java学习——java基础（六）之集合类实现原理

写在前面：一天在迷迷糊糊中度过，依旧木有结果，真的亚历山大。今天开会回来比较晚了，闲话少说，开始复习。

在上节中我们详细学习了Java中集合类的使用方法以及其各自特点，今天我们来学习这些集合类底层源码实现。

1.ArrayList实现原理

ArrayList是List接口的可变数组的实现。实现了所有可选列表操作，并允许包括 null 在内的所有元素。除了实现 List 接口外，此类还提供一些方法来操作内部用来存储列表的数组的大小。

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

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

具体ArrayList源码分析如下：

(1) 底层使用数组实现：

private transient Object[] elementData;  

(2) 构造方法：

ArrayList提供了三种方式的构造器，可以构造一个默认初始容量为10的空列表、构造一个指定初始容量的空列表以及构造一个包含指定collection的元素的列表，这些元素按照该collection的迭代器返回它们的顺序排列。

public ArrayList() {      this(10);  }  public ArrayList(int initialCapacity) {      super();      if (initialCapacity < 0)          throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);      this.elementData = new Object[initialCapacity];  } public ArrayList(Collection<? extends E> c) {      elementData = c.toArray();      size = elementData.length;      if (elementData.getClass() != Object[].class)          elementData = Arrays.copyOf(elementData, size, Object[].class);  }

(3) 存储：

ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)这些添加元素的方法。

// 用指定的元素替代此列表中指定位置上的元素，并返回以前位于该位置上的元素。  public E set(int index, E element) {      RangeCheck(index);      E oldValue = (E) elementData[index];      elementData[index] = element;      return oldValue;  }// 将指定的元素添加到此列表的尾部。  public boolean add(E e) {      ensureCapacity(size + 1);       elementData[size++] = e;      return true;  }// 将指定的元素插入此列表中的指定位置。  // 如果当前位置有元素，则向右移动当前位于该位置的元素以及所有后续元素（将其索引加1）。  public void add(int index, E element) {      if (index > size || index < 0)          throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);      // 如果数组长度不足，将进行扩容。      ensureCapacity(size+1);  // Increments modCount!!    // 将 elementData中从Index位置开始、长度为size-index的元素，      // 拷贝到从下标为index+1位置开始的新的elementData数组中。      // 即将当前位于该位置的元素以及所有后续元素右移一个位置。      System.arraycopy(elementData, index, elementData, index + 1, size - index);      elementData[index] = element;      size++;  }// 按照指定collection的迭代器所返回的元素顺序，将该collection中的所有元素添加到此列表的尾部。  public boolean addAll(Collection<? extends E> c) {      Object[] a = c.toArray();      int numNew = a.length;      ensureCapacity(size + numNew);  // Increments modCount      System.arraycopy(a, 0, elementData, size, numNew);      size += numNew;      return numNew != 0;  }// 从指定的位置开始，将指定collection中的所有元素插入到此列表中。  public boolean addAll(int index, Collection<? extends E> c) {      if (index > size || index < 0)          throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);      Object[] a = c.toArray();    int numNew = a.length;    ensureCapacity(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;  }

(4) 读取

// 返回此列表中指定位置上的元素。  public E get(int index) {      RangeCheck(index);      return (E) elementData[index];  }

(5) 删除

ArrayList提供了根据下标或者指定对象两种方式的删除功能。如下：

// 移除此列表中指定位置上的元素。  public E remove(int index) {      RangeCheck(index);      modCount++;      E oldValue = (E) elementData[index];      int numMoved = size - index - 1;      if (numMoved > 0)          System.arraycopy(elementData, index+1, elementData, index, numMoved);      elementData[--size] = null; // Let gc do its work      return oldValue;  }  // 移除此列表中首次出现的指定元素（如果存在）。这是因为ArrayList中允许存放重复的元素。  public boolean remove(Object o) {      // 由于ArrayList中允许存放null，因此下面通过两种情况来分别处理。      if (o == null) {          for (int index = 0; index < size; index++)              if (elementData[index] == null) {                  // 类似remove(int index)，移除列表中指定位置上的元素。                  fastRemove(index);                  return true;              }  } else {      for (int index = 0; index < size; index++)          if (o.equals(elementData[index])) {              fastRemove(index);              return true;          }      }      return false;  }

注意：从数组中移除元素的操作，也会导致被移除的元素以后的所有元素的向左移动一个位置。

(6) 调整数组容量

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

public void ensureCapacity(int minCapacity) {      modCount++;      int oldCapacity = elementData.length;      if (minCapacity > oldCapacity) {          Object oldData[] = elementData;          int newCapacity = (oldCapacity * 3)/2 + 1;              if (newCapacity < minCapacity)                  newCapacity = minCapacity;        // minCapacity is usually close to size, so this is a win:        elementData = Arrays.copyOf(elementData, newCapacity);      }  }

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

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

public void trimToSize() {      modCount++;      int oldCapacity = elementData.length;      if (size < oldCapacity) {          elementData = Arrays.copyOf(elementData, size);      }  }

(7) Fail-Fast机制

ArrayList也采用了快速失败的机制，通过记录modCount参数来实现。在面对并发的修改时，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

2.HashMap实现原理

HashMap是基于哈希表的Map接口的非同步实现（Hashtable跟HashMap很像，唯一的区别是Hashtalbe中的方法是线程安全的）。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

(1) 数据结构

在java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针（引用），所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表的数组”的数据结构，每个元素存放链表头结点的数组，即数组和链表的结合体，如下图所示。

从上图中可以看出，HashMap底层就是一个数组结构，数组中的每一项又是一个链表。当新建一个HashMap的时候，就会初始化一个数组。源码如下：

/** * The table, resized as necessary. Length MUST Always be a power of two. */transient Entry[] table;static class Entry<K,V> implements Map.Entry<K,V> {    final K key;    V value;    Entry<K,V> next;    final int hash;    ……}

Entry就是数组中的元素，每个 Map.Entry 其实就是一个key-value对，它持有一个指向下一个元素的引用，这就构成了链表。

(2) 存储

当我们往HashMap中put元素的时候，先根据key的hashCode重新计算hash值，根据hash值得到这个元素在数组中的位置（即下标），如果数组该位置上已经存放有其他元素了，那么在这个位置上的元素将以链表的形式存放，新加入的放在链头，最先加入的放在链尾。如果数组该位置上没有元素，就直接将该元素放到此数组中的该位置上。

public V put(K key, V value) {    // HashMap允许存放null键和null值。    // 当key为null时，调用putForNullKey方法，将value放置在数组第一个位置。    if (key == null)        return putForNullKey(value);    // 根据key的hashCode重新计算hash值。    int hash = hash(key.hashCode());    // 搜索指定hash值所对应table中的索引。    int i = indexFor(hash, table.length);    // 如果 i 索引处的 Entry 不为 null，通过循环不断遍历 e 元素的下一个元素。    for (Entry<K,V> e = table[i]; e != null; e = e.next) {        Object k;        if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {            V oldValue = e.value;            e.value = value;            e.recordAccess(this);            return oldValue;        }    }    // 如果i索引处的Entry为null，表明此处还没有Entry。    // modCount记录HashMap中修改结构的次数    modCount++;    // 将key、value添加到i索引处。    addEntry(hash, key, value, i);    return null;}

addEntry(hash, key, value, i)方法根据计算出的hash值，将key-value对放在数组table的 i 索引处。addEntry 是HashMap 提供的一个包访问权限的方法（就是没有public，protected，private这三个访问权限修饰词修饰，为默认的访问权限，用default表示，但在代码中没有这个default），代码如下：

void addEntry(int hash, K key, V value, int bucketIndex) {    // 获取指定 bucketIndex 索引处的 Entry     Entry<K,V> e = table[bucketIndex];    // 将新创建的 Entry 放入 bucketIndex 索引处，并让新的 Entry 指向原来的 Entry    table[bucketIndex] = new Entry<K,V>(hash, key, value, e);    // 如果 Map 中的 key-value 对的数量超过了极限    if (size++ >= threshold)        // 把 table 对象的长度扩充到原来的2倍。        resize(2 * table.length);}

其中：

size：该变量保存了该 HashMap 中所包含的 key-value 对的数量。

threshold：该变量包含了 HashMap 能容纳的 key-value 对的极限，它的值等于 HashMap 的容量乘以负载因子（load factor）

当系统决定存储HashMap中的key-value对时，完全没有考虑Entry中的value，仅仅只是根据key来计算并决定每个Entry的存储位置。我们完全可以把 Map 集合中的 value 当成 key 的附属，当系统决定了 key 的存储位置之后，value 随之保存在那里即可。

hash(int h)方法根据key的hashCode重新计算一次散列。此算法加入了高位计算，防止低位不变，高位变化时，造成的hash冲突。

static int hash(int h) {    h ^= (h >>> 20) ^ (h >>> 12);    return h ^ (h >>> 7) ^ (h >>> 4);}

我们可以看到在HashMap中要找到某个元素，需要根据key的hash值来求得对应数组中的位置。如何计算这个位置就是hash算法。前面说过HashMap的数据结构是数组和链表的结合，所以我们当然希望这个HashMap里面的元素位置尽量的分布均匀些，尽量使得每个位置上的元素数量只有一个，那么当我们用hash算法求得这个位置的时候，马上就可以知道对应位置的元素就是我们要的，而不用再去遍历链表，这样就大大优化了查询的效率。

对于任意给定的对象，只要它的 hashCode() 返回值相同，那么程序调用 hash(int h) 方法所计算得到的 hash 码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算，这样一来，元素的分布相对来说是比较均匀的。但是，“模”运算的消耗还是比较大的，在HashMap中是这样做的：调用 indexFor(int h, int length) 方法来计算该对象应该保存在 table 数组的哪个索引处。indexFor(int h, int length) 方法的代码如下：

static int indexFor(int h, int length) {    return h & (length-1);}

这个方法非常巧妙，它通过 h & (table.length -1) 来得到该对象的保存位，而HashMap底层数组的长度总是 2 的n 次方，这是HashMap在速度上的优化。

在 HashMap 构造器中有如下代码：

int capacity = 1;while (capacity < initialCapacity)capacity <<= 1;

这段代码保证初始化时HashMap的容量总是2的n次方，即底层数组的长度总是为2的n次方。

当length总是 2 的n次方时，h& (length-1)运算等价于对length取模，也就是h%length，但是&比%具有更高的效率。

根据上面 put 方法的源代码可以看出，当程序试图将一个key-value对放入HashMap中时，程序首先根据该 key的 hashCode() 返回值决定该 Entry 的存储位置：如果两个 Entry 的 key 的 hashCode() 返回值相同，那它们的存储位置相同。如果这两个 Entry 的 key 通过 equals 比较返回 true，新添加 Entry 的 value 将覆盖集合中原有Entry 的 value，但key不会覆盖。如果这两个 Entry 的 key 通过 equals 比较返回 false，新添加的 Entry 将与集合中原有 Entry 形成 Entry 链，而且新添加的 Entry 位于 Entry 链的头部。

(3) 读取

public V get(Object key) {    if (key == null)        return getForNullKey();    int hash = hash(key.hashCode());    for (Entry<K,V> e = table[indexFor(hash, table.length)];        e != null;        e = e.next) {        Object k;        if (e.hash == hash && ((k = e.key) == key || key.equals(k)))            return e.value;    }    return null;}

从HashMap中get元素时，首先计算key的hashCode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。

归纳起来简单地说，HashMap 在底层将 key-value 当成一个整体进行处理，这个整体就是一个 Entry 对象。HashMap 底层采用一个 Entry[] 数组来保存所有的 key-value 对，当需要存储一个 Entry 对象时，会根据hash算法来决定其在数组中的存储位置，在根据equals方法决定其在该数组位置上的链表中的存储位置；当需要取出一个Entry时，也会根据hash算法找到其在数组中的存储位置，再根据equals方法从该位置上的链表中取出该Entry。

(4) resize（rehash）

当HashMap中的元素越来越多的时候，hash冲突的几率也就越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。

那么HashMap什么时候进行扩容呢？当HashMap中的元素个数超过数组大小*loadFactor时，就会进行数组扩容，loadFactor的默认值为0.75，这是一个折中的取值。也就是说，默认情况下，数组大小为16，那么当HashMap中元素个数超过16*0.75=12（这个值就是代码中的threshold值，也叫做临界值）的时候，就把数组的大小扩展为 2*16=32，即扩大一倍，然后重新计算每个元素在数组中的位置，而这是一个非常消耗性能的操作，所以如果我们已经预知HashMap中元素的个数，那么预设元素的个数能够有效的提高HashMap的性能。

HashMap扩容的代码如下所示：

//HashMap数组扩容void resize(int newCapacity) {Entry[] oldTable = table;int oldCapacity = oldTable.length;//如果当前的数组长度已经达到最大值，则不在进行调整if (oldCapacity == MAXIMUM_CAPACITY) {threshold = Integer.MAX_VALUE;                return;}//根据传入参数的长度定义新的数组Entry[] newTable = new Entry[newCapacity];//按照新的规则，将旧数组中的元素转移到新数组中transfer(newTable);table = newTable;//更新临界值threshold = (int)(newCapacity * loadFactor);}//旧数组中元素往新数组中迁移void transfer(Entry[] newTable) {//旧数组Entry[] src = table;//新数组长度int newCapacity = newTable.length;//遍历旧数组for (int j = 0; j < src.length; j++) {Entry<K,V> e = src[j];if (e != null) {src[j] = null;do {Entry<K,V> next = e.next;int i = indexFor(e.hash, newCapacity);e.next = newTable[i];newTable[i] = e;e = next;} while (e != null);}}}

(5) 构造方法

HashMap 包含如下几个构造器：

1）HashMap()：构建一个初始容量为 16，负载因子为 0.75 的 HashMap。

2）HashMap(int initialCapacity)：构建一个初始容量为 initialCapacity，负载因子为 0.75 的 HashMap。

3）HashMap(int initialCapacity, float loadFactor)：以指定初始容量、指定的负载因子创建一个 HashMap。

4）HashMap的基础构造器HashMap(int initialCapacity, float loadFactor)带有两个参数，它们是初始容量initialCapacity和加载因子loadFactor。

5）initialCapacity：HashMap的最大容量，即为底层数组的长度。

6）loadFactor：负载因子loadFactor定义为：散列表的实际元素数目(n)/ 散列表的容量(m)。

负载因子衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。

HashMap的实现中，通过threshold字段来判断HashMap的最大容量：

threshold = (int)(capacity * loadFactor); 

结合负载因子的定义公式可知，threshold就是在此loadFactor和capacity对应下允许的最大元素数目，超过这个数目就重新resize以降低实际的负载因子（也就是说虽然数组长度是capacity，但其扩容的临界值确是threshold）。默认的的负载因子0.75是对空间和时间效率的一个平衡选择。当容量超出此最大容量时， resize后的HashMap容量是容量的两倍：

if (size++ >= threshold)       resize(2 * table.length); 

当创建一个 HashMap 时，系统会自动创建一个 table 数组来保存 HashMap 中的 Entry，下面是 HashMap 中一个构造器的代码：

// 以指定初始化容量、负载因子创建 HashMap  public HashMap(int initialCapacity, float loadFactor)  {  // 初始容量不能为负数 if (initialCapacity < 0)  throw new IllegalArgumentException( "Illegal initial capacity: " +  initialCapacity);  // 如果初始容量大于最大容量，让出示容量 if (initialCapacity > MAXIMUM_CAPACITY)  initialCapacity = MAXIMUM_CAPACITY;  // 负载因子必须大于 0 的数值 if (loadFactor <= 0 || Float.isNaN(loadFactor))  throw new IllegalArgumentException(  loadFactor);  // 计算出大于 initialCapacity 的最小的 2 的 n 次方值。 int capacity = 1;  while (capacity < initialCapacity)  capacity <<= 1;  this.loadFactor = loadFactor;  // 设置容量极限等于容量 * 负载因子 threshold = (int)(capacity * loadFactor);  // 初始化 table 数组 table = new Entry[capacity]; // table 的实质就是一个数组，一个长度为 capacity 的数组。 init();  }

(6) Fail-Fast机制

HashMap不是线程安全的，因此如果在使用迭代器的过程中有其他线程修改了map，那么将抛出ConcurrentModificationException，这就是所谓fail-fast策略。

这一策略在源码中的实现是通过modCount域，modCount顾名思义就是修改次数，对HashMap内容的修改都将增加这个值，那么在迭代器初始化过程中会将这个值赋给迭代器的expectedModCount。

HashIterator() {    expectedModCount = modCount;    if (size > 0) { // advance to first entry    Entry[] t = table;    while (index < t.length && (next = t[index++]) == null)        ;    }}

在迭代过程中，判断modCount跟expectedModCount是否相等，如果不相等就表示已经有其他线程修改了Map。

注意到modCount声明为volatile，保证线程之间修改的可见性。（volatile之所以线程安全是因为被volatile修饰的变量不保存缓存，直接在内存中修改，因此能够保证线程之间修改的可见性）。

final Entry<K,V> nextEntry() {       if (modCount != expectedModCount)           throw new ConcurrentModificationException();}

由所有HashMap类的“collection 视图方法”所返回的迭代器都是快速失败的：在迭代器创建之后，如果从结构上对映射进行修改，除非通过迭代器本身的 remove 方法，其他任何时间任何方式的修改，迭代器都将抛出ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不保证在将来不确定的时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在非同步的并发修改时，不可能作出任何坚决的保证。快速失败迭代器尽最大努力抛出 ConcurrentModificationException。因此，编写依赖于此异常的程序的做法是错误的，正确做法是：迭代器的快速失败行为应该仅用于检测程序错误。

(7) key的hashcode与equals方法改写

get方法的过程：首先计算key的hashcode，找到数组中对应位置的某一元素，然后通过key的equals方法在对应位置的链表中找到需要的元素。所以，hashcode与equals方法对于找到对应元素是两个关键方法。

Hashmap的key可以是任何类型的对象，例如User这种对象，为了保证两个具有相同属性的user的hashcode相同，我们就需要改写hashcode方法，比方把hashcode值的计算与User对象的id关联起来，那么只要user对象拥有相同id，那么他们的hashcode也能保持一致了，这样就可以找到在hashmap数组中的位置了。如果这个位置上有多个元素，还需要用key的equals方法在对应位置的链表中找到需要的元素，所以只改写了hashcode方法是不够的，equals方法也是需要改写的。当然，equals方法一般都会根据实际的业务内容来定义，例如根据user对象的id来判断两个user是否相等。 

在改写equals方法的时候，需要满足以下三点： 

(1) 自反性：就是说a.equals(a)必须为true。 

(2) 对称性：就是说a.equals(b)=true的话，b.equals(a)也必须为true。 

(3) 传递性：就是说a.equals(b)=true，并且b.equals(c)=true的话，a.equals(c)也必须为true。 

通过改写key对象的equals和hashcode方法，我们可以将任意的业务对象作为map的key。

3.LinkedHashMap实现原理

LinkedHashMap是Map接口的哈希表和链接列表实现，具有可预知的迭代顺序。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

LinkedHashMap实现与HashMap的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可以是插入顺序或者是访问顺序。

注意，此实现不是同步的。如果多个线程同时访问链接的哈希映射，而其中至少一个线程从结构上修改了该映射，则它必须保持外部同步。

(1) 数据结构

LinkedHashMap继承于HashMap，底层使用哈希表与双向链表来保存所有元素。其基本操作与父类HashMap相似，它通过重写父类相关的方法，来实现自己的链接列表特性。

(2) Entry元素

LinkedHashMap采用的hash算法和HashMap相同，但是它重新定义了数组中保存的元素Entry，该Entry除了保存当前对象的引用外，还保存了其上一个元素before和下一个元素after的引用，从而在哈希表的基础上又构成了双向链接列表。

/**  * 双向链表的表头元素。  */  private transient Entry<K,V> header;  /**  * LinkedHashMap的Entry元素。  * 继承HashMap的Entry元素，又保存了其上一个元素before和下一个元素after的引用。  */  private static class Entry<K,V> extends HashMap.Entry<K,V> {      Entry<K,V> before, after;      ……  }

(3) 初始化

通过源代码可以看出，在LinkedHashMap的构造方法中，实际调用了父类HashMap的相关构造方法来构造一个底层存放的table数组。如：

public LinkedHashMap(int initialCapacity, float loadFactor) {      super(initialCapacity, loadFactor);      accessOrder = false;  }

HashMap中的相关构造方法：

public HashMap(int initialCapacity, float loadFactor) {      if (initialCapacity < 0)          throw new IllegalArgumentException("Illegal initial capacity: " +  initialCapacity);      if (initialCapacity > MAXIMUM_CAPACITY)          initialCapacity = MAXIMUM_CAPACITY;      if (loadFactor <= 0 || Float.isNaN(loadFactor))          throw new IllegalArgumentException("Illegal load factor: " +   loadFactor);      // Find a power of 2 >= initialCapacity      int capacity = 1;      while (capacity < initialCapacity)          capacity <<= 1;        this.loadFactor = loadFactor;      threshold = (int)(capacity * loadFactor);      table = new Entry[capacity];      init();  }

我们已经知道LinkedHashMap的Entry元素继承HashMap的Entry，提供了双向链表的功能。在上述HashMap的构造器中，最后会调用init()方法，进行相关的初始化，这个方法在HashMap的实现中并无意义，只是提供给子类实现相关的初始化调用。

LinkedHashMap重写了init()方法，在调用父类的构造方法完成构造后，进一步实现了对其元素Entry的初始化操作。

void init() {      header = new Entry<K,V>(-1, null, null, null);      header.before = header.after = header;  }

(4) 存储

LinkedHashMap并未重写父类HashMap的put方法，而是重写了父类HashMap的put方法调用的子方法void addEntry(int hash, K key, V value, int bucketIndex) 和void createEntry(int hash, K key, V value, int bucketIndex)，提供了自己特有的双向链接列表的实现。

void addEntry(int hash, K key, V value, int bucketIndex) {      // 调用create方法，将新元素以双向链表的的形式加入到映射中。      createEntry(hash, key, value, bucketIndex);      // 删除最近最少使用元素的策略定义      Entry<K,V> eldest = header.after;      if (removeEldestEntry(eldest)) {          removeEntryForKey(eldest.key);      } else {          if (size >= threshold)              resize(2 * table.length);      }  }void createEntry(int hash, K key, V value, int bucketIndex) {      HashMap.Entry<K,V> old = table[bucketIndex];      Entry<K,V> e = new Entry<K,V>(hash, key, value, old);      table[bucketIndex] = e;      // 调用元素的addBrefore方法，将元素加入到哈希、双向链接列表。      e.addBefore(header);      size++;  }private void addBefore(Entry<K,V> existingEntry) {      after  = existingEntry;      before = existingEntry.before;      before.after = this;      after.before = this;  }

(5) 读取

LinkedHashMap重写了父类HashMap的get方法，实际在调用父类getEntry()方法取得查找的元素后，再判断当排序模式accessOrder为true时，记录访问顺序，将最新访问的元素添加到双向链表的表头，并从原来的位置删除。由于的链表的增加、删除操作是常量级的，故并不会带来性能的损失。

public V get(Object key) {      // 调用父类HashMap的getEntry()方法，取得要查找的元素。      Entry<K,V> e = (Entry<K,V>)getEntry(key);      if (e == null)          return null;      // 记录访问顺序。      e.recordAccess(this);      return e.value;  }void recordAccess(HashMap<K,V> m) {      LinkedHashMap<K,V> lm = (LinkedHashMap<K,V>)m;      // 如果定义了LinkedHashMap的迭代顺序为访问顺序，      // 则删除以前位置上的元素，并将最新访问的元素添加到链表表头。      if (lm.accessOrder) {          lm.modCount++;          remove();          addBefore(lm.header);      }  }

(6) 排序模式

LinkedHashMap定义了排序模式accessOrder，该属性为boolean型变量，对于访问顺序，为true；对于插入顺序，则为false。

private final boolean accessOrder; 

一般情况下，不必指定排序模式，其迭代顺序即为默认为插入顺序。看LinkedHashMap的构造方法，如：

public LinkedHashMap(int initialCapacity, float loadFactor) {      super(initialCapacity, loadFactor);      accessOrder = false;  }

这些构造方法都会默认指定排序模式为插入顺序。如果你想构造一个LinkedHashMap，并打算按从近期访问最少到近期访问最多的顺序（即访问顺序）来保存元素，那么请使用下面的构造方法构造LinkedHashMap：

public LinkedHashMap(int initialCapacity,  float loadFactor,   boolean accessOrder) {      super(initialCapacity, loadFactor);      this.accessOrder = accessOrder;  }

该哈希映射的迭代顺序就是最后访问其条目的顺序，这种映射很适合构建LRU缓存。LinkedHashMap提供了removeEldestEntry(Map.Entry<K,V> eldest)方法，在将新条目插入到映射后，put和 putAll将调用此方法。该方法可以提供在每次添加新条目时移除最旧条目的实现程序，默认返回false，这样，此映射的行为将类似于正常映射，即永远不能移除最旧的元素。

protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {      return false;  }

此方法通常不以任何方式修改映射，相反允许映射在其返回值的指引下进行自我修改。如果用此映射构建LRU缓存，则非常方便，它允许映射通过删除旧条目来减少内存损耗。

例如：重写此方法，维持此映射只保存100个条目的稳定状态，在每次添加新条目时删除最旧的条目。

private static final int MAX_ENTRIES = 100;  protected boolean removeEldestEntry(Map.Entry eldest) {      return size() > MAX_ENTRIES;  } 

4.HashSet实现原理

HashSet实现Set接口，由哈希表（实际上是一个HashMap实例）支持。它不保证set的迭代顺序，特别是它不保证该顺序恒久不变。此类允许使用null元素。HashSet中不允许有重复元素，这是因为HashSet是基于HashMap实现的，HashSet中的元素都存放在HashMap的key上面，而value中的值都是统一的一个private static final Object PRESENT = new Object()。HashSet跟HashMap一样，都是一个存放链表的数组。

HashSet中add方法调用的是底层HashMap中的put()方法，而如果是在HashMap中调用put，首先会判断key是否存在，如果key存在则修改value值，如果key不存在则插入这个key-value。而在set中，因为value值没有用，也就不存在修改value值的说法，因此往HashSet中添加元素，首先判断元素（也就是key）是否存在，如果不存在则插入，如果存在则不插入，这样HashSet中就不存在重复值。

对于HashSet而言，它是基于HashMap实现的，HashSet底层使用HashMap来保存所有元素，更确切的说，HashSet中的元素，只是存放在了底层HashMap的key上， 而value使用一个static final的Object对象标识。因此HashSet 的实现比较简单，相关HashSet的操作，基本上都是直接调用底层HashMap的相关方法来完成， HashSet的源代码如下：

(1) 数据结构

static final long serialVersionUID = -5024744406713321676L;// 底层使用HashMap来保存HashSet中所有元素。private transient HashMap<E,Object> map;// 定义一个虚拟的Object对象作为HashMap的value，将此对象定义为static final。private static final Object PRESENT = new Object();

(2) 构造方法

/*** 默认的无参构造器，构造一个空的HashSet。* * 实际底层会初始化一个空的HashMap，并使用默认初始容量为16和加载因子0.75。*/public HashSet() {map = new HashMap<E,Object>();}/*** 构造一个包含指定collection中的元素的新set。** 实际底层使用默认的加载因子0.75和足以包含指定* collection中所有元素的初始容量来创建一个HashMap。* @param c 其中的元素将存放在此set中的collection。*/public HashSet(Collection<? extends E> c) {map = new HashMap<E,Object>(Math.max((int) (c.size()/.75f) + 1, 16));addAll(c);}/*** 以指定的initialCapacity和loadFactor构造一个空的HashSet。** 实际底层以相应的参数构造一个空的HashMap。* @param initialCapacity 初始容量。* @param loadFactor 加载因子。*/public HashSet(int initialCapacity, float loadFactor) {map = new HashMap<E,Object>(initialCapacity, loadFactor);}/*** 以指定的initialCapacity构造一个空的HashSet。** 实际底层以相应的参数及加载因子loadFactor为0.75构造一个空的HashMap。* @param initialCapacity 初始容量。*/public HashSet(int initialCapacity) {map = new HashMap<E,Object>(initialCapacity);}/*** 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。* 此构造函数为包访问权限，不对外公开，实际只是是对LinkedHashSet的支持。** 实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。* @param initialCapacity 初始容量。* @param loadFactor 加载因子。* @param dummy 标记。*/HashSet(int initialCapacity, float loadFactor, boolean dummy) {map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);}

(3) 其它方法

/*** 返回对此set中元素进行迭代的迭代器。返回元素的顺序并不是特定的。* * 底层实际调用底层HashMap的keySet来返回所有的key。* 可见HashSet中的元素，只是存放在了底层HashMap的key上，* value使用一个static final的Object对象标识。* @return 对此set中元素进行迭代的Iterator。*/public Iterator<E> iterator() {return map.keySet().iterator();}/*** 返回此set中的元素的数量（set的容量）。** 底层实际调用HashMap的size()方法返回Entry的数量，就得到该Set中元素的个数。* @return 此set中的元素的数量（set的容量）。*/public int size() {return map.size();}/*** 如果此set不包含任何元素，则返回true。** 底层实际调用HashMap的isEmpty()判断该HashSet是否为空。* @return 如果此set不包含任何元素，则返回true。*/public boolean isEmpty() {return map.isEmpty();}/*** 如果此set包含指定元素，则返回true。* 更确切地讲，当且仅当此set包含一个满足(o==null ? e==null : o.equals(e))* 的e元素时，返回true。** 底层实际调用HashMap的containsKey判断是否包含指定key。* @param o 在此set中的存在已得到测试的元素。* @return 如果此set包含指定元素，则返回true。*/public boolean contains(Object o) {        return map.containsKey(o);}/*** 如果此set中尚未包含指定元素，则添加指定元素。* 更确切地讲，如果此 set 没有包含满足(e==null ? e2==null : e.equals(e2))* 的元素e2，则向此set 添加指定的元素e。* 如果此set已包含该元素，则该调用不更改set并返回false。** 底层实际将将该元素作为key放入HashMap。* 由于HashMap的put()方法添加key-value对时，当新放入HashMap的Entry中key* 与集合中原有Entry的key相同（hashCode()返回值相等，通过equals比较也返回true），* 新添加的Entry的value会将覆盖原来Entry的value，但key不会有任何改变，* 因此如果向HashSet中添加一个已经存在的元素时，新添加的集合元素将不会被放入HashMap中，* 原来的元素也不会有任何改变，这也就满足了Set中元素不重复的特性。* @param e 将添加到此set中的元素。* @return 如果此set尚未包含指定元素，则返回true。*/public boolean add(E e) {return map.put(e, PRESENT)==null;}/*** 如果指定元素存在于此set中，则将其移除。* 更确切地讲，如果此set包含一个满足(o==null ? e==null : o.equals(e))的元素e，* 则将其移除。如果此set已包含该元素，则返回true* （或者：如果此set因调用而发生更改，则返回true）。（一旦调用返回，则此set不再包含该元素）。** 底层实际调用HashMap的remove方法删除指定Entry。* @param o 如果存在于此set中则需要将其移除的对象。* @return 如果set包含指定元素，则返回true。*/public boolean remove(Object o) {return map.remove(o)==PRESENT;}/*** 从此set中移除所有元素。此调用返回后，该set将为空。* 底层实际调用HashMap的clear方法清空Entry中所有元素。*/public void clear() {map.clear();}/*** 返回此HashSet实例的浅表副本：并没有复制这些元素本身。** 底层实际调用HashMap的clone()方法，获取HashMap的浅表副本，并设置到HashSet中。*/public Object clone() {try {            HashSet<E> newSet = (HashSet<E>) super.clone();            newSet.map = (HashMap<E, Object>) map.clone();            return newSet;        } catch (CloneNotSupportedException e) {            throw new InternalError();        }}

5.LinkedHashSet实现原理

LinkedHashSet是具有可预知迭代顺序的Set接口的哈希表和链接表实现。此实现与HashSet的不同之处在于，后者维护着一个运行于所有条目的双重链接列表。此链接列表定义了迭代顺序，该迭代顺序可为插入顺序或是访问顺序。

注意，此实现不是同步的。如果多个线程同时访问链接的哈希Set，而其中至少一个线程修改了该Set，则它必须保持外部同步。

对于LinkedHashSet而言，它继承与HashSet，又基于LinkedHashMap来实现的。

LinkedHashSet底层使用LinkedHashMap来保存所有元素，它继承于HashSet，其所有的方法操作上又与HashSet相同，因此LinkedHashSet 的实现上非常简单，只提供了四个构造方法，并通过传递一个标识参数，调用父类的构造器，底层构造一个LinkedHashMap来实现，在相关操作上与父类HashSet的操作相同，直接调用父类HashSet的方法即可。

(1)构造方法

/** * 构造一个带有指定初始容量和加载因子的新空链接哈希set。 * * 底层会调用父类的构造方法，构造一个有指定初始容量和加载因子的LinkedHashMap实例。 * @param initialCapacity 初始容量。 * @param loadFactor 加载因子。 */  public LinkedHashSet(int initialCapacity, float loadFactor) {  super(initialCapacity, loadFactor, true);  }    /** * 构造一个带指定初始容量和默认加载因子0.75的新空链接哈希set。 * * 底层会调用父类的构造方法，构造一个带指定初始容量和默认加载因子0.75的LinkedHashMap实例。 * @param initialCapacity 初始容量。 */  public LinkedHashSet(int initialCapacity) {  super(initialCapacity, .75f, true);  }    /** * 构造一个带默认初始容量16和加载因子0.75的新空链接哈希set。 * * 底层会调用父类的构造方法，构造一个带默认初始容量16和加载因子0.75的LinkedHashMap实例。 */  public LinkedHashSet() {          super(16, .75f, true);  }    /** * 构造一个与指定collection中的元素相同的新链接哈希set。 *  * 底层会调用父类的构造方法，构造一个足以包含指定collection * 中所有元素的初始容量和加载因子为0.75的LinkedHashMap实例。 * @param c 其中的元素将存放在此set中的collection。 */  public LinkedHashSet(Collection<? extends E> c) {          super(Math.max(2*c.size(), 11), .75f, true);          addAll(c);  }

(2) 单独构造方法

在父类HashSet中，专为LinkedHashSet提供的构造方法如下，该方法为包访问权限，并未对外公开。

/** * 以指定的initialCapacity和loadFactor构造一个新的空链接哈希集合。 * 此构造函数为包访问权限，不对外公开，实际只是是对LinkedHashSet的支持。 * * 实际底层会以指定的参数构造一个空LinkedHashMap实例来实现。 * @param initialCapacity 初始容量。 * @param loadFactor 加载因子。 * @param dummy 标记。 */  HashSet(int initialCapacity, float loadFactor, boolean dummy) {  map = new LinkedHashMap<E,Object>(initialCapacity, loadFactor);  }

由上述源代码可见，LinkedHashSet通过继承HashSet，底层使用LinkedHashMap，以很简单明了的方式来实现了其自身的所有功能。