26_2集合实现类研究底层（部分）：手撕Vector、Stack、HashSet、TreeSet底层源码，涉及红黑树

原创

已于 2024-07-11 11:13:56 修改 · 913 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #集合 #红黑树

于 2024-03-10 19:09:28 首次发布

day26下

集合框架

标绿已经学习底层，深入底层主要是研究实现类底层

手撕Vector底层源码

场景：
    //Vector<String> v = new Vector<>(10,5);//扩容机制是：数组原来长度 + 容量增量
    Vector<String> v = new Vector<>();//扩容机制是：数组原来长度的2倍
		
    v.add("aaa");
    v.add("bbb");
    v.add("ccc");
    v.add("ddd");

底层

public abstract class AbstractList<E> extends AbstractCollection<E> implements List<E> {
	//外部操作数（计算添加和删除的次数）
    protected transient int modCount = 0;//最终4
    
    protected AbstractList() {
    }
}

public class Vector<E> extends AbstractList<E> implements List<E>{
    
    //数组最大容量
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    
    //数据容器 - ["aaa","bbb","ccc","ddd",null,null,null,null,null,null]
    protected Object[] elementData;//new Object[10];
    //元素个数（相当于ArrayList的size）
    protected int elementCount;//最终4
    //容量增量
    protected int capacityIncrement;//0
    
    //new对象过程
    //无参构造调用一个参数的有参构造
    public Vector() {
        this(10);
    }
    //一个参数的有参构造调用两个参数的有参构造
    //initialCapacity - 10
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
    
    //initialCapacity - 10
    //capacityIncrement - 0
    public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }
    
    //添加过程（加锁）
    // e - 最终"ddd"
    public synchronized boolean add(E e) {
        modCount++;
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    
    //minCapacity - 11
    //判断
    private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    //minCapacity - 11
    //扩容
    private void grow(int minCapacity) {
        // oldCapacity - 10
        int oldCapacity = elementData.length;
        // newCapacity = 10 + 10
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
  
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    //超过最大容量
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0)
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_V