2022 java 面试准备2022 java 面试准备 Java 基础 Java 集合框架集合分类 Java 的 L

2022 java 面试准备

Java 基础

Java 集合框架

集合分类

Java 的 List 是非常常用的数据类型。List 是有序，有下标，元素可重复的 Collection。Java List 常见实现类：分别是 ArrayList、Vector 、LinkedList和CopyWriteArrayList。

# ArrayList（数组）

ArrayList 是最常用的 List 实现类，内部是通过数组实现的。存储地址是连续的，一旦数据存储好了，查询效率会比较高。当从 ArrayList 的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。

# Vector（数组实现、线程同步）

Vector 与 ArrayList 一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写 Vector，避免多线程同时写而引起的不一致性，其实就是每个方法都加上了synchronized，所以在效率上小于ArrayList，但实现同步需要很高的花费，因此，访问它比访问 ArrayList 慢。

# LinkList（链表）

LinkedList 是用链表结构存储数据的，地址是任意的，所以在开辟内存空间的时候不需要等一个连续的地址，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了 List 接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

# CopyWriteArrayList

CopyOnWriteArrayList 读操作很常见，修改操作很少见。写操作是用复制然后在这个新数组上进行修改来完成的。缺点是：浪费时间、空间。写效率很低，读效率很高，使用背景：读操作远多于写操作。比用读写锁这个方法效率要高一些。

ArrayList

ArrayList 是 Java 集合框架中 List 接口的一个实现类。底层是数组，相当于动态数组。与 Java 中的数组相比，它的容量能动态增长

使用的最多的集合ArrayList 的优缺点：

它是基于数组实现的List类

可以动态地调整容量

有序的（元素输出顺序与输入顺序一致）

元素可以为 null

不同步，非线程安全，效率高

查询快，增删慢

占用空间更小，对比 LinkedList，不用占用额外空间维护链表结构

集成体系

从结构图上可以看到ArrayList是抽象类AbstractList的子类【AbstractList是一个模版类，add()，remove()等默认的操作】，同时实现了List接口【list 顶层接口，主要定义了List 的一些操作，如：size()，isEmpty()，contains()，iterator()】。除此之外，它还实现了三个标识型接口，这几个接口都没有任何方法，仅作为标识表示实现类具备某项功能。

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

RandomAccess 表示实现类支持快速随机访问，大部分是基于数组实现；支持随机访问涉及到遍历方式： for 循环(支持随机访问)、迭代器循环(不支持随机访问)

Cloneable 表示实现类支持克隆，具体表现为重写了clone方法，ArrayList 是一个深拷贝。浅拷贝指的是直接使用Object中的clone方法，拷贝的对象是非独立。

拷贝源码：
public Object clone() {
    try {
        ArrayList<?> v = (ArrayList<?>) super.clone();
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
 throw new InternalError(e);
    }
}

拷贝的都是栈中的内容例如：int i=0 ，基本类型的变量在栈内跟堆无关

传值方式：基本类型和String变量是指传递，引用类型是引用传递。

深浅拷贝参照：https://juejin.cn/post/7103385559623532558

有关扩容及深浅拷贝原理：https://blog.csdn.net/m0_49508485/article/details/123283578

java.io.Serializable 表示支持序列化，将对象转换成以字节序列的形式来表示，以便于持久化和传输。可将对象存入网络传输，写磁盘需要序列化，同理从磁盘或者网络中读取对象需要反序列化； 如果需要对此过程自定义，可以重写writeObject与readObject方法。 



serialVersionUID：是类文件的指纹（签名），可理解为md5值，不要采用随机生成的方式，要求写死不让其重新签名，避免已序列化后的对象进行反序列化时出现问题。

主要成员变量

// 序列号

private static final long serialVersionUID = 8683452581122892189L;

// 数组初始容量为 10

private static final int DEFAULT_CAPACITY = 10;

// 如果自定义容量为0，则会默认用它来初始化ArrayList，或者用于空数组替换

private static final Object[] EMPTY_ELEMENTDATA = {};

