集合

List:

1. ArrayList:  jdk1.2,   线程不安全   底层使用数组：Object[ ]   ，如果非要使用线程安全的ArrayList可以使用Collections工具类中的某个方法。
2. LinkList:    jdk1.2,   线程不安全   底层使用双向链表
3. Vector:      jdk1.1,   线程安全       底层使用数组: Object[ ]     很少用了

一、ArrayList源码分析:

1、jdk1.7情况下：

ArrayList list = new ArrayList()

底层创建一个长度为10的Object[ ]数组elementData

list.add(123);  elementData[0] = new Integer(123); 前提是数组长度够的情况下

...

list.add(11); // 如果此次的添加导致底层elementData 数组容量不够，则扩容，默认情况下，数组大小变为原来的1.5倍，同时将原来数组中的数据复制到新的数组中。

结论：建议开发中使用带参数的构造器 ArrayList list = new ArrayList(int capacity)

2、jdk1.8情况下：

ArrayList list = new ArrayList();

底层创建一个空数组 即Object[ ] elementData初始化为{ },并没有创建长度为10的数组

list.add(123); 第一次调用add()时，底层才创建了长度为10的数组，并将数组123添加到elementData中，

...

后续添加和扩容的方式与jdk1.7相同

3、小结：

jdk7中的ArrayList的创建方式类似于单例的饿汉式，而jdk8的ArrayList的对象的创建类似于单例的懒汉式，延迟了数组的创建，节省内存。

二、LinkList源码分析：

jdk1.8和1.7一样：

LinkList list = new LinkList()

生成一个空的对象，里面不存放数据。内部声明了Node类型的first和last属性，默认值为null

list.add(123) 将123封装到Node中，创建了Node对象

Node结构为：

private static class Node<E> {
        E item;
        Node<E> next;
        Node<E> prev;

        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

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

set:

/-----Set ：存储无序的、不可重复的数据

        /-----HashSet : 作为Set接口的主要实现类：线程不安全，可以存储null值

               /-----LinkedHashSet：作为HashSet的子类，遍历其内部数据时，可以按照添加的顺序遍历

       /-----TreeSet：可以按照添加对象的指定属性，进行排序，底层使用二叉树中的红黑树存储数据

1、如何理解无序性、不可重复性，以HashSet为例说明

无序性：不等于随机性。存储的数据在底层数组中并非按照数组索引的顺序进行添加存放，而是根据数据的哈希值比较来选取存放在数组中的位置的

不可重复性：保证添加的元素按照equals()判断时，不能返回true。即：相同的元素只能添加一个

2、添加元素的过程：以HashSet为例：

• 说明：HashSet底层也是使用数组存储，jdk1.7中，初始化就分配一个长度为16的数组；jdk1.8中初始化分配的是空的数组，在第一次添加元素时才会初始化一个长度为16的数组。这种情况和List是一样的。

我们向HashSet中添加元素a，首先调用元素a所在类的hashCode()方法，计算元素a的哈希值，此哈希值接着通过某种算法计算出在hashSet底层数组中的存放位置，(即为：索引位置)，判断数组此位置上是否已经有元素：

        如果此位置上没有其他元素，则元素a添加成功。  ------> 情况1

        如果此位置上有其他元素b，(或者以链表形式存在的多个元素)，则比较元素a与元素b的hash值：

                如果hash值不同，则元素a添加成功，           -------> 情况2

               如果hash值相同，进而需要条用元素a所在类的equals()方法：

                         equals()返回true，元素a添加失败

