java 做children无限极 java无限容量

转载

fjfdh 2024-06-16 20:05:49

文章标签 java 做children无限极 java 开发语言 eclipse ci 文章分类 Java 后端开发

引言

源代码

总结

引言

在Java中，ArrayList是最常用的集合之一。它是一种容器，它的内部定义了一个Object类型的数组elementData，因此可用于存储任意类型的数据。我们知道，数组是长度恒定的。而ArrayList相当于是一个长度可变的动态数组，一起来看看的它的扩容机制。

源代码

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
 ......
    private int size;
    private static final Object[] EMPTY_ELEMENTDATA = {};
    //定义的空数组
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    transient Object[] elementData; // non-private to simplify nested class access
    //无参的构造方法
      public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
......
    //有参构造方法
       public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
......

}

如果使用无参的构造方法创造一个ArrayList集合对象，那么就默认让这个数组指向一个空数组DEFAULTCAPACITY_EMPTY_ELEMENTDATA；它是一个私有的，静态的常量。也就是只要是通过无参构造方法创建ArrayList对象，无论创建多少个，每个ArrayList内部的elementData都指向那个空数组，没有重新new，这一点也节省了内存空间！

如果使用有参的构造方法，就会根据传入的长度，创建出新的Object[]类型数组，并让elementData指向它。这里讨论的是扩容机制，就先不介绍其他的构造方法。

添加元素

public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
  
       private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

        private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

      private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

ArrayList内部定义了一个私有变量size，它时刻记录着当前集合存储的元素个数。使用add()方法添加元素时：

1.调用ensureCapacityInternal(int minCapacity )方法传入“size+1”(最小容量)看是否需要扩容，

2.在ensureCapacityInternal(int minCapacity )方法内，调用calculateCapacity(Object[] elementData, int minCapacity) 将elementData和"最小容量"传入,

3.在calculateCapacity(Object[] elementData, int minCapacity)方法内，判断elementData是不是默认的空数组，如果是，就返回默认容量DEFAULT_CAPACITY（10）和最小容量minCapacity中较大的值，否则返回最小容量minCapacity。记这个值为value

4.当ensureExplicitCapacity()方法拿到这个值value

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)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        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;
    }

5.在grow()方法中，按照oldCapacity + (oldCapacity >> 1）进行计算新的容量newCapacity，相当于是计算原数组的1.5倍容量。如果这个容量比最小容量要小，那么newCapacity就重新赋值为minCapacity。如果最小容量minCapacity比默认的容量MAX_ARRAY_SIZE还要大，就会调用hugeCapacity(int minCapacity)方法，最后得到Inteter.MAX_VALUE或Integer.MAX_VALUE-8