Question

Java代码示例1：

ArrayList<ArrayList<Integer>> outerList = new ArrayList<ArrayList<Integer>>();
for(i=0; i<5000; i++){  
    outerList.add(new ArrayList<Integer>());
    for(j=0; j<5000; j++){
        outerList.get(i).add(1);
    }
}

Java代码示例2：

ArrayList<ArrayList<Integer>> outerList_n = new ArrayList<ArrayList<Integer>>();
ArrayList<Integer> innerList_n = new ArrayList<Integer>();

for(j=0; j<5000; j++){
    innerList_n.add(1);
}   
for(i=0; i<5000; i++){  
    outerList_n.add(innerList_n);
}

描述：

代码示例1每次创建一个新的arrayList以添加到外部列表，尽管innerList的每个条目始终为1。

代码示例2创建一个数组，所有条目都为1，然后将其添加到for循环中的outerList。

问题：

1）它们是否都有不同的记忆足迹或相同？我用jdk.nashorn.internal.ir.debug.ObjectSizeCalculator来计算它，结果如下：

outerList的大小：514907072

outerList_n的大小：130048

2）我不明白为什么上面的内存不同。两种情况下的数据结构都不相同吗？

3）这是javascript中的相同情况吗？当我为上述2个场景尝试javascript的相应代码时，我在两种情况下都获得了相同的内存占用。

Javascript代码：

function sizeof(object){

  // initialise the list of objects and size
  var objects = [object];
  var size    = 0;

  // loop over the objects
  for (var index = 0; index < objects.length; index ++){

    // determine the type of the object
    switch (typeof objects[index]){

      // the object is a boolean
      case 'boolean': size += 4; break;

      // the object is a number
      case 'number': size += 8; break;

      // the object is a string
      case 'string': size += 2 * objects[index].length; break;

      // the object is a generic object
      case 'object':

        // if the object is not an array, add the sizes of the keys
        if (Object.prototype.toString.call(objects[index]) != '[object Array]'){
          for (var key in objects[index]) size += 2 * key.length;
        }

        // loop over the keys
        for (var key in objects[index]){    
          // determine whether the value has already been processed
          var processed = false;
          for (var search = 0; search < objects.length; search ++){
            if (objects[search] === objects[index][key]){
              processed = true;
              break;
            }
          }    
          // queue the value to be processed if appropriate
          if (!processed) objects.push(objects[index][key]);    
        }    
    }    
  }    
  // return the calculated size
  return size;    
}

// TWO SEPARATE FOR LOOPS
var start = new Date().getTime();
var i,j ;
var inner_arr1 = [];
var outer_arr1 = [];
for (i = 0; i < 100; i++) {
    inner_arr1.push("abcdefghijklmnopqrstuvwxyz");
}
for (j = 0; j < 100; j++) {
    outer_arr1.push(inner_arr1);
}
var end = new Date().getTime();
print("size of outer_arr1: "+sizeof(outer_arr1));
print("time of outer_arr1 (in ms): "+(end-start))


// NESTED FOR LOOPS
var start = new Date().getTime();
var outer_arr2 = [];
for (j = 0; j < 100; j++) {
    var inner_arr2 = [];    
    for (i = 0; i < 100; i++) {
        inner_arr2.push("abcdefghijklmnopqrstuvwxyz");   
    }
    outer_arr2.push(inner_arr1);    
}
var end = new Date().getTime();
print("size of outer_arr2: "+sizeof(outer_arr2));
print("time of outer_arr2 (in ms): "+(end-start))


/*
COMMAND:
jjs findingSize.js

OUTPUT:
size of outer_arr1: 52
time of outer_arr1 (in ms): 45
size of outer_arr2: 52
time of outer_arr2 (in ms): 58
*/

Answer 1

它们是否都有不同的内存占用或相同？

不同。在第一种情况下，您将创建5001个ArrayList实例。在第二个中，您只创建了两个ArrayList实例

两种情况下数据结构都不相同吗？

两种情况下的数据结构都相同 - 您有阵列数组。唯一的区别是，在第二种情况下，所有内置数组都是相同的 - 它们共享公共内存，当您在某行中更改值时，所有行都将被更改

Answer 2

代码示例1 ：它将创建5000 不同的 Lists，其值为值1的5000倍，全部保存在outerList中：5000 + 1 = 5001个不同的列表
代码示例2 ：outerList包含相同列表的5000倍（填充5000次值1）：1 + 1 = 2个不同解释

Answer 3

在我看来，评估是正确的。您的第一个代码示例具有内部循环。这比第二个样本指数多。

说白了，第二个样本将循环第一个循环5000次，然后第二个循环重复5000次。

第一个例子将迭代内部循环5000次，对于外部循环的每个循环（另外5000次），因此你得到5000 * 5000次的外部列表.get（i）.add（1）。

我希望这能回答你的问题。

两个代码片段之间的内存差异

3 个答案: