从知识图谱讲到源码实例，基础的知识深入学习就不只是基础

关注公众号：Java架构师联盟，每日更新技术好文

部分资料已经上传到我的git仓库中：有需要的可以下载

https://gitee.com/biwangsheng/mxq

作为一个程序员，通常，我们的程序需要根据程序运行时才知道创建多少个对象。但若非程序运行，程序开发阶段，我们根本不知道到底需要多少个数量的对象，甚至不知道它的准确类型。为了满足这些常规的编程需要，我们要求能在任何时候，任何地点创建任意数量的对象，而这些对象用什么来容纳呢？我们首先想到了数组，但是数组只能放同一类型的数据，而且其长度是固定的，那怎么办呢？集合便应运而生了！

而对于集合的相关内容，我通过思维导图整理了一下，分成两个部分，Map和Collection两个部分，来看一下

Map

Collection

因为篇幅原因，只展示Collection的List，这也是在日常开发中应用最多的，或者说在面试过程中被问到最多的一个知识点，因为它可以扩充出来很多其他的知识点

一、ArrayList的底层实现

ArrayList实现与List、RandomAccess接口，是顺序接口，即元素存放的数据与放进去的顺序相同，允许放入null元素，也支持随机访问
底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同
ArrayList相当于动态数据，其中最重要的两个属性分别是：elementData数组以及siz

二、ArrayList可以实现同步吗

为了追求效率，ArrayList没有实现同步（synchronizd），如果需要逗哥线程并发访问，用户可以手动同步，也可以使用Vector代替。如可以先采用Collections.synchronizedList()方法对其进行包装

三、ArrayList的add()方法

在调用add()方法的时候首先进行扩容校验，将插入的值放在尾部，并将size+1.

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

四、ArrayList的add(index,e)方法

如果调用add(index,e)在指定位置添加的话也是首先扩容校验，接着对数据进行复制，目的是把index位置空出来放本次插入的数据，并将后面的数据向后移动一个位置。

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++; }

其实扩容最终调用的代码

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); }

也是一个数组复制的过程。

注意：

由此可见ArrayList的主要消耗时数组扩容以及在指定位置添加数据，在日常使用时最好是指定大小，尽量减少扩容。更要减少在指定位置插入数据的操作。

五、ArrayList的序列化

由于ArrayList是基于动态宿主实现的，所以并不是所有的空间都被使用。因此使用了transient修饰。可以防止被自动序列化

transient Object[] elementData; // non-private to simplify nested class access

因此ArrayList自定义了序列化和反序列化

//序列化 private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{ // Write out element count, and any hidden stuff int expectedModCount = modCount; s.defaultWriteObject(); // Write out size as capacity for behavioural compatibility with clone() s.writeInt(size); // Write out all elements in the proper order. //只序列化了被使用的数据 for (int i=0; i<size; i++) { s.writeObject(elementData[i]); } if (modCount != expectedModCount) { throw new ConcurrentModificationException(); } } //反序列化 private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException { elementData = EMPTY_ELEMENTDATA; // Read in size, and any hidden stuff s.defaultReadObject(); // Read in capacity s.readInt(); // ignored if (size > 0) { // be like clone(), allocate array based upon size not capacity int capacity = calculateCapacity(elementData, size); SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, capacity); ensureCapacityInternal(size); Object[] a = elementData; // Read in all elements in the proper order. for (int i=0; i<size; i++) { a[i] = s.readObject(); } } }

当对象中自定义了writeObject和readObject方法时，JVM会调用这两个自定义方法来实现序列化和反序列化

从实现中可以看出ArrayList值序列化了被使用的数据

六、ArrayList和Vector的比较

Vector也会是实现List接口，底层数据结构和ArrayList类似，也是一个动态数组存放的数据，不过在add()方法的时候使用synchronized进行同步数据，但是开销较大，所以Vector是一个同步容器并不是并发容器。

add()方法

public synchronized boolean add(E e) { modCount++; ensureCapacityHelper(elementCount + 1); elementData[elementCount++] = e; return true; }

add(index,e)方法：指定位置插入数据

public void add(int index, E element) { insertElementAt(element, index); } public synchronized void insertElementAt(E obj, int index) { modCount++; if (index > elementCount) { throw new ArrayIndexOutOfBoundsException(index + " > " + elementCount); } ensureCapacityHelper(elementCount + 1); System.arraycopy(elementData, index, elementData, index + 1, elementCount - index); elementData[index] = obj; elementCount++; }

七、ArrayList的扩容机制

假如有20个数据需要添加，那么会分别在第一次的时候将ArrayList
之后扩容会按照1.5倍增长，也就是当添加第11个数据的时候，ArrayList继续扩容变为10*1.5=15；
当添加第16个数据时。继续扩容15*1.5=22个
不能超过int的最大值（231-1）-8

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

八、LinkedList的底层实现

LinkedList底层是基于双向链表实现的；
本身实现了List和Deque（双端队列）接口
拥有List的一些特性（jdk1.7/1.8之后取消了循环，修改为双向链表）

既可以看做一个顺序容器，又可以看做一个队列（Queue)，同时又可以看做一个栈（stack）。这样看来，LinkedList简直是个全能冠军。当你需要使用栈或者队列时，可以考虑使用LinkedList，一方面是因为Java官方已经声明不建议使用Stack类，更遗憾的是，Java里根本没有一个叫做Queue的类（它是一个接口名）。关于栈或者队列，现在的首选是ArrayDeque，它有着比LinkedList（当做栈或者队列使用时）更好的性能。

九、LinkedList的add()方法

public boolean add(E e) { linkLast(e); return true; } void linkLast(E e) { final Node<E> l = last; final Node<E> newNode = new Node<>(l, e, null); last = newNode; if (l == null) first = newNode; else l.next = newNode; size++; modCount++; }

可见每次插入都是移动指针，和ArrayList的拷贝数组来说效率要高上不少

十、LinkedList的查询方法get(index)

public E get(int index) { checkElementIndex(index); return node(index).item; } Node<E> node(int index) { // assert isElementIndex(index); if (index < (size >> 1)) { Node<E> x = first; for (int i = 0; i < index; i++) x = x.next; return x; } else { Node<E> x = last; for (int i = size - 1; i > index; i--) x = x.prev; return x; } }

上述代码，利用了双向链表的特性，如果index离链表头比较近，就从节点头部遍历。否则就从节点尾部开始遍历。使用空间（双向链表）来换取时间