JDK源代码阅读笔记（一）------容器篇

一、类图

二、基本抽象基类

1.Collection

所有List和Set都需要实现的基本接口

2.AbstractCollection

此类提供 Collection 接口的骨干实现，以最大限度地减少了实现此接口所需的工作

用迭代器对数据进行访问（不是随机访问）

3.AbstractList

此类提供 List 接口的骨干实现，以最大限度地减少实现“随机访问”数据存储（如数组）支持的该接口所需的工作

用迭代器对数据进行访问（不是随机访问）

4.AbstractSet

此类提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作

用迭代器对数据进行访问（不是随机访问）

5.AbstractSequentialList

此类提供了 List 接口的骨干实现，从而最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作（ 用迭代器对数据进行访问，不是随机访问）

6.AbstractSet

此类提供 Set 接口的骨干实现，从而最大限度地减少了实现此接口所需的工作。

（用迭代器对数据进行访问，不是随机访问）

7.AbstractMap

此类提供 Map 接口的骨干实现，以最大限度地减少实现此接口所需的工作

（用迭代器对数据进行访问，不是随机访问）

三、List

List可以将元素维护在特定的序列中，并且允许一个相同元素在集合中多次出现。List接口在Collection接口的基础上增加了大量的方法，使得可以在List中间插入和移除元素。

Abstract类之外，在学习中比较常用的类有ArrayList（基于数组实现），LinkedList（基于循环链表实现）Vector（基于数组实现，线程安全），Stack（是Vector的子类，基于数组实现）

1.ArrayList

继承自AbstractList，实现List等接口，基本属性如下：

public  class  ArrayList<E>  extends  AbstractList<E>

         implements  List<E>, RandomAccess, Cloneable, java.io.Serializable

{

     private  static  final  long  serialVersionUID  = 8683452581122892189L;

     /**

     * The array buffer into which the elements of the ArrayList are stored.

     * The capacity of the ArrayList is the length of this array buffer.

     */

     private  transient  Object[]  elementData ;

     /**

     * The size of the ArrayList (the number of elements it contains).

     *

     *  @serial

     */

     private  int  size ;‘

}

基本数据存在名为elementData的数组中，查询指定元素和遍历整个元素都是对数组进行操作

对于ArrayList的增加与删除，利用了Arrays工具类进行数组复制，Arrays的最终实现是利用如下语句

System.arraycopy(original, 0, copy, 0, Math.min(original. length , newLength));

该语句会编译成本地代码，提高效率

2.Vector

实现大体和ArrayList一样，只是每个方法上加了同步标志

3.Stack

继承于Vector，一个栈，限制客户端代码操作数组的位置，只能在栈顶，具体实现时即是数组最后一个元素的位置

4.LinkedList

继承自AbstractSequentialList（ 用迭代器对数据进行访问，不是随机访问）

实现的是一个双链表，所有操作都是按照双重链接列表的需要执行的，基本属性如下：

public  class  LinkedList<E>  extends  AbstractSequentialList<E>

     implements  List<E>, Deque<E>, Cloneable, java.io.Serializable

{

     private  transient  Entry<E>  header  =  new  Entry<E>( null ,  null ,  null );

     private  transient  int  size  = 0;

     /**

     * Constructs an empty list.

     */

     public  LinkedList() {

         header . next  =  header . previous  =  header ;

    }

}

header为头节点，size记录链表长度

其中Entry<E>是一个内部类，作为链表的一个节点：

private  static  class  Entry<E> {

      E element;

      Entry<E> next;

      Entry<E> previous;

      Entry(E element, Entry<E> next, Entry<E> previous) {

           this .element = element;

           this .next = next;

           this .previous = previous;

      }

    }

虽然LinkedList获取指定位置的元素时较ArrayList按索引获取较慢，但是JDK中对get方法做了优化：

private  Entry<E> entry( int  index) {

         if  (index < 0 || index >=  size )

             throw  new  IndexOutOfBoundsException( "Index: " + index +  ", Size: " + size );

        Entry<E> e =  header ;

         if  (index < ( size  >> 1)) {

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

                e = e. next ;

        }  else  {

             for  ( int  i =  size ; i > index; i--)

                e = e. previous ;

        }

         return  e;

    }

四、Set

包括HashSet（无序不重复），LinkedHashSet（按放入顺序有序不重复），TreeSet（按红黑树方式有序不重复）

1.HashSet

利用hash值来查找容器类的元素，因为容器中没个元素的值不相同，所以可以根据元素值来生成hash码

其基本属性如下：

public  class  HashSet<E>  extends  AbstractSet<E>

     implements  Set<E>, Cloneable, java.io.Serializable

{

     static  final  long  serialVersionUID  = -5024744406713321676L;

     private  transient  HashMap<E,Object>  map ;

     // Dummy value to associate with an Object in the backing Map

     private  static  final  Object  PRESENT  =  new  Object();

}

map中的键值“E”用来存储HasgSet中元素值，对应的“Object”固定用PRESENT来表示