// 如果没有自定义容量，则会使用它来初始化ArrayList，或者用于空数组比对

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; //跟前面的区别就是这个空数组是用来判断ArrayList第一添加数据的时候要扩容多少。默认的构造器情况下返回这个空数组 



// 底层数据结构，数组    transient 不序列化

transient Object[] elementData;//数据存的地方它的容量就是这个数组的长度，同时只要是使用默认构造器（DEFAULTCAPACITY_EMPTY_ELEMENTDATA ）第一次添加数据的时候容量扩容为DEFAULT_CAPACITY = 10 

 

// 实际ArrayList 大小/集合中元素的个数

private int size;

// 最大数组容量

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

构造方法

//默认构造方法，初始为空数组。

//只有插入一条数据后才会扩展为10，而实际上默认是空的

public ArrayList() {

    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;

}



//根据指定容量创建对象数组

public ArrayList(int initialCapacity) {

    if (initialCapacity > 0) {

        //创建initialCapacity大小的数组

        this.elementData = new Object[initialCapacity];

    } else if (initialCapacity == 0) {

        //创建空数组

        this.elementData = EMPTY_ELEMENTDATA;

    } else {

        throw new IllegalArgumentException("Illegal Capacity: "+

                                               initialCapacity);

    }

}



/**

 * 构造一个包含指定集合的元素的列表，按照它们由集合的迭代器返回的顺序。

 */

public ArrayList(Collection<? extends E> c) {

    //转换最主要的是toArray()，这在Collection中就定义了

    elementData = c.toArray();

    if ((size = elementData.length) != 0) {

        // c.toArray 有可能不返回一个 Object 数组

        if (elementData.getClass() != Object[].class)

            //使用 Arrays.copy 方法拷创建一个 Object 数组

            elementData = Arrays.copyOf(elementData, size, Object[].class);

    } else {

        // 替换为空数组

        this.elementData = EMPTY_ELEMENTDATA;

    }

}

以无参数构造方法创建 ArrayList 时，实际上初始化赋值的是一个空数组。当真正对数组进行添加元素操作时，才真正分配容量。即向数组中添加第一个元素时，数组容量扩为10。

内部类

private class Itr implements Iterator<E>  



private class ListItr extends Itr implements ListIterator<E>  



private class SubList extends AbstractList<E> implements RandomAccess  



static final class ArrayListSpliterator<E> implements Spliterator<E>

ArrayList有四个内部类，其中的Itr是实现了Iterator接口，同时重写了里面的hasNext()， next()， remove() 等方法；其中的ListItr 继承 Itr，实现了ListIterator接口，同时重写了hasPrevious()， nextIndex()， previousIndex()， previous()， set(E e)， add(E e) 等方法，所以这也可以看出了 Iterator和ListIterator的区别：ListIterator在Iterator的基础上增加了添加对象，修改对象，逆向遍历等方法，这些是Iterator不能实现的。

核心方法

add()方法

//添加一个特定的元素到list的末尾

public boolean add(E e) {

    //先确保elementData数组的长度足够，size是数组中数据的个数，因为要添加一个元素，所以size+1，先判断size+1的这个个数数组能否放得下，在这个方法中去判断数组长度是否够用

    ensureCapacityInternal(size + 1);  // 检查是否需要扩容

    //把元素放到最后一位

    elementData[size++] = e;

    return true;

}



//在指定位置添加一个元素

public void add(int index, E element) {

    rangeCheckForAdd(index);//检查是否越界

    ensureCapacityInternal(size + 1);  //检查是否需要扩容

    //将index及其后的元素后挪一位，则index位置就空出来了

    System.arraycopy(elementData, index, elementData, index + 1,size - index);

    //将元素插入到index的位置

    elementData[index] = element;

    //大小+1

    size++;

}



// 校验插入位置是否合理

private void rangeCheckForAdd(int index) {

    //插入的位置肯定不能大于size 和小于0

    if (index > size || index < 0)   

        //如果是，就报越界异常

        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}



//添加一个集合

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;

    //新数组有元素，就返回 true

    return 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 modCount

    int 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;

}

