JavaSE集合源码分析（一）--深入理解ArrayList原理（JDK1.8）

最新推荐文章于 2021-01-05 23:08:27 发布

晋文子上

最新推荐文章于 2021-01-05 23:08:27 发布

阅读量209

点赞数

分类专栏： Java基础文章标签： java 源码

本文链接：https://blog.csdn.net/qq_34190023/article/details/80879386

版权

Java基础专栏收录该内容

12 篇文章 0 订阅

订阅专栏

ArrayList ：

1）ArrayList内部是通过一个Object数组实现的，当数组填满之后会根据需要进行扩容
2）最好预估ArrayList的大小，并设置其初始容量，以避免不必要的扩容所造成的性能问题。
3）ArrayList的初始容量是10，ArrayList每次扩容都将容量变为原来的1.5倍，若还小于所需的最小值，那么直接分配容量为所需值。
4）ArrayList线程不安全，允许空（null）的元素。
5）ArrayList内部有两个内部类，分别实现Iterator和ListIterator，定义了迭代的规则。

查找O（1）。添加移除慢。

ArrayList的容量是指用来存储列表元素的数组的大小。它总是至少等于列表的大小。随着向 ArrayList 中不断添加元素，其容量也自动增长。自动增长会带来数据向新数组的重新拷贝。如果可预知数据量的多少，可在构造 ArrayList 时指定其容量。在添加大量元素前，应用程序也可使用ensureCapacity操作来增加ArrayList实例的容量，这可减少递增式再分配的数量。

注意，此实现不是同步的。如果多个线程同时访问一个 ArrayList 实例，而其中至少一个线程从结构上修改了列表，那么它必须保持外部同步。

相对比的，Vector是线程安全的，其中涉及线程安全的方法皆被同步操作了。

从上面介绍的向 ArrayList 中存储元素的代码中，每当向数组中添加元素时，都要去检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容，以满足添加数据的需求。数组扩容通过一个公开的方法 ensureCapacity(int minCapacity)来实现。在实际添加大量元素前，我也可使用 ensureCapacity来手动增加 ArrayList 实例的容量，以减少递增式再分配的数量。

ArrayList源码分析：（JDK8）

ArrayList是对象引用的一个变长数组，是线程不安全的

public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable {

属性：

transient Object[] elementData;

private int size;

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] 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);
    }
}

public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

set方法：

public E set(int index, E element) { // set时依旧会判断是否越界，然后保存新值返回旧值
    rangeCheck(index);
    E oldValue = elementData(index); // 先获取旧值
    elementData[index] = element; // 直接对内部维护的数组进行赋值
    return oldValue;
}

add方法：

public boolean add(E e) {
    ensureCapacityInternal(size + 1); // Increments modCount!!
    elementData[size++] = e;
    return true;
}

// 将指定的元素插入此列表中的指定位置。

// 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）

public void add(int index, E element) {
rangeCheckForAdd(index);

// 如果数组长度不足，将进行扩容。
    ensureCapacityInternal(size + 1); // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

get方法：

public E get(int index) { // get元素前会先判断传入的index是否越界，如果没有则返回元素值
rangeCheck(index); // 判断是否越界
return elementData(index);
}

indexOf方法：

public int indexOf(Object o) {
    if (o == null) {
        for (int i = 0; i < size; i++)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = 0; i < size; i++)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}

remove方法：

public E remove(int index) {
    rangeCheck(index);
    modCount++;
    E oldValue = elementData(index);
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // clear to let GC do its work
    return oldValue;
}

public boolean remove(Object o) {

// 由于ArrayList中允许存放null，因此下面通过两种情况来分别处理。
    if (o == null) {
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

clear方法：

public void clear() {
    modCount++;
    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

public int size() {
return size;
}

@Override
public void forEach(Consumer<? super E> action) {
    Objects.requireNonNull(action);
    final int expectedModCount = modCount;
    @SuppressWarnings("unchecked")
    final E[] elementData = (E[]) this.elementData;
    final int size = this.size;
    for (int i=0; modCount == expectedModCount && i < size; i++) {
        action.accept(elementData[i]);
    }
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

private void fastRemove(int index) {
    modCount++;
    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--size] = null; // clear to let GC do its work
}

扩容:

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 如果只是刚初始化，最小容量大小默认是8
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);//根据容量进行分配
}
private void ensureExplicitCapacity(int minCapacity) {   // 扩容
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0) // 大于的时候进行扩容，否则直接结束
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // JDK8扩充策略是原来的1.5倍
    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;
}

从上述代码中可看出，数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量的增长大约是其原容量的 1.5倍。这种操作的代价是很高的，因此在实际使用时，我们应该尽量避免数组容量的扩张。当我们可预知要保存的元素的多少时，要在构造 ArrayList 实例时，就指定其容量，以避免数组扩容的发生。或者根据实际需求，通过调用 ensureCapacity方法来手动增加 ArrayList实例的容量。

ArrayList 还给我们提供了将底层数组的容量调整为当前列表保存的实际元素的大小的功能。它可通过 trimToSize方法来实现。

实例：

     ArrayList array = new ArrayList();// 创建集合对象

     // 添加多个字符串元素(包含内容相同的)

     array.add("hello"); array.add("world"); array.add("java");  array.add("world");

     array.add("java");  array.add("world");  array.add("world"); array.add("world");

     array.add("world"); array.add("java");

     array.add("world");

     ArrayList newArray = new ArrayList();

     Iterator it = array.iterator();

     while (it.hasNext()) {

         String s = (String) it.next();

         // 新集合是否有这个字符串，没有就添加新的字符串

         if (!newArray.contains(s)) {

             newArray.add(s);

         }

     }

     // 遍历新集合

     for (int x = 0; x < newArray.size(); x++) {

         String s = (String) newArray.get(x);

         System.out.println(s);

     }

     /* 需求：ArrayList去除集合中字符串的重复值(字符串的内容相同)

* 要求：不能创建新的集合，就在以前的集合上做。

*/

     //去除相同的（选择排序思想）不建立新的数组

     //不断对比，如果是重复的话，就去掉当前对比的这个，然后让数组的值减一

     for (int x = 0; x < array.size() - 1; x++) {

         for (int y = x + 1; y < array.size(); y++) {

             if (array.get(x).equals(array.get(y))) {

                 array.remove(y);

                 y--;

             }

         }

     }

     Iterator it1 = array.iterator();

     while (it1.hasNext()) {

         String s = (String) it1.next();

         System.out.println(s);

     }