                         equals()返回false，则元素a添加成功    -------->情况3

对于添加成功的情况2和情况3而言，元素a与已经存在制定索引位置上的数据以链表方式存储，

jdk 7 :元素a放到数组中，指向原来的元素

jdk 8 :原来的元素在数组中，指向元素a

总结：七上八下

注意：

1. HashSet集合判断两个元素相等的标准：两个对象通过hashCode()方法比较相等，并且两个对象的equals()方法返回值也相等
2. 对于存放在Set容器中的两个对象，对应的类一定要重写equals()和hashCode(Object obj)方法，以实现对象相等规则，即：相等的对象必须具有相等的散列码。
3. HashSet底层也是使用HashMap结构存储数据，只是自动为每个元素的value值设置为Object

LinkedHashSet:

作为HashSet的子类，在添加数据的同时，每个数据还维护了两个引用，记录此数据的前一个和后一个数据的位置；

优点：对于频繁的遍历操作LinkedHashSet效率高于HashSet

TreeSet:

• 使用TreeSet存储元素必须保证元素是相同类型，因为要进行比较，不同类型的元素之间没法比较
• 必须实现java.lang.Comparable接口或者继承java.util.Comparator类。
• 自然排序中，比较两个对象是否相同的标准为：compareTo()返回0，不再是equals().

Map

    /------HashMap: 作为Map的主要实现类：线程不安全，效率高，可以存储null的key和value

           底层结构：jdk7: 数组+链表

                             jdk8: 数组+链表+红黑树

           /------ LinkedHashaMap: 保证在遍历map元素时，可以按照添加的顺序实现遍历。

                   原因：在原有的HashMap底层结构基础上，添加一对指针，指向前一个和后一个元素。

                 对于频繁的遍历操作，此类执行效率高于HashMap

 /----- TreeMap:保证按照添加的key-value对进行排序，实现排序遍历，此时考虑key的自然排序或定制排序

           底层使用：红黑树

/------ HashTable：作为古老的实现类，线程安全，效率低，不能存储null的key和value

         /------ Properties:

高频面试题：

1、HashMap的底层实现原理？

2、HashMap 和 HashTable的异同

3、CurrentHashMap 与 Hashtable的异同？

HashMap底层实现原理？jdk7

HashMap map = new HashMap():

在实例化以后，底层创建了长度为16的以为数据Entry table

....... 可能已经执行过多次put........

map.put(key1,value1):

首先，调用key1所在类的hashCode()，计算key1的哈希值，此哈希值经过某种运算之后，得到在Entry数组中的存放位置。

如果此位置上的数据为空，此时的key1-value1添加成功，  -----情况1

如果此位置上的数据不为空，（意味着此位置上存在一个多多个数据（以链表形式）），比较key1和已经存在的一个或多个数据的哈希值：

          如果key1的哈希值，与已经存在的数据的哈希值都不相同，此时key1-value1添加成功。 -----情况2

          如果key1的哈希值与已经存在的某一个数据(key2-value2)的哈希值相同，继续比较：调用key1所在类的equals(key2)

                      如果equals()返回false.此时key1-value1添加成功  -----情况3

                      如果equals()返回true,使用value1替换value2

补充：关于情况2和情况3：此时key1-value1和原来的数据以链表的方式存储

在不断的添加过程中会涉及到扩容问题，默认的扩容方式：当元素个数大于0.75*size，并且要添加元素的位子不空，则扩容为原来的2倍，并将原有的数据复制过来。

jdk8: 相较于jdk7在底层实现方面的不同：

1、new HashMap()：底层没有创建一个长度为16的数组

2、jdk8 底层的数组是Node[ ]，而非Entry[ ]

3、首次调用put()方法时，底层创建长度为16的数组

4、jdk7底层结构只有：数组+链表，jdk8中底层结构：数组+链表+红黑树

     当数组的某一个索引位置上的元素以链表的形式存在的数据个数 > 8且当前数组的长度 > 64时，

     此时此索引位置上的所有数据改为使用红黑树存储

当数组的某一个索引位置上的元素以链表形式存在的数据个数 > 8 且当前数组的长度 > 64时，此时此索引位置上的所有数据改为使用红黑树存储。

Collections集合工具类

ArrayList list = new ArrayList()

Collections的 Collections.synchronizedList(list)方法可以将变成线程安全的

对map和set等集合也有类似的方法可以使用，详情看源码