面试中常常会被问到JDK自带的容器，许多时候面试官会深挖实现以及常用类，这里简单做一部分的整理,文章基于jdk1.8版本。由于本人才疏学浅，如有错误之处还望斧正，技术应认真对待，请您发现错误及时反馈，感谢🙏
-->转载请注明出处 简书 geek之路

---

Connection

首先看一下Connection接口

Connection实现类以及接口

可以发现常用的List 接口 Set接口与Queue接口

再依次看下List接口中有哪些常用类（并发包留给后续的并发篇去写）

List接口下常用类

ArrayList、LinkedList、Vector 映入眼帘

同理Set 发现有HashSet 与LinkedHashSet

Queue接口发现基本都是concurrent下的东西留在并发篇去写

Queue实现

ArrayList实现原理
核心参数

 // 默认容器大小
 private static final int DEFAULT_CAPACITY = 10;
//空的对象数组
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//数组结构存储目标对象
transient Object[] elementData;
//ArrayList 的 size；
private int size;

初始化的三个构造器

   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 {
            //传入指定大小小于0 抛出异常
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }

//将c元素的集合放入ArrayList
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;
        }
    }

add()

初始化好后我们常常向其中添加元素执行add()源码如下

  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);//取10和参数间大的
       }
      return minCapacity;
     }

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;      //父类AbstractList  结构性修改+1

        // 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);//扩大为原来的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); //copy 扩容数据
    }

可以发现关键点在于对容器大小进行了扩容

remove ()

有添加就要有删除

  public E remove(int index) {
        rangeCheck(index); //检查参数合法性

        modCount++; //  结构修改+1
        E oldValue = elementData(index) ; //获得删除object

        int numMoved = size - index - 1;  //计算移动的个数
        if (numMoved > 0)
            //移动
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //有利于GC  也就是数组不再持有该对象，使其不可达
        elementData[--size] = null; // clear to let GC do its work

        return oldValue;
    }

get() 获取对象

  public E get(int index) {
        // 检验索引是否合法
        rangeCheck(index);
        return elementData(index);
    }

set() 指定位置设置值

    public E set(int index, E element) {
        // 校验下标是否合法
        rangeCheck(index);
        // 旧值
        E oldValue = elementData(index);
        // 将新值放在指定下标
        elementData[index] = element;
        // 返回旧值
        return oldValue;
    }

indexOf() 查找某对象

    public int indexOf(Object o) {
        if (o == null) { // 查找的对象为null
            for (int i = 0; i < size; i++) // 遍历数组
                if (elementData[i]==null)//找到第一个为null的对象
                    return i;//返回数组下标
        } else { // 查找的对象不为null
            for (int i = 0; i < size; i++) // 遍历数组
                if (o.equals(elementData[i]))//找到第一个和指定对象相等的对象
                    return i;//返回下标
        } 
        // 没有找到，返回-1
        return -1;
    }

由此可以看出，如果查找的对象不为null，那么该对象判断条件的关键在于是否重写equals() ,并且查找为顺序遍历

小结

ArrayList 默认容量为10，扩容系数为原长度的1.5倍，采用的是数组的结构。也就是特殊的链表结构，在物理内存中是有序的，所以我们查询某元素效率很快，增加删除元素由于需要改变其顺序，效率略低。同时，我们需要注意，在使用的时候对可预见的长度，创建时尽量指定大小，避免多次扩容，提高效率。

ps：发现写博客一篇基础知识也需要大约四十分中的书写，贵在坚持吧！