虽说 System.arraycopy 是底层方法，但每次添加都后移一位还是不太好。

对数组的容量进行调整

//确保内部容量够用

private void ensureCapacityInternal(int minCapacity) {

    // minCapacity  ArrayList 的大小（它包含的元素数量）

    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));

}



//如果elementData中是空，则返回默认容量10和大小+1的最大值，否则返回大小+1

private static int calculateCapacity(Object[] elementData, int minCapacity) {

    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {

        return Math.max(DEFAULT_CAPACITY, minCapacity);

    }

    return minCapacity;

}



//确认实际的容量，这个方法就是真正的判断elementData是否够用

private void ensureExplicitCapacity(int minCapacity) {

    modCount++;



    //minCapacity如果大于了实际elementData的长度，那么就说明elementData数组的长度不够用，不够用那么就要增加elementData的length。这里有的小伙伴就会模糊minCapacity到底是什么呢，这里解释一下



/**

  * 当我们要 add 进第1个元素到 ArrayList 时，elementData.length 为0 （因为还是一个空的 list），因为执行了 `ensureCapacityInternal()` 方法 ，所以 minCapacity 此时为10。此时，`minCapacity - elementData.length > 0 `成立，所以会进入 `grow(minCapacity)` 方法。

  * 当add第2个元素时，minCapacity 为2，此时elementData.length(容量)在添加第一个元素后扩容成 10 了。此时，`minCapacity - elementData.length > 0 ` 不成立，所以不会进入 （执行）`grow(minCapacity)` 方法。

  * 添加第3、4···到第10个元素时，依然不会执行grow方法，数组容量都为10。

  * 直到添加第11个元素，minCapacity(为11)比elementData.length（为10）要大。进入grow方法进行扩容。

  */

    // overflow-conscious code

    if (minCapacity - elementData.length > 0)

        //如果 size +1 > elementData.length 证明数组已经放满，则增加容量，调用grow

        grow(minCapacity);

}



//扩容核心方法

private void grow(int minCapacity) {

    //将扩充前的elementData大小给oldCapacity

    int oldCapacity = elementData.length;

    //新容量newCapacity是1.5倍的旧容量oldCapacity

    int newCapacity = oldCapacity + (oldCapacity >> 1);//10>>1 =5

    //这句话就是适应于elementData就空数组的时候，length=0，那么oldCapacity=0，newCapacity=0，所以这个判断成立，在这里就是真正的初始化elementData的大小了，就是为10。

    

//如果扩容后的容量不满足你需要的容量，扩容选择你需要的容量大小，不能大于Integer.MAX_VALUE

    if (newCapacity - minCapacity < 0) newCapacity = minCapacity;

//如果newCapacity超过了最大的容量限制，就调用hugeCapacity，也就是将能给的最大值给newCapacity

if (newCapacity - MAX_ARRAY_SIZE > 0) newCapacity = hugeCapacity(minCapacity);

    //以新容量拷贝出一个新的数组

     elementData = Arrays.copyOf(elementData, newCapacity);

}



//这个就是上面用到的方法，很简单，就是用来赋最大值。

private static int hugeCapacity(int minCapacity) {

    if (minCapacity < 0) throw new OutOfMemoryError();

    //如果minCapacity都大于MAX_ARRAY_SIZE，那么就Integer.MAX_VALUE返回，反之将MAX_ARRAY_SIZE返回。因为maxCapacity是三倍的minCapacity，可能扩充的太大了，就用minCapacity来判断了。

        //Integer.MAX_VALUE:2147483647   MAX_ARRAY_SIZE：2147483639  也就是说最大也就能给到第一个数值。还是超过了这个限制，就要溢出了。相当于arraylist给了两层防护。

   return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;

}

首先创建一个空数组elementData，第一次插入数据时直接扩充至10，然后如果elementData的长度不足，就扩充至1.5倍，如果扩充完还不够，就使用需要的长度作为elementData的长度。



增加容量：默认1.5倍扩容。

1.获取当前数组的长度 >= oldCapacity

