集合框架总结

  2019作为新的一年开始，我也着手面试的准备。这篇的博客的主角集合--面试中都会出现的，所以今天特作此总结，也算是复习的成果的一个展示。在查看了许多的博客和源码后我决定将其分成3部分来总结。

三个部分分别是：集合的分类、各个集合的底层实现、集合方法的源码实现

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　集合的分类

　　1.集合-- collection接口

 

  

先上个图

collection作为Set, List, Queue三个接口的父接口，它定义了操作集合的公用方法，包括add(),remove()等方法。稍后会对这些常用的方法进行源码解读。集合作为存储数据的容器，它的作用有点像数据库的作用，而接口则提供了操作这些数据的方法。

下面来看下每个集合的底层数据结构是怎么实现的不废话先上图

在知道了集合的分类和底层实现后，在来看下最经常使用的几个集合的源码

1、ArrarList作为最经常使用的集合。

1. 类声明如下：

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

实现的后三个接口分别表示，该集合可以随机访问（通过下标访问），克隆，序列化和反序列化（把对象转换为字节序列的过程称为对象的序列化。把字节序列恢复为对象的过程称 为

对象的反序列化。）

实现的第一个接口List则表示ArrayList可以使用List接口的所有方法。

　　2. 类的成员属性

public class ArrayList<E> extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{// 版本号private static final long serialVersionUID = 8683452581122892189L;// 缺省容量private static final int DEFAULT_CAPACITY = 10;// 空对象数组private static final Object[] EMPTY_ELEMENTDATA = {};// 缺省空对象数组private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};// 元素数组transient Object[] elementData;// 实际元素大小，默认为0private int size;// 最大数组容量private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
}

说明：类的属性中核心的属性为elementData，类型为Object[]，用于存放实际元素，并且被标记为transient，也就意味着在序列化的时候，此字段是不会被序列化的。

　　3.类的构造函数ArrayList(int)--初始化指定大小的集合

