不同语言的数组 - 存储引用或原始对象？

Question

我正在努力思考在使用数组时原始内存在不同语言中的样子。

考虑以下 Java 代码：

String a = "hi";
String b = "there";
String c = "everyone";
String[] array = {a, b, c};

显然数组包含引用，而不是对象；也就是说，内存中有一个包含三个引用的连续数组，每个引用都指向内存中对象所在的某个其他位置。所以对象本身不一定位于三个连续的桶中；而是引用。

现在考虑一下：

String[] array = {"hi", "there", "everyone"}

我想在这种情况下，字符串与内存中的所有其他常量一起存在于某个地方，然后数组保存对内存中这些常量的引用？所以，再一次，在原始内存中，数组看起来不像 ['h', 'i', '[=14=]', 't', 'h', 'e', 'r', 'e'... (etc)]。（为方便起见，使用 c 风格的终止）。相反，它更像是 ['a83a3edf' ,'a38decd' ... (etc)]，其中每个元素都是一个内存位置（引用）。

我从这个思考过程中得出的结论是，在 Java 中，您永远无法将数组想象成内存中连续对象的桶，而是连续引用。我想不出任何方法来保证对象将始终连续存储在 Java.

中

现在考虑 C:

char *a = "hi";
char *b = "there";
char *c = "everyone";
char *array[] = {a, b, c};

上面的代码在功能上等同于上面的 Java——也就是说，数组包含对其他内存位置的引用（指针）。与 Java 一样，指向的对象不一定是连续的。

但是，在以下 C 代码中：

struct my_struct array[5];  // allocates 5 * size(my_struct) in memory! NOT room for 5
                            // references/pointers, but room for 5 my_structs.

array 中的结构连续位于原始内存中。

现在我的具体问题是：

我的假设是否正确，在 Java 中，数组必须始终包含引用，因为程序员只能访问 Java 中的引用？原始数据类型呢？那么它的工作方式会有所不同吗？ Java 中的 int 数组在原始内存中看起来就像 C 中的数组一样吗（除了 Object class cruft Java 会添加）？
在Java中，程序员就没有办法保证对象的内存分配是连续的吗？这可能是偶然发生的，或者很有可能发生，但程序员不能保证一定会发生吗？
在 C 中，程序员可以在内存中连续创建对象（结构）的原始数组，正如我上面所展示的，对吗？
其他语言如何处理这个问题？我猜 Python 就像 Java?

这个问题的动机是我想深入了解这些语言中数组在原始内存级别发生的情况。主要针对程序员面试问题。我在之前的一次采访中说过，数组（不是任何语言，只是一般意义上的）像桶一样在内存中连续保存对象。只是在我说了这句话之后，我才意识到在像 Java 这样的语言中，这并不是它的工作方式。所以我想 100% 清楚它。

谢谢。如果有任何需要澄清的地方，请告诉我。

Answer 1

you can never ever imagine arrays as buckets of contiguous objects in memory, but rather as contiguous references.

理论上你是对的，实际上，JVM 不会随机化内存访问。它按顺序分配内存并在 GC 期间按发现顺序（或相反顺序）复制对象

Was I correct in my assumption that in Java, arrays must ALWAYS hold references, as the programmer only ever has access to references in Java?

是的，当然，除非你有一个基元数组。

What about for raw data types? Will it work differently then?

基元和引用在内存中是连续的。基本相同

Will an array of ints in Java look just like one in C in raw memory (besides the Object class cruft Java will add)?

是的。

In Java, is there no way for the programmer to guarantee contiguous memory allocation of objects?

除非您使用堆外内存，否则不会。虽然一般来说这并不像您想象的那么严重大多数时候，但对象在内存中是连续的。

It might happen by chance, or with high probability, but the programmer can not GUARANTEE it will be so?

正确。当您看到最差的 0.1% 或更高延迟时，通常您会遇到更大的问题。

In C, programmers CAN create raw arrays of objects (structs) contiguously in memory, as I have shown above, correct?

是的。您也可以在 Java 中执行此操作，但您必须使用堆外内存。有许多库支持此功能，例如 Javolution、Chronicle、SBE。

Answer 2

像 C 这样的低级语言让你处理内存布局，以及你是否有一个指向其他地方的指针或一个值就在这里。确保正确处理堆栈与堆分配，并且不要忘记 free() 每个指针 malloc()。

Java、Python 和 JavaScript 等高级语言消除了内存的低级布局。所有对象都在堆上，您可以引用它。虽然引用类似于指针，但它是不透明的并且不直接与给定的内存位置相关联。因此，所有数据结构都包含对对象的引用。

Answer 3

to 1) 在java中数组是对象，对象和数组存储在堆上，因为堆可能不连续，所以数组也可能不连续。

4) 在 python 中你可以创建一个连续的数组，如果你使用 scipy

Answer 4

我不能和Java说任何细节，虽然我的理解是给定以下代码

int arr[] = new int[N];

本地（堆栈）变量 arr 包含对堆上数组对象的引用，为我们提供如下布局：

          +---+
     arr: |   |---+
          +---+   |
           ...    |
          +---+   |
      cp: |   |<--+  class pointer 
          +---+ 
     flg: |   |      flags
          +---+
     lck: |   |      locks
          +---+
      sz: |   |      size
          +---+
  arr[0]: |   |
          +---+
  arr[1]: |   |
          +---+
           ...
          +---+
arr[N-1]: |   |
          +---+

对于基本类型的数组，值直接存储在arr[0]、arr[1]等中。对于class类型的数组，数组的每个元素存储一个引用那个 class 的一个实例，所以还有另一个间接级别。引用本身是连续存储的，但它们指向的实例不是（或者至少不保证是）。

C 和 C++ 数组要简单得多。给定以下代码：

 int arr[N];

你得到以下内容：

          +---+
  arr[0]: |   |
          +---+ 
  arr[1]: |   |
          +---+ 
           ...
          +---+
arr[N-1]: |   |
          +---+

C 数组不涉及间接寻址或元数据。没有为指向数组第一个元素的对象 arr 预留存储空间。如果数组具有 auto 范围（意味着它是在块内声明的，而不是 static），则数组元素的内存分配与任何局部变量相同。

对于任何类型 T，T arr[N] 将留出 N 个连续元素来存储类型 T 的值。如果 T 是令人讨厌的 struct 类型，那么 T a[N] 存储 N 该令人讨厌的 struct 类型的连续实例。

不同语言的数组 - 存储引用或原始对象？

Arrays in different languages - store references, or raw objects?

c

java

arrays

jvm