2.oldCapacity>＞1,表示将oldCapacity右移一位（位运算），相当于除2.再加上1，相当于新容量扩容1.5倍。

3.如果新容量小于需要的容量，则以需要的容量为准。

4.如果新容量比最大值还要大，则将新容量赋值为最大值。

5.以新容量拷贝出来一个新的数组赋值给elementData

remove()方法

其实这几个删除方法都是类似的

//根据索引删除指定位置的元素

public E remove(int index) {

    //检查index的合理性

    rangeCheck(index);

    //这个作用很多，比如用来检测快速失败的一种标志。

    modCount++;

    //通过索引直接找到该元素

    E oldValue = elementData(index);



    //计算要移动的位数。

    int numMoved = size - index - 1;

    if (numMoved > 0)

        //移动元素，挨个往前移一位。

        System.arraycopy(elementData, index+1, elementData, index,

                         numMoved);

    //将--size上的位置赋值为null，让gc(垃圾回收机制)更快的回收它。

    elementData[--size] = null; // clear to let GC do its work

        //返回删除的元素。

    return oldValue;

}



//从此列表中删除指定元素的第一个匹配项，如果存在，则删除。通过元素来删除该元素，就依次遍历，如果有这个元素，就将该元素的索引传给fastRemobe(index)，使用这个方法来删除该元素，fastRemove(index)方法的内部跟remove(index)的实现几乎一样，这里最主要是知道arrayList可以存储null值

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;

}



//内部方法，“快速删除”，就是把重复的代码移到一个方法里

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

}



//删除或者保留指定集合中的元素

//用于两个方法，一个removeAll()：它只清除指定集合中的元素，retainAll()用来测试两个集合是否有交集。　

private boolean batchRemove(Collection<?> c, boolean complement) {

    //将原集合，记名为A

    final Object[] elementData = this.elementData;

    //r用来控制循环，w是记录有多少个交集

    int r = 0, w = 0;

    boolean modified = false;

    try {

        //遍历 ArrayList 集合

        for (; r < size; r++)

            //参数中的集合c一次检测集合A中的元素是否有

            if (c.contains(elementData[r]) == complement)

                //有的话，就给集合A

                elementData[w++] = elementData[r];

    } finally {

        //发生了异常，直接把 r 后面的复制到 w 后面

        if (r != size) {

            //将剩下的元素都赋值给集合A

            System.arraycopy(elementData, r,elementData, w,size - r);

            w += size - r;

        }

        if (w != size) {

//这里有两个用途，在removeAll()时，w一直为0，就直接跟clear一样，全是为null。

//retainAll()：没有一个交集返回true，有交集但不全交也返回true，而两个集合相等的时候，返回false，所以不能根据返回值来确认两个集合是否有交集，而是通过原集合的大小是否发生改变来判断，如果原集合中还有元素，则代表有交集，而原集合没有元素了，说明两个集合没有交集。

// 清除多余的元素，clear to let GC do its work

            for (int i = w; i < size; i++) elementData[i] = null;

            modCount += size - w;

            size = w;

            modified = true;

        }

    }

    return modified;

}





//保留公共的

public boolean retainAll(Collection<?> c) {

    Objects.requireNonNull(c);

    return batchRemove(c, true);

}



//将elementData中每个元素都赋值为null，等待垃圾回收将这个给回收掉

public void clear() {

    modCount++;

    //并没有直接使数组指向 null,而是逐个把元素置为空，下次使用时就不用重新 new 了

    for (int i = 0; i < size; i++)

        elementData[i] = null;



    size = 0;

}

总结：根据索引删除指定位置的元素，此时会把指定下标到数组末尾的元素挨个向前移动一个单位，并且会把数组最后一个元素设置为null，这样是为了方便之后将整个数组不被使用时，会被GC，可以作为小的技巧使用。

get()方法

public E get(int index) {

    // 检查元素是否越界

    rangeCheck(index);

    //返回数组index位置的元素

    return elementData(index);

}



private void rangeCheck(int index) {

    if (index >= size)

        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

}



