Java 泛型函数调用

Question

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

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);          
    }       
}

现在我正在尝试使链接列表通用，以便它也可以是整数，字符串或其他对象的Linklist。

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

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

在Linklist的 ADD 函数中，我比较了对象（包装在节点中）以找出我必须添加新对象/节点的位置

这是我的自定义链接列表类和节点类

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;
                }
            }
        }
    }
}   

现在，我想将比较逻辑保留在对象类（汽车类）中，以便将来要进行的任何更改（如果我想比较例如的价格）都将对汽车类进行。

由于我试图使它通用，以便我可以使用Linklists来保存其他对象（这也将具有compareTo函数），这部分代码：

public int compareTo(Node<E> newNode){
            return this.data.compareTo(newNode.data);       
        }

不允许调用 compareTo 函数并给出错误"compareTo(E) 未定义类型 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型都知道如何比较自己。