时间戳

首页 > 解决方案 > 警告：[unchecked] 作为原始类型 Comparable 的成员对 compareTo(T) 的未经检查的调用

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

问题描述

我最近在 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()，但我不确定如何修复它。欢迎任何帮助。堆栈溢出也是新的，所以如果我做错了或错过了已经回答的地方，请原谅我。

标签： javalinked-listcomparablecomparetounchecked

解决方案

有两（三）种不同类型的订购：

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

一般来说：

Comparable是一个通用类，所以你应该实际使用Comparable<T>（T 是一个类类型），在你的例子中反身使用它，因为Comparable<Node>编译器知道你有一个可比较 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：使用特定于任务的订购：

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

类的代码不一定需要（但仍然可以）指定排序实现。但是随后使用特定顺序对特定内容进行排序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<>在混合中的某个地方并使用它

推荐阅读