list.add方法的内存原理

Question

 public static void testForProblem() {  
    // 一些朋友在向循环里向列表增加对象的时候  
    // 经常忘记初始化，造成最终加入的都是同一个对象  
    List<MyObject> list = new ArrayList<MyObject>();  
    MyObject obj = new MyObject();  
    for (int i = 1; i <= 5; i++) {  
      obj.setName("Name" + i);  
      list.add(obj);  
    }  
    // 里面的数据都是最后一个  
    showList(list); // [Name5, Name5, Name5, Name5, Name5]  
  
    // 正确的做法  
    List<MyObject> list2 = new ArrayList<MyObject>();  
    MyObject obj2 = null;  
    for (int i = 1; i <= 5; i++) {  
      obj2 = new MyObject();  
      obj2.setName("Name" + i);  
      list2.add(obj2);  
    }    
    showList(list2); // [Name1, Name2, Name3, Name4, Name5]  
  }  
  /** 
   * 显示List里面的数据。 
   *  
   * @param list 
   */  
  private static void showList(List list) {  
    System.out.println(Arrays.toString(list.toArray()));  
  }  
}  
  
class MyObject {  
  private String name;  
  
  public String getName() {  
    return name;  
  }  
  
  public void setName(String name) {  
    this.name = name;  
  }  
  
  /** 
   * 重写toString方法，输出name 
   */  
  public String toString() {  
    return name;  
  }  
我想知道 add  方法 在 内存中是如何运行的。
是不是在 new ArrayList 的时候 开辟的一个  空间 ，  然后add（obj）的时候，list添加个指针， 就把指针指向obj的地址了？
如果是这样的话 我就理解了。
不是的话 请回答

Answer 1

楼主理解是对滴
 new ArrayList 的时候 开辟的一个  空间 ，  然后add（obj）的时候，list添加个指针， 就把指针指向obj的地址了

Answer 2

在new ArrayList()时开辟了一个默认是10的ArrayList()空间如果ADD后的长度大于现有ArrayList SIZE的长度，则增加一部分空间。source code如下
int oldCapacity = elementData.length;
if (minCapacity > oldCapacity) {
    Object oldData[] = elementData;
    int newCapacity = (oldCapacity * 3)/2 + 1;//增加空间
         if (newCapacity < minCapacity)
newCapacity = minCapacity;//如果增加的空间还不能满足，则用新的空间（可能是针对ADD(list)的情况）
    elementData = (E[])new Object[newCapacity];
    System.arraycopy(oldData, 0, elementData, 0, size);
}

Answer 3

public  void add(int index,
    E element) {
        rangeCheckForAdd(index);
        ensureCapacity(size+1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        elementData[index] = element;
        size++;
}
public  void ensureCapacity(int minCapacity) {
        modCount++;
        int oldCapacity = elementData.length;
        if (minCapacity  > oldCapacity) {
            Object oldData[] = elementData;
            int newCapacity = (oldCapacity * 3)/2 + 1;
            if (newCapacity <  minCapacity)
                newCapacity = minCapacity;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
}

Answer 4

right  回复内容太短了！