java 数组到底是如何工作的

Question

有人能解释一下数组在 Java 中是如何工作的吗？

我对下面的代码感到惊讶：

        Object test = new Object[2][2];
        Object test2 = new Object[] {
                new Object[2],new Object[2]
        };
        Object test3 = new Object[2][];
        ((Object[])test3)[0] = new Object[2];
        ((Object[])test3)[1] = new Object[2];
        System.out.println(test instanceof Object[]);
        System.out.println(test instanceof Object[][]);
        System.out.println(test2 instanceof Object[]);
        System.out.println(test2 instanceof Object[][]);
        System.out.println(test3 instanceof Object[]);
        System.out.println(test3 instanceof Object[][]);

只有test2不是Object[][]的实例，

运行时有什么区别？

编辑：我看到一些答案。 Jon Skeet，请注意我可以这样做：

Object[] test4 = (Object [])test;
test4[0] = "blaaa";
test4[1] = "toto";
System.out.println(test4);

test instanceof Object[] 返回 true，并且在运行时不会引发任何异常。根据 Sierra & SCJP 的书，贝茨，测试 IS-A Object[][] 但也是一个 Object[]

但是当尝试使用“test4[0] =”blaaa“;”重新分配新值时，我得到一个异常： 线程“main”中的异常 java.lang.ArrayStoreException：java.lang.String at Main.main(Main.java:24)

所以看起来在运行时，test和test2都是IS-A Object[]，并且都包含对象数组，但只有其中之一是IS-A Object[][]

Answer 1

Test2 仅被声明为对象数组。它包含的对象恰好也是数组，但这没有声明。这就是区别。

Answer 2

test2 指的是包含两个元素的数组。它的类型只是Object[] - 因此这些元素可以引用任何对象。特别是，您可以这样写：

// Valid
Object[] foo = (Object[]) test2;
foo[0] = "hello";

而 不会 适用于 test：

// Invalid - test isn't just an Object[], it's an Object[][]
Object[] foo = (Object[]) test;
test[0] = "hello";

因为 test 引用的数组的元素类型是 < code>Object[] 而不是 Object。数组“知道”每个元素应该为 null 或对 Object[] 的引用，因此 VM 将阻止它存储字符串。

您可以将 test 转换为 Object[]，就像将 String[] 转换为 Object[] 一样 - 这就是所谓的数组协方差，在我看来，允许它是一个错误。正如我们所见，虚拟机必须在执行时检查存储。

Answer 3

我没有找到任何完整的答案来回答我的问题，我会这样做......

读完 SCJP 书后，我对它更加清楚了。它只是在泛型一章而不是数组一章中进行了处理。 （泛型与数组）
乔恩·斯基特的回答很好，但对我来说似乎不完整。

所以你必须理解泛型和数组的区别。

泛型只是一种“编译安全性”。运行时没有检查。这意味着，通过以下技巧，您可以将字符串对象插入到集合中

public static void main(String [] args) {
    Set<Integer> set = new HashSet<Integer>();
    set.add(1);
    set.add(2);
    addString(set,"test");
    for ( Object o : (Set)set ) {
        System.out.println(o);
    }
    for ( Object o : set ) {
        System.out.println(o);
    }
}

public static void addString(Set set,String s) {
    set.add(s);
}

输出为：

1
2
test
1
2
ClassCastException

http://www.ideone .com/nOSQz

请注意，代码编译（带有警告）并运行得很好，直到您将该集合与 Set 引用一起使用，因为有一个隐式强制转换会尝试将字符串转换为整数...

这样做的原因有很多（并非全部在书中公开），例如追溯兼容性，以及需要能够调用遗留代码（非泛型），同时提供非泛型集合。

如果您不调用任何遗留代码而只调用泛型代码，那么您不应该遇到任何这样的问题，您的集合只包含您想要的内容，因为编译器处理了它，并且不需要在运行时进行检查...

因为泛型在运行时没有检查，并尝试防止在集合中插入错误的项目，禁止将 List 转换为 List，或致电method(List) 带有 List 参数，因为这意味着您可以在 List 中插入 Cat > 通过操作 List...

---

数组的工作方式不同。

正如 Jon Skeet 所说，数组具有类型协方差。

因此我们可以将 Dog[] 转换为 Animal[]，因为 Dog 是一种动物。

与泛型一样，Java 希望尽量避免将 Cat 插入到 Dog 数组中。
但由于协变性，它无法在编译时完成。
就像 Jon Skeet 一样，我同意这种协方差也许不是一个好主意，但它是 Java 的遗产......
因此，与泛型相反，数组确实具有运行时检查，以防止将猫插入狗数组。

在运行时，JVM 知道应该在数组中插入什么，而对于泛型则不知道。

---

所以，回到我最初的问题

Object test = new Object[2][2];
Object[] test2 = (Object [])test;
test2[0] = "blaaa";
test2[1] = "toto";
System.out.println(test2);

test（2D 数组）可以转换为 test2（1D 数组），但在幕后它仍然是一个 2D 数组，最终是一个 1D 数组 A1，预计将被其他 1D 数组填充A2 包含对象。

这就是为什么当我在 A1（最后是 test2）中尝试插入一个 String 时引发 ArrayStoreException，它最终是一个 Object，而不是一个 Object[]

---

总结：

由于使用 1D 和 2D 数组，可能会出现一些混乱转换为一维数组，但对于此代码来说，它是完全相同的：

数组：

Dog[] dogs = new Dog[1];
dogs[0] = new Dog();
Animal[] animals = (Animal [])dogs;
animals[1] = new Cat();

这在运行时在第四行失败。
而且你无法将猫插入到狗数组中。

如果我们对泛型做同样的事情，

Set<Dog> dogs = new HashSet<Dog>();
dogs.add( new Dog() );
Set<Animal> animals = (Set<Animal>) dogs;
animals.add( new Cat() );

由于第三行，这不会编译。
但是通过使用旧的泛型代码，您可以将猫插入到狗集中。

Answer 4

test2引用的对象是一个Object[]。

Instanceof 正在测试 test2 引用的对象的类型，而不是数组内容的类型。

运行时数组的内容是Object[]，它可以装入Object[]，因为Object[]是对象。

Answer 5

test2 是您可以放入任何Object 的东西，因为它是通过new Object[] 创建的。您只能将 Object[] 放入 test 和 test3 中，因为它们是通过更严格的构造函数创建的：new Object[ ][]。

Answer 6

您已将 test2 定义为

Object test2 = new Object[];     // This is a plain array of Objects.