多維數組聲明中的順序是否對已用內存有影響？

Question

將爲a和b分配多少個字節？

import android.graphics.Bitmap; 

Bitmap[][][] a = new Bitmap[1000][2][2]; 
Bitmap[][][] b = new Bitmap[2][2][1000]; 

請注意，我只詢問純數組採用的內存，裏面沒有任何對象。

_{爲什麼我問？因爲我正在編寫Android遊戲。對我而言，順序無關緊要，但如果存在內存差異，則可以節省一些內存。}

Answer 1

是的，它確實有所作爲。

在Java中，二維數組是一維數組的數組，而數組（除了所有對象之外）還有頭部，除了保存元素本身所需的空間外。

所以考慮int[10][2]與int[2][10]，並假設一個32位的JVM。

• int[2][10]由2個元素的一個數組和2個10個元素的數組組成。總共 - 3個數組對象+ 22個元素。
• int[10][2]由10個元素的一個數組和10個2元素的數組組成。總共 - 11個數組對象+ 30個元素。

如果我們假設報頭大小是3個32位字（通常用於一個32位JVM）和參考是1個32位字，然後

• int[2][10]需要3 * 3 + 22 * 1 = 31個字= 124個字節
• int[10][2]需要11 * 3 + 30×1 = 63個字= 252個字節

應用相同的邏輯和可以用維數較高的估計的陣列的大小。

但很顯然，如果最大尺寸是最右側的尺寸，則可以使用更少的空間。

---

_{我已經做了數學與int陣列，但在32位機器上的int和reference佔用相同的字節數。在64位機器上，參考的大小可能與int或long的大小相同，具體取決於JVM選項。標題大小也可能不同......不完全確定...可能依賴於平臺。}

_{我還沒有考慮過持有Bitmap對象本身所需的空間，但它是相同的，但是您組織陣列。}

Answer 2

沒有內存差異，但是您的數組索引的順序可能在理論上對您的程序速度產生影響 。

您通常在嵌套循環中處理多維數組內容。所以你的數組應該按照你在內部循環中處理相鄰元素的方式進行組織，以便編譯器生成最高效的代碼。我不知道的Java是如何組織的內存，但認爲這是不是不同的C/C++：

int a[10][100]; 
for (i = 0; i < 10; ++i) { 
    for (j = 0; j < 100; ++j) { 
     do_something_with(a[i][j]); 
    } 
} 

Answer 3

當嘗試它在熱點（準確的數字可能與你所得到的Dalvik不同，但結論應該是相似），I得到的結果如下：

對象陣列（1000x2x2）：76034個字節
對象陣列（2x2x1000）：16137個字節

這是符合粗略計算：

[2][2][1000]      
Array #  Header Size Memory Number Total 
1    16  2  24  1  24 
2    16  2  24  2  48 
3    16 1000 4016  4 16,064 

         Grand Total  16,136 


[1000][2][2]      
Array #  Header Size Memory Number Total 
1    16 1000 4016  1 4,016 
2    16  2  24 1000 24,000 
3    16  2  24 2000 48,000 

         Grand Total  76,016 

---

測試下面的代碼，以-XX:-UseTLAB運行以獲得更準確的結果。

public class TestMemory { 

    private static final int SIZE = 100; 
    private static Runnable r; 
    private static Object o; 

    private static void test(Runnable r, String name, int numberOfObjects) { 
     long mem = Runtime.getRuntime().freeMemory(); 
     r.run(); 
     System.out.println(name + ": " + (mem - Runtime.getRuntime().freeMemory())/numberOfObjects + " bytes"); 
    } 

    public static void main(String[] args) throws Exception { 
     r = new Runnable() { public void run() { for (int i = 0; i < SIZE; i++) o = new Object[1000][2][2];} }; 
     test(r, "Object array (1000x2x2)", SIZE); 

     r = new Runnable() { public void run() { for (int i = 0; i < SIZE; i++) o = new Object[2][2][1000];} }; 
     test(r, "Object array (2x2x1000)", SIZE); 
    } 
} 

Answer 4

是的，它是有差別的。只是-Xmx8M試試這個：

// throws OutOfMemoryError 
public static void main(String[] args) { 
    int[][] a = new int[500000][2]; 
    System.out.println("a.length: '" + (a.length) + "'"); 
} 

// works 
public static void main(String[] args) { 
    int[][] a = new int[2][500000]; 
    System.out.println("a.length: '" + (a.length) + "'"); 
} 

第一個將拋出一個OutOfMemoryError，第二個會傳球。

原因是，第一個版本創建500.000長度爲2的數組，而第二個創建長度爲500.000的2個數組。

Reference：

在如C語言，一個二維陣列（或實際上任何多維數組）本質上是一維陣列，明智的指針操作。在Java中，情況並非如此，多維數組實際上是一組嵌套數組。這意味着二維數組的每一行都有一個對象的開銷，因爲它實際上是一個單獨的對象！