Question

class Node<T extends Number> implements Comparable<Node<T>>{
private T data;
private Node<T> next;
private Node<T> prev;

public Node(T data){
    this.data = data;
    next = null;
    prev = null;
}

public int compareTo(Node<T> o){
    if(o.data > this.data){
        return -1;
    }else if(o.data < this.data){
        return 1;
    }else{
        return 0;
    }
}

我写了上面的代码，当我尝试编译它时，我得到了

    Queue.java:14: error: bad operand types for binary operator '>'
            if(o.data > this.data){
                      ^
  first type:  T
  second type: T
  where T is a type-variable:
    T extends Number declared in class Queue.Node

    Queue.java:16: error: bad operand types for binary operator '<'
            }else if(o.data < this.data){
                            ^
  first type:  T
  second type: T
  where T is a type-variable:
    T extends Number declared in class Queue.Node
    2 errors

这样你就不会对Queue.node感到困惑，类节点嵌入在类队列中

所以我猜测Java不会自动取消装箱号码但是有办法吗？

由于

Answer 1

您可以使用doubleValue()：

class Node<T extends Number> implements Comparable<Node<T>>
{
    private T data;
    private Node<T> next;
    private Node<T> prev;

    public Node(T data)
    {
        this.data = data;
        next = null;
        prev = null;
    }

    public int compareTo(Node<T> o)
    {
        if(o.data.doubleValue() > this.data.doubleValue()) return -1;
        else if(o.data.doubleValue() < this.data.doubleValue()) return 1;
        else return 0;
    }
}

Answer 2

Number类是抽象的，不能像扩展它的类那样使用。

例如：

// this doesnt work
Number a = 22;
Number b = 33;
Number c = a - b; // compile error
if(a > b) // compile error

您需要比较这些Number对象的某些值。

// this works
Number a = 22;
Number b = 33;
Number c = a.doubleValue() - b.doubleValue();
if(a.longValue() > b.longValue())

因此，为了修复您的代码，您的语句应为if(o.data.doubleValue() > this.data.longValue())

Answer 3

所以我猜测Java不会自动取消装箱号码

这是正确的。只有当您尝试使用的表达式的静态类型是原始包装类型之一时，才能进行取消装箱; e.g。

    Number n = ...
    int i = 1 + n;               // Compilation error
    int j = 1 + ((Integer) n);   // OK ... provided the cast is going to work.

但有办法吗？

如果您知道Number是特定类型，那么您可以按上述方式进行投射。否则，您可以明确调用相应的...Value()方法。

    int j = 1 + n.intValue();

但是，您无法使运算符（'+'，'＆gt;'等等）表现得像Number类的重载一样。

Answer 4

不要打扰T作为Number：T extend Comparable<T>，并将其作为return this.data.compareTo(o.data)实施。

Answer 5

您可以在节点Type上使用intValue（）方法，它将返回整数值。其他数据类型也可以使用类似的方法（doubleValue（），longValue（）等。）。

以下代码片段如下：

public int compareTo(Node<T> o){
   if(o.data.intValue() > this.data.intValue()){
      return -1;
    }else if(o.data.intValue() < this.data.intValue()){
      return 1;
    }else{
       return 0;
    }
}

Answer 6

您应该使用intValue()或方法（或其他任何版本，如果您需要long或double。如果不是Integer也可以使用1}}。

public int compareTo(Node<T> o){
    if(o.data.intValue() > this.data.intValue()){
        return -1;
    }else if(o.data.intValue() < this.data.intValue()){
        return 1;
    }else{
        return 0;
    }
}

Answer 7

虽然你提出的要求一般是不可能的，但在这种情况下你可以使用Number的所有子类也实现Comparable的事实。如果你添加＆amp;与T的定义相比，您可以简单地比较这些值。

在Java中，是否可以将Number拆分为适当的类型？

7 个答案: