【数据结构】 ArrayList深入解析

public static void main(String[] args) {
	ArrayList<Integer> list = new ArrayList<>();
    list.add(10);
    list.add(11);
    list.add(12);
    list.add(1,13);
    System.out.println(list);
    list.clear();
    System.out.println(list);
}

//部分源码：博主用的是JDK17,17对于一些源码进行封装的处理
    public boolean add(E e) {
        modCount++;
        add(e, elementData, size);
        return true;
	}
	
    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

	private Object[] grow(int minCapacity) {
        int oldCapacity = elementData.length;
        if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            int newCapacity = ArraysSupport.newLength(oldCapacity,
                    minCapacity - oldCapacity, /* minimum growth */
                    oldCapacity >> 1           /* preferred growth */);
            return elementData = Arrays.copyOf(elementData, newCapacity);
        } else {
            return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
        }
    }
    
	private Object[] grow() {
	    return grow(size + 1);
	}

Collection<? extends E> c

ArrayList<Integer> list2 = new ArrayList<>(list);
	list2.add(999999999);
	System.out.println(list2);

ArrayList<Integer> list = new ArrayList<>();
// 在索引 0、1、2 分别插入元素
list.add(0, 23);
list.add(1, 5);
list.add(2, 2);
System.out.println(list); 

public void add(int index, E element) {
    // 1. 检查索引合法性（不能小于 0，也不能大于当前元素个数）
    rangeCheckForAdd(index);
    // 2. 记录集合修改次数（用于快速失败机制，如迭代器遍历中修改集合会抛异常）
    modCount++;
    final int s; // 当前集合元素个数
    Object[] elementData; // 底层存储数组
    // 3. 检查是否需要扩容（若当前元素个数 == 数组长度，触发扩容）
    if ((s = size) == (elementData = this.elementData).length)
        elementData = grow(); // 扩容方法（默认扩容为原容量的 1.5 倍，JDK 8+）
    // 4. 数组拷贝：将 index 及后续元素向后搬移 1 位
    System.arraycopy(
        elementData, index,    // 原数组 + 原数组起始索引
        elementData, index + 1,// 目标数组 + 目标数组起始索引（后移 1 位）
        s - index              // 拷贝长度（index 到末尾的元素个数）
    );
    // 5. 在空出的 index 位置插入新元素
    elementData[index] = element;
    // 6. 元素个数 +1
    size = s + 1;
}

// 新建一个待批量添加的集合
ArrayList<Integer> test = new ArrayList<>();
test.add(1);
test.add(2);
test.add(3);
// 批量添加 test 的所有元素到 arrayList 末尾
arrayList.addAll(test);
System.out.println(list); // 输出：[23, 5, 2, 1, 2, 3]

// 删除索引 0 的元素（值为 23）
arrayList.remove(0);
System.out.println(arrayList); 
// 输出：[5, 2, 1, 2, 3]

// 删除元素 1（注意：JDK 9+ 中 new Integer(1) 已过时，建议直接传值）
arrayList.remove(new Integer(1)); // 过时写法
arrayList.remove(1); // 推荐写法（自动装箱为 Integer）
System.out.println(arrayList);
 // 输出：[5, 2, 2, 3]

// 查找元素 2 的索引（从头部开始）
System.out.println(arrayList.indexOf(2)); // 输出：1（第一个 2 在索引 1）
// 查找元素 2 的索引（从尾部开始）
System.out.println(arrayList.lastIndexOf(2)); // 输出：2（最后一个 2 在索引 2）

int indexOfRange(Object o, int start, int end) {
    Object[] es = elementData;
    if (o == null) {
        // 匹配 null 元素
        for (int i = start; i < end; i++) {
            if (es[i] == null) return i;
        }
    } else {
        // 匹配非 null 元素（调用 equals()）
        for (int i = start; i < end; i++) {
            if (o.equals(es[i])) return i;
        }
    }
    return -1;
}

// 新建一个集合用于演示截取
ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);
// 截取索引 1~3 的元素（包含 1，不包含 3，即元素 2、3）
List<Integer> list1 = list.subList(1, 3);
System.out.println(list);  // 原集合：[1, 2, 3, 4, 5]
System.out.println(list1); // 子集合：[2, 3]

// 修改子集合 list1 的索引 0 元素为 99
list1.set(0, 99);
System.out.println(list);  // 原集合变为：[1, 99, 3, 4, 5]
System.out.println(list1); // 子集合变为：[99, 3]
//list预期结果分别是：1，2，3，4，5		list1预期结果：99，3

List<Integer> independentList = new ArrayList<>(list.subList(1, 3));

ArrayList<Integer> list = new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
list.add(4);
list.add(5);

System.out.println("=====普通 for 循环=====");
int size = list.size(); // 提前获取 size，避免循环中多次调用（优化性能）
for (int i = 0; i < size; i++) {
    System.out.print(list.get(i) + " "); // 输出：1 2 3 4 5
}

System.out.println("=====for each 输出=====");
for (Integer num : list) {
    System.out.print(num + " "); // 输出：1 2 3 4 5
}

System.out.println("=====使用迭代器iterator输出=====");
Iterator<Integer> iterator = list.iterator();
while (iterator.hasNext()) {
    Integer num = iterator.next();
    
    //意味着打印当前iterator的下一个，同时iterator往后走一步
    //就是在集合之外，如果判断这个迭代器的下一个存在，那么直接打印；
    //并且往下走一个位置（走到打印的那个位置），如果没有就不再打印
    
    System.out.print(num + " "); // 输出：1 2 3 4 5
    // 遍历中安全删除（示例：删除元素 2）
    if (num == 2) {
        iterator.remove(); // 需在 next() 后调用，否则抛异常
    }
}
System.out.println("\n删除后：" + list); // 输出：[1, 3, 4, 5]

System.out.println("=====使用迭代器ListIterator输出=====");
ListIterator<Integer> listIt = list.listIterator();
while (listIt.hasNext()) {
    System.out.print(listIt.next() + " "); // 输出：1 3 4 5
}

System.out.println("=====使用迭代器ListIterator输出 扩展=====");
// 从集合末尾开始反向遍历（需先正向遍历到末尾，或传入初始索引为 list.size()）
ListIterator<Integer> reverseIt = list.listIterator(list.size());
while (reverseIt.hasPrevious()) {
	//从后往前打印：previous表示先前的，逆序打印
    System.out.print(reverseIt.previous() + " "); // 输出：5 4 3 1
}