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

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

ArrayList outerList=new ArrayList（）；
对于（i=0；i，在我看来，计算结果是正确的。您的第一个代码示例有一个内部循环。这比第二个示例的值成倍增加

简单地说，第二个示例将第一个循环迭代5000次，然后第二个循环迭代5000次

第一个示例将对内循环进行5000次迭代，对于外循环的每个循环（另外5000次），您将得到OutList.get（i）.add（1）的5000*5000次迭代

我希望这能回答你的问题

它们都有不同的记忆足迹还是相同的记忆足迹

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

这两种情况下的数据结构不是都一样吗

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

代码示例1：它将创建5000个不同的列表，填充值为1的5000倍，全部保存在外部列表：5000+1=5001个不同的列表中

代码示例2:outerList包含5000次相同的列表（用5000次值1填充）：1+1=2个不同的列表

两者都不同，代码示例1将运行25000次，并添加5000个不必要的列表。第一个示例将运行5000^2次，而第二个示例仅运行10000次。我知道迭代次数。但这里的问题是关于内存。提示：在第二种情况下，您可以看到两个新的运算符。第一个示例中有多少个运算符？因此，当我做ARAYLIST.Adx（x）时，X不是一个拷贝，而是原来的数组本身。是的，java类是引用类型。每个赋值复制引用，但不是复制数组本身。假设对于C++是有效的（当然，如果不将指针存储到向量）但是JavaI并没有编辑这个问题，把我的观察结果包含在JavaScript中。你能回答为什么JavaScript中的内存是一样的吗？它是否像C++？你确定你的函数是正确的吗？如果你的数组应该包含100个元素，它怎么返回52？我来检查一下。谢谢：
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);
}

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
*/