public static void main(String[] args) {
        // 無參構(gòu)造
        List<Integer> list1 = new ArrayList<>();
        // 給定初始容量
        List<Integer> list2 = new ArrayList<>(10);
        // 使用另外一個 ArrayList對其初始化
        List<Integer> list3 = new ArrayList<>(list2);
        
		list1.add(1);
        list1.add(2);
        list1.add(3);
        // 其父類 AbstractCollection重寫了 toString方法
        System.out.println(list1);// 輸出 [1, 2, 3]

    }

// 遍歷順序表
  for (int i = 0; i < list.size(); i++) {
      System.out.print(list.get(i));
  }
  // for - each 遍歷
  for (String s : list) {
      System.out.print(s);
  }

  // 迭代器打印
  // 獲取迭代器對象
  Iterator<String> iterator = list.iterator();
  while (iterator.hasNext()) {
      // 獲取下一個對象
      String next =  iterator.next();
      // 打印
      System.out.print(next);
  }
  // listIterator ---- 實(shí)現(xiàn)了 Iterator 接口
  ListIterator<String> iterator2 = list.listIterator();
   while (iterator2.hasNext()) {
       String next =  iterator2.next();
       System.out.print(next);
   }

ListIterator<String> iterator2 = list.listIterator();
while (iterator2.hasNext()) {
    String next =  iterator2.next();
    if (next.equals("hello")) {
        iterator2.add("三團(tuán)");// 在 hello 的后面添加 三團(tuán)
    }else{
        System.out.print(next + " ");
    }
}
System.out.println(list);// [hello, 三團(tuán), bit, world]

	List<String> list = new ArrayList<>();
	List<String> listAdd = new ArrayList<>();
	listAdd.add("hello");
	listAdd.add("world");
	listAdd.add("你好~");
	
	list.add("哈哈");// 尾插元素
	list.add(0,"你好"); // 0 下標(biāo)插入 "你好 "
	list.addAll(listAdd);// 將集合 listAdd 中的元素尾插到該集合中
	
	String s = list.remove(0);// 刪除 index 位置元素并返回
	boolean s2 = list.remove("hello");// 刪除遇到的第一個 hello，沒找到則返回 false
	
	list.set(0,"we");
	
	list.indexOf("we");//返回第一個 "we" 所在下標(biāo)
	list.lastIndexOf("we");// 返回最后一個 "we" 的下標(biāo)
	
	System.out.println(list);
	// 截取子串 -- 左閉右開區(qū)間
	List<String> sub = list.subList(1, 3);
	System.out.println(sub);
	list.set(2,"修改后的list");
	System.out.println(sub);

public class MyArrayList<E> {

    private Object[] elementData;// 數(shù)組
    private int usedSize;// 代表有效的數(shù)據(jù)個數(shù)
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    public MyArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    public MyArrayList(int capacity) {
        // 判斷參數(shù)的合法性
        if (capacity >= 0) {
            this.elementData = new Object[capacity];
        }else {
            throw new RuntimeException("初始化的容量不能為負(fù)數(shù)！");
        }
    }

    /**
     * 添加元素
     * @param e 要添加的元素
     */
    public boolean add(E e) {
        // 確定一個真正的容量,預(yù)測 -> 如需擴(kuò)容則擴(kuò)容
        ensureCapacityInternal(usedSize + 1);
        // 擴(kuò)容完畢，放數(shù)據(jù)
        elementData[usedSize++] = e;
        return true;
    }

    /**
     * 給 index位置添加元素
     * @param index
     * @param e
     */
    public boolean add(int index, E e) {
        // 檢查 index 是否合法
        rangeCheckForAdd(index);
        // 確定一個真正的容量 -> 如需擴(kuò)容則擴(kuò)容
        ensureExplicitCapacity(usedSize + 1);
        // 移動 index后面的元素,并在 index位置插入元素
        copy(index,e);
        usedSize++;
        return true;
    }
    private void copy(int index, E e){
        for (int i = usedSize; i > index; i--) {
            elementData[i] = elementData[i - 1];
        }
        elementData[index] = e;
    }
    private void rangeCheckForAdd(int index) {
        if (index > usedSize || index < 0)
            throw new IndexOutOfBoundsException("index位置不合法！");
    }



    public void ensureCapacityInternal(int minCapacity) {
        // 計算出需要的容量
        int capacity = calculateCapacity(elementData, minCapacity);
        // 根據(jù)計算出的容量，看是否需要擴(kuò)容或者分配內(nèi)存
        ensureExplicitCapacity(capacity);
    }

    private void ensureExplicitCapacity(int minCapacity) {
        // 如果需要的容量大于數(shù)組容量，就擴(kuò)容
        if (minCapacity - elementData.length > 0)
            // 擴(kuò)容
            grow(minCapacity);
    }

    private static final int MAX_ARRAY_SIZE  = Integer.MAX_VALUE - 8;
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            // 說明你要的容量非常大，就分配更大的內(nèi)存
            newCapacity = hugeCapacity(minCapacity);;
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
                Integer.MAX_VALUE :
                MAX_ARRAY_SIZE;
    }

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 確定之前數(shù)組是否分配過內(nèi)存，沒有的話返回一個初始化的容量 10
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(10, minCapacity);
        }
        // 分配后，返回 +1 后的值，即實(shí)際所需要的容量
        return minCapacity;
    }
}