说明：get函数会检查索引值是否合法（只检查是否大于size，而没有检查是否小于0），值得注意的是，在get函数中存在element函数，element函数用于返回具体的元素，具体函数如下：



E elementData(int index) {

    return (E) elementData[index];

}

说明：返回的值都经过了向下转型（Object -> E），这些是对我们应用程序屏蔽的小细节。

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) { 

        // 遍历数组，找到第一个为空的元素，返回下标

        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;

}

说明：从头开始查找与指定元素相等的元素，需要注意的是可以查找null元素，意味着ArrayList中可以存放null元素的。与此函数对应的lastIndexOf，表示从尾部开始查找。

contains()方法

//判断是否含有某个元素

public boolean contains(Object o) {

    return indexOf(o) >= 0;

}

toArray()方法

/**

 * 以正确的顺序返回一个包含此列表中所有元素的数组（从第一个到最后一个元素）; 返回的数组的运

 * 行时类型是指定数组的运行时类型。 

 */



public Object[] toArray() {

    //elementData：要复制的数组；size：要复制的长度

    return Arrays.copyOf(elementData, size);

}



public <T> T[] toArray(T[] a) {

    //如果只是要把一部分转换成数组

    if (a.length < size)

        // Make a new array of a's runtime type, but my contents:

        return (T[]) Arrays.copyOf(elementData, size, a.getClass());

    //全部元素拷贝到 数组 a

    System.arraycopy(elementData, 0, a, 0, size);

    if (a.length > size)

        a[size] = null;

    return a;

}

System.arraycopy()和 Arrays.copyOf()方法

System.arraycopy()方法

System.arraycopy(…)：将指定源数组中的数组从指定位置开始复制到目标数组的指定位置

// src：源对象

// srcPos：源对象对象的起始位置

// dest：目标对象

// destPost：目标对象的起始位置

// length：从起始位置往后复制的长度。

// 这段的大概意思就是解释这个方法的用法，复制src到dest，复制的位置是从src的srcPost开始，到srcPost+length-1的位置结束，复制到destPost上，从destPost开始到destPost+length-1的位置上

public static void arraycopy(Object src, int srcPos, Object dest, int destPos,

             int length)

测试代码

public class ArraycopyTest {

        public static void main(String[] args) {

        int[] a = new int[10];

        a[0] = 0;

        a[1] = 1;

        a[2] = 2;

        a[3] = 3;

        System.arraycopy(a, 2, a, 3, 3);

        a[2] = 99;

        for (int i = 0; i < a.length; i++) {

            System.out.print(a[i] + " ");

        }

    }

}

结果：0 1 99 2 3 0 0 0 0 0

Arrays.copyOf()方法

Array.copyOf() 选择指定的数组，截断或填充空值（如果需要），使副本具有指定的长度。以达到扩容的目的

//Arrays的copyOf()方法传回的数组是新的数组对象，改变传回数组中的元素值，不会影响原来的数组。

//copyOf()的第二个自变量指定要建立的新数组长度，如果新数组的长度超过原数组的长度，则保留数组默认值

public static <T> T[] copyOf(T[] original, int newLength) {

    return (T[]) copyOf(original, newLength, original.getClass());

}



/**

 * @Description 复制指定的数组, 如有必要用 null 截取或填充，以使副本具有指定的长度

 * 对于所有在原数组和副本中都有效的索引，这两个数组相同索引处将包含相同的值

 * 对于在副本中有效而在原数组无效的所有索引，副本将填充 null，当且仅当指定长度大于原数组的长度时，这些索引存在

 * 返回的数组属于 newType 类

 *

 * @param original 要复制的数组

 * @param newLength 副本的长度

 * @param newType 副本的类

 * 

 * @return T 原数组的副本，截取或用 null 填充以获得指定的长度

 * @throws NegativeArraySizeException 如果 newLength 为负

 * @throws NullPointerException 如果 original 为 null

 * @throws ArrayStoreException 如果从 original 中复制的元素不属于存储在 newType 类数组中的运行时类型

 */