其实现基础就是HashMap，所以，HashSet不像List那样可以“随机”访问，只能用迭代器访问

2.TreeSet

其实现基础就是TreeMap，其基本属性如下：

public  class  TreeSet<E>  extends  AbstractSet<E>

     implements  NavigableSet<E>, Cloneable, java.io.Serializable

{

     /**

     * The backing map.

     */

     private  transient  NavigableMap<E,Object>  m ;

     // Dummy value to associate with an Object in the backing Map

     private  static  final  Object  PRESENT  =  new  Object();

}

3.LinkedHashSet

继承于HashSet，其基本属性如下：

public  class  LinkedHashSet<E>  extends  HashSet<E>

     implements  Set<E>, Cloneable, java.io.Serializable {

     private  static  final  long  serialVersionUID = -2851667679971038690L;

}

五、Map

包括HashMap（key无序不重复），LinkedHashMap（key按放入顺序有序不重复），TreeMap（key按红黑树方式有序不重复）

1.HashMap

利用每个key值生成散列值，根据散列值进行数据查找

下图是使用链表来解决散列过程中的碰撞问题，新元素插入链表头

在HashSet中有个loadFactor（负载因子），对于上图所示总共有11个位置，目前有4个位置已经存放，即40%的空间已被使用。在HashSet的默认实现中，初始容量为16，负载因子为0.75，也就是说当有75%的空间已被使用，将会进行一次再散列（再哈希），之前的散列表（数组）将被删除，新增加的散列表是之前散列表长度的2倍，最大值为Integer.MAX_VALUE。

其基本属性如下：

public  class  HashMap<K,V>  extends  AbstractMap<K,V>

     implements  Map<K,V>, Cloneable, Serializable

{

     /**

     * The default initial capacity  -  MUST be a power of two.

     */

     static  final  int  DEFAULT_INITIAL_CAPACITY = 16;

     /**

     * The maximum capacity, used if a higher value is implicitly specified

     * by either of the constructors with arguments.

     * MUST be a power of two <= 1<<30.

     */

     static  final  int  MAXIMUM_CAPACITY = 1 << 30;

     /**

     * The load factor used when none specified in constructor.

     */

     static  final  float  DEFAULT_LOAD_FACTOR = 0.75f;

     /**

     * The table, resized as necessary. Length MUST Always be a power of two.

     */

     transient  Entry[] table;

     /**

     * The number of key - value mappings contained in this map.

     */

     transient  int  size;

     /**

     * The next size value at which to resize (capacity * load factor).

     *  @serial

     */

     int  threshold;

     /**

     * The load factor for the hash table.

     *

     *  @serial

     */

     final  float  loadFactor;

}

其中Entry[] table是用来存放value的数组，数组下标根据key的散列值生成，Entry的基本实现如下：

static class Entry<K,V> implements Map.Entry<K,V> {

         final  K key;

        V value;

        Entry<K,V> next;

         final  int  hash;

}

其中 “Entry<K,V> next” 保存为该的下一个节点

每次查找先找到table中的一个节点，然后以该节点作为头节点进行链表的遍历

2.TreeMap

key按红黑树方式有序的放入TreeMap，其基本属性如下：

public   class  TreeMap<K,V>  extends  AbstractMap<K,V>

    implements NavigableMap<K,V>, Cloneable, java.io.Serializable

{

     /**

     * The comparator used to maintain order in this tree map, or

     * null if it uses the natural ordering of its keys.

     *

     *  @serial

     */

     private  final  Comparator<?  super  K> comparator;

     private  transient  Entry<K,V> root =  null ;

     /**

     * The number of entries in the tree

     */

     private  transient  int  size = 0;

}

其中comparator用来比较key值的大小，root作为整棵树的根节点，Entry为每个节点，其属性如下：

     static  final  class  Entry<K,V>  implements  Map.Entry<K,V> {

        K  key ;

        V  value ;

        Entry<K,V>  left  =  null ;

        Entry<K,V>  right  =  null ;

        Entry<K,V>  parent ;

         boolean  color  =  BLACK ;

}

3.LinkedHashMap

继承与HashMap，新加入一个元素时，需要维护hash表和双链表这两个表，以保证既能利用hash来快速查找数据，又能按map中输入数据的顺序输出数据，如果在映射中重新插入 键，则插入顺序不受影响，基本属性如下：

public  class  LinkedHashMap<K,V>  extends  HashMap<K,V>  implements  Map<K,V>

{

     private  static  final  long  serialVersionUID = 3801124242820219131L;

     /**

     * The head of the doubly linked list.

     */

     private  transient  Entry<K,V> header;

     /**

     * The iteration ordering method for this linked hash map: 

      *   <tt> true </tt>  for access - order,

     *   <tt> false </tt>  for insertion - order.

     *  @serial

     */

     private  final  boolean  accessOrder;

}

其中header代表双链表的头节点，accessOrder用来选择输出的顺序