Java泛型函数调用

Question

我正在 java 中创建自己的 link 列表数据结构，其中 linked 列表中的每个节点都将保存另一个 class 的对象（汽车 class 例如）。所以它基本上是一个 linked 汽车列表。

public class car {      
    private String carName;
    private double price;

    car(String name,double price){
        this.carName=name;
        this.price=price;   
    }           
    public int compareTo(car newCar)
    {
        return this.carName.compareTo(newCar.carName);          
    }       
}

现在我正在尝试使 link 列表通用，这样它也可以是 Linklist 整数、字符串或其他对象。

customLinklist<cars> newList=customLinklist<cars>()
customLinklist<String> newList=customLinklist<String>()
customLinklist<float> newList=customLinklist<float>()

LinkList 按字母顺序排序，因此当我将汽车添加到列表时，它会按排序方式插入。

在 Linklist 的 ADD 函数中，我比较对象（包裹在节点中）以找出我必须添加新的 object/node

的位置

这是我的 CustomLinklist class 和节点 Class

public class CustomLinkedList<E> {

    public class Node<E>{   
        private E data;
        private Node<E> next;
        private Node<E> back;

        public int compareTo(Node<E> newNode){

            return this.data.compareTo(newNode.data);       
        }

    }


    private Node<E> head,tail;


    CustomLinkedList(){ 
        head=null;  
        tail=null;
    }


    public void add(E newObject){

        if (head==null)
        {
            head=new Node<E>();
            head.data=newObject;
            head.next=null;
            head.back=null;
            tail=head;

        }
        else
        {
            Node<E> currentNode=head,newNode = null;
            Node<E> prevNode;


            newNode=new Node<E>();
            newNode.data=newObject;
            newNode.next=null;
            newNode.back=null;


            while( currentNode.compareTo(newNode)<0 && currentNode.next!=null)
            {
                currentNode=currentNode.next;
            }           


            if(currentNode.next==null && currentNode!=head)
            {
                currentNode.next=newNode;
                newNode.back=currentNode;
                tail=newNode;

            }
            else
            {       
                prevNode=currentNode.back;
                if(currentNode!=head)
                {

                    prevNode.next=newNode;
                }
                newNode.back=prevNode;
                newNode.next=currentNode;
                currentNode.back=newNode;

                if(currentNode==head)
                {

                    head=newNode;

                }
            }

        }

    }

}

现在我想在对象 class( 汽车 class) 中保留比较逻辑，以便将来进行任何更改（如果我想比较价格，例如) 会发到车上 class .

因为我试图让它变得通用，所以我可以使用 Linklists 来保存其他对象（也将具有 compareTo 函数），这部分代码：

public int compareTo(Node<E> newNode){

            return this.data.compareTo(newNode.data);       
        }

不允许调用 compareTo 函数并给出错误 "The method compareTo(E) is undefined for the type E"

我怎样才能使它成为通用的，这样我就可以在不知道对象类型的情况下调用比较函数？

Answer 1

基本上你必须确保链表中的元素是可比较的。您可以使用 Comparable 界面来做到这一点。所以你的链表应该只包含实现 Comparable 接口的元素。你是怎样做的？通过给你的类型参数绑定 E:

class MyLinkedList<E extends Comparable<E>> { ... }

这意味着，为了将 Car 添加到您的列表中，它必须实施 Comparable<Car>。

Answer 2

使用类型约束如下：

public class CustomLinkedList<E extends Comparable>

因此你要求类型 E 必须有一个 compareTo() 方法。并且每种类型 E 都知道如何比较自己。

Java泛型函数调用

Java Generics function calling

java

oop

linked-list

nodes

generic-collections