public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {

    @SuppressWarnings("unchecked")

    T[] copy = ((Object)newType == (Object)Object[].class)

        ? (T[]) new Object[newLength]

        : (T[]) Array.newInstance(newType.getComponentType(), newLength);

    System.arraycopy(original, 0, copy, 0,

                     Math.min(original.length, newLength));

    return copy;

}

测试代码

public static void main(String[] args) {

        int[] a = new int[3];

        a[0] = 0;

        a[1] = 1;

        a[2] = 2;

        int[] b = Arrays.copyOf(a, 10);

        System.out.println("b.length " + b.length);



        for (int i : b) {

            System.out.print(i + " ");

        }

    }

    

输出：

b.length10

0 1 2 0 0 0 0 0 0 0

两者联系与区别

# 联系：

    看两者源代码可以发现copyOf()内部调用了System.arraycopy()方法

# 区别：

    arraycopy()需要目标数组，将原数组拷贝到你自己定义的数组里，而且可以选择拷贝的起点和长度以及放入新数组中的位置

    copyOf()是系统自动在内部新建一个数组，并返回该数组

JDK1.8 ArrayList 源码分析：thinkwon.blog.csdn.net/article/det…

常见面试题

subList

Arrays.asList

Size 和 length

HashMap

部分关键词

# threshold 阈值  capacity 容量  loadfactor 加载因子

部分成员变量如下：

//初始值，为16，必须为2的次幂

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;    

//当容量被占满0.75时就需要reSize扩容

static final float DEFAULT_LOAD_FACTOR = 0.75f;

//链表长度到8，就转为红黑树

static final int TREEIFY_THRESHOLD = 8;

// 树大小为6，就转回链表

static final int UNTREEIFY_THRESHOLD = 6;





数组中存放 Entry 对象



Node(int hash, K key, V value, Node<K,V> next) {

    this.hash = hash;

    this.key = key;

    this.value = value;

    this.next = next;

}

# 为什么HashMap 要用数组+链表来实现？







# HashMap 的PUT方法大致实现流程









# HashMap中数组的大小有什么特点？为什么要是2的幂次方数？









# HashMap 中是如何计算数组下标？







# HashMap 1.7 是如何进行扩容？







# 多线程情况下HashMap1.7 在扩容时为什么会出现线程不安全？







# HashMap1.7的rehash 底层是如何实现？







# HashMap 中的modcount 表示什么意思？









# HashMap 为什么会出现 ConcurrentModificationException？

HashMap 的源码

Int 4个字节 32bit （比特位）1 byte 就是 8 bit

# PUT 方法底层源码分析

1、put(key, value)中直接调用了内部的putVal方法，并且先对key进行了hash操作；

2、putVal方法中，先检查HashMap数据结构中的索引数组表是否位空，如果是的话则进行一次resize操作；

3、以HashMap索引数组表的长度减一与key的hash值进行与运算，得出在数组中的索引，如果索引指定的位置值为空，则新建一个k-v的新节点；

4、如果不满足的3的条件，则说明索引指定的数组位置的已经存在内容，这个时候称之碰撞出现；

5、在上面判断流程走完之后，计算HashMap全局的modCount值，以便对外部并发的迭代操作提供修改的Fail-fast判断提供依据，于此同时增加map中的记录数，并判断记录数是否触及容量扩充的阈值，触及则进行一轮resize操作；

6、在步骤4中出现碰撞情况时，从步骤7开始展开新一轮逻辑判断和处理；

7、判断key索引到的节点（暂且称作被碰撞节点）的hash、key是否和当前待插入节点（新节点）的一致，如果是一致的话，则先保存记录下该节点；如果新旧节点的内容不一致时，则再看被碰撞节点是否是树（TreeNode）类型，如果是树类型的话，则按照树的操作去追加新节点内容；如果被碰撞节点不是树类型，则说明当前发生的碰撞在链表中（此时链表尚未转为红黑树），此时进入一轮循环处理逻辑中；

