警告：[unchecked] 未经检查地调用 compareTo(T) 作为原始类型 Comparable 的成员

Question

我最近在 10 年后回到 Java，但我已经很生疏了。我正在尝试运行我拥有的一些基本排序列表代码。此代码用于编译和运行，但现在我收到以下警告：

.\LinkedList.java:30: warning: [unchecked] unchecked call to compareTo(T) as a member of the raw type Comparable
                    return _data.compareTo( ((Node)n)._data );
                                          ^
where T is a type-variable:
T extends Object declared in interface Comparable

这是引发警告的代码：

static protected class Node implements Comparable
{
    public Node _next;
    public Comparable _data;
    
    protected Node(Comparable data, Node next)
    {
        _next = next;
        _data = data;
    }
    
    public int compareTo(Object n)
    {
        return _data.compareTo( ((Node)n)._data );
    }
    
    public String toString()
    {
        return _data.toString();
    }
    
} // end Node class

我的理解是我不能再在原始类型上使用 compareTo()，但我不确定如何修复它。欢迎任何帮助。 堆栈溢出也是新的，所以如果我做错了或错过了已经回答的地方，请原谅我。

Answer 1

有两（三）种不同的订购方式：

1. 类本身实现的自然顺序行为
2. 在代码中实现的特定于任务的订单行为
3. 两者兼而有之，因为它们是兼容的。

一般：

Comparable 是一个通用类，所以你应该实际使用Comparable<T>（T 是一个类类型），在你的例子中反射性地使用它作为Comparable<Node> 所以编译器知道你有一个 comparable Node 您想与另一个（可比较的）节点进行比较。

Ordering Type 1：Comparable<T> 用于当您对元素具有自然排序并且元素决定其自身的排序行为时使用。

你的代码重做：

1：可以与Ts比较的节点，这通常是有问题的：

public class Node<T extends Comparable<T>> implements Comparable<T> {
    public Node<T>  _next;
    public T        _data;

    protected Node(final T data, final Node<T> next) {
        _next = next;
        _data = data;
    }

    @Override public String toString() {
        return _data.toString();
    }

    @Override public int compareTo(final T pO) {
        return _data.compareTo(pO);
    }

} // end Node class

2：可以与其他节点进行比较的节点，并且它所包含的T也必须是Comparable：

这是您将在您的情况下使用的默认实现。

public class Node<T extends Comparable<T>> implements Comparable<Node<T>> {
    public Node<T>  _next;
    public T        _data;

    protected Node(final T data, final Node<T> next) {
        _next = next;
        _data = data;
    }

    @Override public String toString() {
        return _data.toString();
    }

    @Override public int compareTo(final Node<T> pO) {
        return _data.compareTo(pO._data);
    }

} // end Node class

排序类型 2：使用特定任务排序：

这与上述情况相反。在这里，决定排序的不是元素，而是手头的任务：

类的代码不一定需要（但仍然可以）指定排序实现。但是随后使用特定排序Comparator 对特定内容进行排序：

import java.util.ArrayList;
import java.util.Collections;

public class MyClass {

    public final int    mAge;
    public final String mName;
    public final float  mValue;

    protected MyClass(final int pAge, final String pName, final float pValue) {
        mAge = pAge;
        mName = pName;
        mValue = pValue;
    }

    @Override public String toString() {
        return "MyClass [mAge=" + mAge + ", mName=" + mName + ", mValue=" + mValue + "]";
    }



    public static void main(final String[] args) {
        final ArrayList<MyClass> list = new ArrayList<>();
        list.add(new MyClass(12, "Chris", 13.7f));
        list.add(new MyClass(14, "Anna", 18.7f));
        list.add(new MyClass(33, "Bob", 3.7f));


        printList("Unordered", list);

        // sort by age
        Collections.sort(list, (p, q) -> p.mAge - q.mAge);
        printList("Sorted by age", list);

        // sort by Name
        Collections.sort(list, (p, q) -> p.mName.compareTo(q.mName));
        printList("Sorted by name", list);

        // sort by Value
        Collections.sort(list, (p, q) -> (int) Math.signum(p.mValue - q.mValue));
        printList("Sorted by value", list);
    }

    private static void printList(final String pMessage, final ArrayList<MyClass> pList) {
        System.out.println(pMessage);
        for (final MyClass item : pList) {
            System.out.println(item);
        }
        System.out.println();
    }

} 

...当然还有第 3 类，您可以将两者混合使用，即在混合中的某处有一个 implements Comparable<> 并使用它