集合

集合

容器，存储多个数据。底层使用不同的数据结构进行存储，每种数据结构都有各自的特点。

一.Collection接口（集成迭代器接口，Collection的实现类可以使用迭代器）

1.Queue：队列

队列中的数据元素遵循“先进先出”（First In First Out）的原则，简称FIFO结构。
在队尾添加元素，在队头删除元素。

2.List：

1. ArrayList：

        底层实现：数组（数组扩容）
        特点：
            1.存储元素有序（存储顺序）
            2.存储元素允许重复
            3.查找效率高（底层的数组为连续的空间）
            4.删除，添加时效率低
                涉及到元素的移动，数组的扩容（拷贝原数组中的数据）
            5.数组扩容时为原数组1.5倍
            6.线程不安全

2.LinkedList：

        底层实现：链表（双向链表，提高查询效率，可以从头结点或尾结点查找）
        特点：
            1.存储元素有序（存储顺序）
            2.存储元素允许重复
            3.查找效率低
            4.删除，添加时效率高
                修改前后节点地址，不需要扩容
            5.不涉及扩容
            6.线程不安全

3.Vector:

        底层实现：数组（数组扩容）
        特点和ArrayList相似，线程安全

4.List接口实现类遍历方式

        1.普通for循环
        2.增强for循环
        3.迭代器

3.Set：

1.HashSet：

        底层实现：HashMap（以key-value形式存储，存储到散列表中）
        存储过程：
            将存储的元素作为底层HashMap存储时的key，value值自动的创建。
        特点：
            1.存储元素无序
            2.存储元素不允许重复
            3.没有提供获取元素方法，只能遍历获取（1.增强for循环 2.迭代器）
            4.线程不安全

2.TreeSet：

        底层实现：TreeMap（以key-value形式存储，存储到红黑树中）
        存储过程：
             将存储的元素作为底层TreeMap存储时的key，value值自动的创建。
             将key进行值的比较存储到红黑树的制定位置。
         特点：
            1.存储元素有序（值大小顺序）
            2.存储元素不允许重复
            3.没有提供获取元素方法，只能遍历获取（1.增强for循环 2.迭代器）
            4.线程不安全

二.Map接口（key-value形式存储）

1.HashMap：

底层实现：

        1.jdk1.8之前：数组 + 链表
            1.扩容时使用头插
            2.散列表的数组扩容后为原数组的2倍

        2.jdk1.8及之后：数组 + 链表 + 红黑树 （红黑树可以提高查询的效率）

1.重要的属性：

                1.DEFAULT_INITIAL_CAPACITY=16：默认数组的初始换容量（没有指定数组长度使用该默认值）
                2.MAXIMUM_CAPACITY=2^30：数组最大长度
                3.DEFAULT_LOAD_FACTOR=0.75f：默认负载因子（数组长度*负载因子 = 扩容阈值）
                4.TREEIFY_THRESHOLD=8：链表转换为红黑树的链表个数阈值
                5.UNTREEIFY_THRESHOLD=6：红黑树转换为链表的链表个数的阈值
                6.MIN_TREEIFY_CAPACITY=64：链表转换为红黑树的最小数组长度
                7.threshold：阈值
                8.loadFactor：负载因子

2.构造方法：

                1.new HashMap();
                    1.默认的负载因子为负载因子属性赋值
                    2.没有创建散列表底层的数组
                2.new HashMap(数组长度);
                    1.默认的负载因子为负载因子属性赋值
                    2.计算了数组的长度（必须为2的n次幂）
                    3.没有创建散列表底层的数组
                3.new HashMap(数组长度,负载因子);
                    1.指定的负载因子为负载因子属性赋值
                    2.计算了数组的长度（必须为2的n次幂）
                    3.没有创建散列表底层的数组

3.put()：

                1.计算key的Hash值（(h = key.hashCode()) ^ (h >>> 16)，减少Hash冲突）
                2.判断散列表中的数组是否为nll
                    1.null：（数组还未创建）
                        1.new HashMap();
                            1.创建长度为默认长度的数组（16）
                            2.扩容阈值为，默认负载因子*默认数组长度（16*0.75=12）
                        2.new HashMap(数组长度); | new HashMap(数组长度,负载因子);
                            1.计算了数组长度（必须为2的n次幂）为threshold赋值
                                注意：
                                    只有该情况时，threshold才作为数组的长度

                            2.创建长度为2的n次幂的数组（指定的长度，不是2的n次幂自动转换为2的n次幂）
                            3.新数组长度*负载因子

                    2.非null：（数组已经创建了）
                        1.计算存储key-value的key的在数组中存储的位置
                        2.判断数组中该位置是否有节点
                            1.没有：（没有冲突），创建节点存储在该位置
                            2.有：（出现冲突）
                                1.判断存在的key和要添加的key是否相同
                                    相同：新值替换旧值
                                2.判断存在的节点是否为数节点
                                    是：添加到数中
                                3.判断节点数是否大于等于8
                                    1.>=8：判断数组长度是否大于64
                                        1.是：变为红黑树
                                        2.否：数组扩容
                                    2.<8：直接添加当前链表的尾部

                    3.++size > threshold：判断散列表中元素个数+1后是否大于扩容阈值
                        1.是：扩容
                            数组长度扩容为原数组的2倍
                            将原数组中的节点放入新数组中
                        2.否：结束

3.特点

                1.存储元素无序
                2.存储元素的key不可以重复
                3.存储元素的value可以重复
                4.散列表的数组每次扩容为原长度的2倍
                5.线程不安全

2.TreeMap:

    底层数据结构：红黑树
    特点：
        1.存储元素有序（值大小顺序）
        2.存储元素的key不可以重复并且不能为null
        3.存储元素的value可以重复
        4.线程不安全