public ArrayList(int initialCapacity) {if (initialCapacity > 0) { // 初始容量大于0this.elementData = new Object[initialCapacity]; // 初始化元素数组} else if (initialCapacity == 0) { // 初始容量为0this.elementData = EMPTY_ELEMENTDATA; // 为空对象数组} else { // 初始容量小于0，抛出异常throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);}}

说明：指定elementData数组的大小，不允许初始化大小小于0，否则抛出异常。

ArrayList（）无参构造函数，当初始化时会给一个默认10的容量大小

 /*** Constructs an empty list with an initial capacity of ten.*/public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}

 ArrayList(Collection<? extends E> c) 参数为泛型的集合参数，即传入的参数必须是集合的子类

 /*** Constructs a list containing the elements of the specified* collection, in the order they are returned by the collection's* iterator.** @param c the collection whose elements are to be placed into this list* @throws NullPointerException if the specified collection is null*/public ArrayList(Collection<? extends E> c) {
　　　　　　// 将传入的集合转为数组elementData = c.toArray();if ((size = elementData.length) != 0) {// c.toArray might (incorrectly) not return Object[] (see 6260652)
　　　　　　// 可能不返回object[]数组if (elementData.getClass() != Object[].class)
　　　　　　// 拷贝数据到object[]数组elementData = Arrays.copyOf(elementData, size, Object[].class);} else {// replace with empty array.this.elementData = EMPTY_ELEMENTDATA;}}

 　　4.add方法

public boolean add(E e) {//对数组的容量进行调整ensureCapacityInternal(size + 1);  // Increments modCount!!elementData[size++] = e;return true;
}//在指定位置添加一个元素
public void add(int index, E element) {
// 数组下标校验rangeCheckForAdd(index);//对数组的容量进行调整ensureCapacityInternal(size + 1);  // Increments modCount!!// 把index后的数据往后移一位，在index位置插入新元素System.arraycopy(elementData, index, elementData, index + 1,size - index);elementData[index] = element;size++;
}//添加一个集合
public boolean addAll(Collection<? extends E> c) {//把该集合转为对象数组Object[] a = c.toArray();int numNew = a.length;//增加容量ensureCapacityInternal(size + numNew);  // Increments modCount//挨个向后迁移System.arraycopy(a, 0, elementData, size, numNew);size += numNew;//新数组有元素，就返回 truereturn numNew != 0;
}//在指定位置，添加一个集合
public boolean addAll(int index, Collection<? extends E> c) {rangeCheckForAdd(index);Object[] a = c.toArray();int numNew = a.length;ensureCapacityInternal(size + numNew);  // Increments modCountint numMoved = size - index;//原来的数组挨个向后迁移if (numMoved > 0)System.arraycopy(elementData, index, elementData, index + numNew,numMoved);//把新的集合数组 添加到指定位置System.arraycopy(a, 0, elementData, index, numNew);size += numNew;return numNew != 0;
}

　　5.数组容量调整

public void ensureCapacity(int minCapacity) {int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)// 不是默认的数组，说明已经添加了元素? 0// 默认的容量
        : DEFAULT_CAPACITY;if (minCapacity > minExpand) {//当前元素个数比默认容量大
        ensureExplicitCapacity(minCapacity);}
}private void ensureCapacityInternal(int minCapacity) {//还没有添加元素if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {//最小容量取默认容量和 当前元素个数 最大值minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);}ensureExplicitCapacity(minCapacity);
}private void ensureExplicitCapacity(int minCapacity) {modCount++;// 容量不够了，需要扩容if (minCapacity - elementData.length > 0)grow(minCapacity);
}

　　6.扩容

private void grow(int minCapacity) {int oldCapacity = elementData.length;// 1.5 倍 原来容量int newCapacity = oldCapacity + (oldCapacity >> 1);//如果当前容量还没达到 1.5 倍旧容量，就使用当前容量，省的站那么多地方if (newCapacity - minCapacity < 0)newCapacity = minCapacity;//新的容量居然超出了 MAX_ARRAY_SIZEif (newCapacity - MAX_ARRAY_SIZE > 0)//最大容量可以是 Integer.MAX_VALUEnewCapacity = hugeCapacity(minCapacity);// minCapacity 一般跟元素个数 size 很接近，所以新建的数组容量为 newCapacity 更宽松些elementData = Arrays.copyOf(elementData, newCapacity);
}private static int hugeCapacity(int minCapacity) {if (minCapacity < 0) // overflowthrow new OutOfMemoryError();return (minCapacity > MAX_ARRAY_SIZE) ?Integer.MAX_VALUE :MAX_ARRAY_SIZE;
}

                       

 7.查询和修改

E elementData(int index) {return (E) elementData[index];
}//获取
public E get(int index) {rangeCheck(index);//直接根据数组角标返回元素，快的一比return elementData(index);
}//修改
public E set(int index, E element) {rangeCheck(index);E oldValue = elementData(index);//直接对数组操作elementData[index] = element;//返回原来的值return oldValue;
}

8、删除

//根据位置删除
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 workreturn oldValue;
}//删除某个元素
public boolean remove(Object o) {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;
}//内部方法，“快速删除”，就是把重复的代码移到一个方法里
//没看出来比其他 remove 哪儿快了 - -
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
}//保留公共的
public boolean retainAll(Collection<?> c) {Objects.requireNonNull(c);return batchRemove(c, true);
}//删除或者保留指定集合中的元素
private boolean batchRemove(Collection<?> c, boolean complement) {final Object[] elementData = this.elementData;//使用两个变量，一个负责向后扫描，一个从 0 开始，等待覆盖操作int r = 0, w = 0;boolean modified = false;try {//遍历 ArrayList 集合for (; r < size; r++)//如果指定集合中是否有这个元素，根据 complement 判断是否往前覆盖删除if (c.contains(elementData[r]) == complement)elementData[w++] = elementData[r];} finally {//发生了异常，直接把 r 后面的复制到 w 后面if (r != size) {System.arraycopy(elementData, r,elementData, w,size - r);w += size - r;}if (w != size) {// 清除多余的元素，clear to let GC do its workfor (int i = w; i < size; i++)elementData[i] = null;modCount += size - w;size = w;modified = true;}}return modified;
}//清楚全部
public void clear() {modCount++;//并没有直接使数组指向 null,而是逐个把元素置为空//下次使用时就不用重新 new 了for (int i = 0; i < size; i++)elementData[i] = null;size = 0;
}

9、indexof和lastindexof

public boolean contains(Object o) {return indexOf(o) >= 0;
}//遍历，第一次找到就返回
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;
}//倒着遍历
public int lastIndexOf(Object o) {if (o == null) {for (int i = size-1; i >= 0; i--)if (elementData[i]==null)return i;} else {for (int i = size-1; i >= 0; i--)if (o.equals(elementData[i]))return i;}return -1;
}

由于 ArrayList 不是同步的，所以在并发访问时，如果在迭代的同时有其他线程修改了 ArrayList, fail-fast 的迭代器 Iterator/ListIterator 会报 ConcurrentModificationException 错。
因此我们在并发环境下需要外部给 ArrayList 加个同步锁，或者直接在初始化时用 Collections.synchronizedList 方法进行包装：

List list = Collections.synchronizedList(new ArrayList(...));

 

由于第一次写总结博客，的确是中费时费力的工作，但也收获颇多，如有不足还请轻喷。

参考博客：

https://blog.csdn.net/u011240877/article/details/52853989

https://blog.csdn.net/u011518120/article/details/52026076

https://www.cnblogs.com/leesf456/p/5308358.html