8、循环中，先判断被碰撞节点的后继节点是否为空，为空则将新节点作为后继节点，作为后继节点之后并判断当前链表长度是否超过最大允许链表长度8，如果大于的话，需要进行一轮是否转树的操作；如果在一开始后继节点不为空，则先判断后继节点是否与新节点相同，相同的话就记录并跳出循环；如果两个条件判断都满足则继续循环，直至进入某一个条件判断然后跳出循环；

9、步骤8中转树的操作treeifyBin，如果map的索引表为空或者当前索引表长度还小于64（最大转红黑树的索引数组表长度），那么进行resize操作就行了；否则，如果被碰撞节点不为空，那么就顺着被碰撞节点这条树往后新增该新节点；

10、最后，回到那个被记住的被碰撞节点，如果它不为空，默认情况下，新节点的值将会替换被碰撞节点的值，同时返回被碰撞节点的值（V）。



 # 为什么要右移16位

其实是为了减少碰撞，进一步降低hash冲突的几率。int类型的数值是4个字节的，右移16位异或可以同时保留高16位于低16位的特征

 # 为什么要异或运算？

首先将高16位无符号右移16位与低十六位做异或运算。如果不这样做，而是直接做&运算那么高十六位所代表的部分特征就可能被丢失 将高十六位无符号右移之后与低十六位做异或运算使得高十六位的特征与低十六位的特征进行了混合得到的新的数值中就高位与低位的信息都被保留了 ，而在这里采用异或运算而不采用& ，| 运算的原因是 异或运算能更好的保留各部分的特征，如果采用&运算计算出来的值会向1靠拢，采用|运算计算出来的值会向0靠拢

# 总结：

(n-1)&hash判断元素存放的位置，n-1等于数组的长度，与运算相当于取余运算(计算速度大于取余运算)假如不做右移运算，那么hash仅是最后四位和1111运算(假如数组长度为16)那么hash高位的信息就会全部丢失（比如如果有多个key.hashcode最后四位都是0000那么就会全部存储在索引为0的桶中产生碰撞），如果右移16位就会将高位的信息与低位的16位异或运算，保留了高位与低位的特征更能体现key.hashcode的特征，降低冲突的概率。

主要目的：上面提到的所有问题，最终目的还是为了让哈希后的结果更均匀的分布，减少哈希碰撞，提升hashmap的运行效率



# 9个节点之后，会将所有节点转为红黑树·

HashMap的resize

当hashmap中的元素个数超过数组大小*加载因子时，就会进行数组扩容，加载因子的默认值为0.75，也就是说，默认情况下，数组大小为16，那么当hashmap中元素个数超过16*0.75=12的时候，就把数组的大小扩展为2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知hashmap中元素的个数，那么预设元素的个数能够有效的提高hashmap的性能。比如说，我们有1000个元素new HashMap(1000), 但是理论上来讲new HashMap(1024)更合适，不过上面annegu已经说过，即使是1000，hashmap也自动会将其设置为1024。 但是new HashMap(1024)还不是更合适的，因为0.75*1000 < 1000, 也就是说为了让0.75 * size > 1000, 我们必须这样new HashMap(2048)才最合适，既考虑了&的问题，也避免了resize的问题。

CurrentHashMap

ReentrantLock源码

ReadWriteLock 读写锁，写锁未分配时，读锁可以反复分配。写锁一旦加上，任何锁都处于阻塞状态，是一把互锁；读锁是一把共享锁。读写分离，处理高并发线程安全集合







ConcurrentHashMap 实现思想是使用分段锁，将HashMap分成16段，给每段都加锁。性能效率要远高于Hashtable



HashMap 存储结构是一个数组链表，(数组里面每个元素都是一个链表)元素在数组当中是散列存放，元素分布的越分散越均匀，存储效率越高。HashTable 是对整个对象加锁了。



ConcurrentLinkedQunue 线程安全的队列接口实现类(链表实现)。使用的算法是：CAS 比较交换算法这个算法是无锁算法。这个算法是指：再给一个对象赋值的时候做一下比较判断。在实现线程安全的时候，效率也非常高。