线程main java.lang.ClassCastException异常:无法将java.lang.Integer强制转换为q3.Box

Question

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

我能做的一件事就是Object max = 0行，它保存了最大值。我选择Object是因为它可以容纳任何东西(据我所知)，但一开始将它设置为0没有多大意义，但我想不出有什么其他方法可以工作。

编辑:还有一件事，当我用Double测试它时，它抛出了同样的错误，但对于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泛型的实现，这是通过type erasure实现的。因为Comparable是一个通用接口，所以当我们覆盖compareTo时，the compiler generates something called a bridge method看起来像这样：

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());
    }
}

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

通常，您需要自己将零值传递给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);
}

另请参阅What is a raw type and why shouldn't we use it?