线程“ main”中的异常java.lang.ClassCastException：java.lang.Integer无法转换为q3.Box

Question

我不知道这里发生了什么。 我正在尝试创建一个通用的max方法来处理各种数组类型，但是我不明白我在哪里试图将Integer转换为Box。 我在这里很新，所以任何帮助将不胜感激。

我可以做的一件事是保存该最大值的Object max = 0行。 我选择Object是因为它可以容纳任何东西（据我所知），但是首先将其设置为0并没有多大意义，但是我想不出任何其他可行的方法。

编辑：还有一件事，当我使用Doubles进行测试时，它会引发相同的错误，但是java.lang.Integer cannot be cast to java.lang.Double但这再次对我没有意义。 我要在哪里撒这些东西？ 一定是max吗？

这是我的代码：

包q3;

import java.util.Random;

public class Biggest {

public static Object max(Comparable[] x) {

    Object max = 0;

    for (int i = 0; i < x.length; i++) {
        System.out.println("Comparing " + x[i] + " to " + max);
        if (x[i].compareTo(max) > 0) {
            max = x[i];
        }
    }
    return max;
}

public static void main(String[] args) {

    Integer[] ai = new Integer[10];
    Double[] ad = new Double[10];

    fillInts(ai);
    fillDoubs(ad);
    System.out.println("Max ints: " + max(ai));
    //System.out.println("Max doubles: " + max(ad, ad.length));


    ///// boxes/////////

    Box[] boxes = new Box[5];
    fillBoxes(boxes);
    System.out.println(max(boxes));


}



private static void fillBoxes(Box[] boxes) {

    // random class for each of the dimension

    Random a = new Random();
    Random b = new Random();
    Random c = new Random();

    int l, w, h;

    for (int i = 0; i < boxes.length; i++) {
        l = a.nextInt(30);
        w = b.nextInt(30);
        h = c.nextInt(30);

        boxes[i] = new Box(l, w, h);
    }

}



private static void fillDoubs(Double[] ad) {
    Random r = new Random();
    for (int i = 0; i < ad.length; i++) {
        ad[i] = 1.0 * r.nextDouble();
    }

}

private static void fillInts(Integer[] ai) {
    Random r = new Random();
    for (int i = 0; i < ai.length; i++) {
        ai[i] = r.nextInt(100);
    }
}

}

Answer 1

文字0始终是int类型，因此Object max = 0; 实际上是隐式Object max = Integer.valueOf(0); 由于自动装箱。 这意味着max始终以实际类型为Integer的值开始。

例如，由于Double.compareTo需要Double参数，因此在将Integer传递给它时会引发异常。

为什么确切地引发类强制转换异常的解释有些复杂，但这是由于Java泛型的实现（通过类型擦除）而引起的 。 由于Comparable是通用接口，因此当我们覆盖compareTo ， 编译器会生成称为bridge方法的东西，如下所示：

public final class Double implements Comparable<Double> {
    // ...

    // generated bridge method
    public int compareTo(Object o) {
        return compareTo((Double) o);
    }
    // method which java.lang.Double
    // source code actually declares
    @Override
    public int compareTo(Double that) {
        return compare(this.doubleValue(), that.doubleValue());
    }
}

当你调用compareTo在Comparable ，它实际上调用该方法compareTo(Object) ，它试图参数转换为Double ，然后将它传递给Double.compareTo(Double) 。 实际上是在bridge方法中强制抛出异常的。

通常，您需要自己将零值传递给max方法，如以下示例（也使用泛型）所示：

public static <T extends Comparable<T>> T max(T[] arr, T zero) {
    T max = zero;
    for (T e : arr)
        if (e.compareTo(max) > 0)
            max = e;
    return max;
}

另一种方法是这样的：

public static <T extends Comparable<T>> Optional<T> max(T[] arr) {
    if (arr.length == 0)
        return Optional.empty();
    T max = arr[0];
    for (int i = 1; i < arr.length; ++i)
        if (arr[i].compareTo(max) > 0)
            max = arr[i];
    return Optional.of(max);
}

另请参阅什么是原始类型，为什么我们不应该使用它呢？