Java集合

一、Java集合

java.util.Collection:存储一个一个的数据
    |-----子接口：List:存储有序的、可重复的数据 
           |---- ArrayList、LinkedList、Vector

    |-----子接口：Set:存储无序的、不可重复的数据
           |---- HashSet
                 |----LinkedHashSet
           |----TreeSet


java.util.Map:存储一对一对的数据（key-value键值对）
    |---- HashMap
           |----LinkedHashMap
    |----TreeMap
    |----Hashtable
           |----Properties

二、遍历集合

1、迭代器

// 获取迭代器
Iterator iterator = coll.iterator();
// 遍历
while(iterator.hasNext()){
    System.out.println(iterator.next());
}

2、foreach

三、List及其实现类

java.util.Collection:
    |-----子接口：List:存储有序的、可重复的数据
           |---- ArrayList:List的主要实现类；线程不安全的、效率高；底层使用Object[]数组存储
                           在添加数据、查找数据时，效率较高；在插入、删除数据时，效率较低
           |---- LinkedList:底层使用双向链表的方式进行存储；在对集合中的数据进行频繁的删除、插入操作时，建议使用此类；在插入、删除数据时，效率较高；在添加数据、查找数据时，效率较低；
           |---- Vector:List的古老实现类；线程安全的、效率低；底层使用Object[]数组存储

1、ArrayList底层逻辑

//jdk7版本
//当我们创建一个ArrayList时
ArrayList<String> list = new ArrayList<>();

//底层会初始化数组，数组的长度为10。
Object[] elementData = new Object[10];

当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容。默认扩容为原来长度的1.5倍。并将原有数组中的元素复制到新的数组中。

//jdk8版本
ArrayList<String> list = new ArrayList<>();

//底层会初始化数组，即：
Object[] elementData = new Object[]{};

list.add("AA"); //首次添加元素时，会初始化数组elementData = new Object[10];
list.add("BB");//elementData[1] = "BB";
...
同样当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容。默认扩容为原来长度的1.5倍。并将原有数组中的元素复制到新的数组中。

2、Vector底层逻辑

Vector v = new Vector(); 

//底层初始化数组，长度为10.
Object[] elementData = new Object[10];

3、LinkedList底层逻辑

LinkedList<String> list = new LinkedList<>();

//底层的会声明一个Node对象：
private static class Node<E> {
    E item;
    Node<E> next;
    Node<E> prev;
}

list.add("AA"); //将"AA"封装到一个Node对象1中，list对象的属性first、last都指向此Node对象1。
list.add("BB"); //将"BB"封装到一个Node对象2中，对象1和对象2构成一个双向链表，同时last指向此Node对象2

四、Set及其实现类

java.util.Collection:
    |-----子接口：Set:存储无序的、不可重复的数据
           |---- HashSet：主要实现类；底层使用的是HashMap，即使用数组+单向链表+红黑树结构进行存储。
                |---- LinkedHashSet：是HashSet的子类；在现有的数组+单向链表+红黑树结构的基础上，又添加了一组双向链表，用于记录添加元素的先后顺序。即：我们可以按照添加元素的顺序实现遍历。便于频繁的查询操作。
           |---- TreeSet：底层使用红黑树存储。可以按照添加的元素的指定的属性的大小顺序进行遍历。

1、Set中的无序性与不可重复性

1.1 无序性

与添加的元素的位置有关，根据添加的元素的哈希值，计算的其在数组中的存储位置。此位置不是依次排列的，表现为无序性。

1.2 不可重复性

添加到Set中的元素是不能相同的。比较的标准，需要判断hashCode()得到的哈希值以及equals()结果。哈希值相同且equals()返回true，则认为元素是相同的。

因此添加到HashSet/LinkedHashSet中元素所在的类要重写两个方法：equals() 和 hashCode()。

2、HashSet/LinkedHashSet底层逻辑

----HashSet底层使用的是HashMap
----LinkedHashSet底层使用的是LinkedHashMap

五、Map及其实现类

java.util.Map:
    |---- HashMap:主要实现类;线程不安全的，效率高;可以添加null的key和value值;底层使用数组+单向链表+红黑树结构存储
        |---- LinkedHashMap:在HashMap使用的数据结构的基础上，增加了一对双向链表，用于记录添加的元素的先后顺序
    |---- TreeMap:底层使用红黑树存储;可以按照添加的key-value中的key元素的指定的属性的大小顺序进行遍历。需要考虑使用①自然排序 ②定制排序。
    |---- Hashtable:古老实现类;线程安全的，效率低;不可以添加null的key或value值;底层使用数组+单向链表结构存储
        |---- Properties:其key和value都是String类型。常用来处理属性文件。

1、HashMap的特点

> HashMap中的所有的key彼此之间是不可重复的、无序的。所有的key就构成一个Set集合。--->key所在的类要重写hashCode()和equals()
> HashMap中的所有的value彼此之间是可重复的、无序的。所有的value就构成一个Collection集合。--->value所在的类要重写equals()
> HashMap中的一个key-value,就构成了一个entry。
> HashMap中的所有的entry彼此之间是不可重复的、无序的。所有的entry就构成了一个Set集合。

2、HashMap底层逻辑

2.1 创建对象过程

//jdk7中，创建对象的过程中
HashMap<String,Integer> map = new HashMap<>();

//底层会初始化数组
Entry[] table = new Entry[16];

map.put("AA",78); //"AA"和78封装到一个Entry对象中，考虑将此对象添加到table数组中。

2.2 添加/修改

将(key1,value1)添加到当前的map中：
①调用key1所在类的hashCode()方法，计算key1对应的哈希值1；
②哈希值1经过某种算法hash()之后，得到哈希值2；
③哈希值2再经过某种算法indexFor()之后，就确定了(key1,value1)在数组table中的索引位置i。

情况1：
----如果此索引位置i的数组上没有元素，则(key1,value1)添加成功。
----如果此索引位置i的数组上有元素(key2,value2),则需要继续比较key1和key2的哈希值2 —>哈希冲突
情况二：
----如果key1的哈希值2与key2的哈希值2不相同，则(key1,value1)添加成功。
----如果key1的哈希值2与key2的哈希值2相同，则需要继续比较key1和key2的equals()。要调用key1所在类的equals(),将key2作为参数传递进去。
情况三：
----调用equals()，返回false: 则(key1,value1)添加成功。
----调用equals()，返回true: 则认为key1和key2是相同的。默认情况下，value1替换原有的value2。

jdk7中，情况二与情况三都是头插法

（扩容）

随着不断的添加元素，在满足如下的条件的情况下，会考虑扩容：
(size >= threshold) && (null != table[i])
当元素的个数达到临界值(数组的长度 * 加载因子)时，也就是默认的临界值 = 16 * 0.75 = 12，就考虑扩容。
默认扩容为原来的2倍。

2.3 jdk8

① 在jdk8中，当我们创建了HashMap实例以后，底层并没有初始化table数组。当首次添加(key,value)时，进行判断，如果发现table尚未初始化，则对数组进行初始化。
② 在jdk8中，HashMap底层定义了Node内部类，替换jdk7中的Entry内部类。意味着，我们创建的数组是Node[]
③ 在jdk8中，如果当前的(key,value)经过一系列判断之后，可以添加到当前的数组角标i中。如果此时角标i位置上有元素。在jdk7中是将新的(key,value)指向已有的旧的元素（头插法），而在jdk8中是旧的元素指向新的(key,value)元素（尾插法）。
④
jdk7:数组+单向链表
jk8:数组+单向链表 + 红黑树
单向链表 ------> 红黑树：如果数组索引i位置上的元素的个数达到8，并且数组的长度达到64时。（红黑树进行put()/get()/remove()操作的时间复杂度为O(logn)，而单向链表的时间复杂度为O(n)）
红黑树 ------> 单向链表：当使用红黑树的索引i位置上的元素的个数低于6的时候。

2.4 HashMap属性字段

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认的初始容量 16
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量  1 << 30
static final float DEFAULT_LOAD_FACTOR = 0.75f;  //默认加载因子
static final int TREEIFY_THRESHOLD = 8; //默认树化阈值8，当链表的长度达到这个值后，要考虑树化
static final int UNTREEIFY_THRESHOLD = 6;//默认反树化阈值6，当树中结点的个数达到此阈值后，要考虑变为链表

//当单个的链表的结点个数达到8，并且table的长度达到64，才会树化。
//当单个的链表的结点个数达到8，但是table的长度未达到64，会先扩容
static final int MIN_TREEIFY_CAPACITY = 64; //最小树化容量64

transient Node<K,V>[] table; //数组
transient int size;  //记录有效映射关系的对数，也是Entry对象的个数
int threshold; //阈值，当size达到阈值时，考虑扩容
final float loadFactor; //加载因子，影响扩容的频率

3、LinkedHashMap底层逻辑

3.1 LinkedHashMap 与 HashMap 的关系

----LinkedHashMap是HashMap的子类。
----LinkedHashMap在HashMap使用的数组+单向链表+红黑树的基础上，又增加了一对双向链表，记录添加的(key,value)的先后顺序。便于我们遍历所有的key-value。

3.2 底层结构

//LinkedHashMap内部定义了一个Entry
static class Entry<K,V> extends HashMap.Node<K,V> {
    Entry<K,V> before, after; //增加的一对双向链表
    Entry(int hash, K key, V value, Node<K,V> next) {
        super(hash, key, value, next);
    }
}