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

Question

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

.\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. 由Class本身实现的自然顺序行为
2. 在代码中实现的特定于任务的订单行为
3. 两者的结合，因为它们兼容。

一般：

Comparable 是通用 Class，因此您实际上应该使用 Comparable<T>（T 是 class 类型），在您的示例中反身使用它作为 Comparable<Node> 所以编译器知道你有一个 comparable Node 要与另一个（可比较的）节点进行比较。

排序类型 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：使用特定于任务的排序：

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

Class 的代码 不一定需要 （但仍然可以）指定排序实现。但是随后的排序是在特定内容上以特定顺序完成的 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<> 并使用它