0908集合总结

Java集合

Java的集合类主要由Collection接口和Map接口派生而来，其中Collection接口由两个常用的子接口，即List接口和Set接口，所以常说的Java集合框架由三大类接口构成（Map接口、List接口和Set接口）

List接口

1. List的实现类有Vector、ArrayList、LinkedList、Stack等
   1. Stack类内部是栈结构。是Vector类的子类
2. Vector是线程安全的
3. ArrayList是非线程安全的，ArrayList内部使用数组存储元素
4. LinkedList内部使用双向链表存储元素，
5. 因此：ArrayList集合随机访问效率高于LinkedList集合，而LinkedList集合在插入元素，删除元素使效率高于ArrayList

Set接口

1. 实现类：HashSet类和TreeSet类

Map接口

1. 实现类：HashMap类和Hashtable类等

Collection

Collectio继承了Iterable接口，

Iterable

实现了Iterable接口的类可以通过实现iterator（）方法来返回一个迭代器对象，从而使其可以使用for-each循环语法来遍历集合中的元素

在迭代的过程中不能改变结构

Queue接口

1. 继承自Collection接口的子接口
2. Queue接口不容许插入null元素，也不容许重复的元素
3. 实现类：LinkedList、ArrayDeque

Deque接口

1. 继承自Queue接口
2. 双向操作
3. 队列的特点：先进先出
4. 栈特性
5. 实现类：ArrayDeque、LinkedList

List接口

List接口继承自Collection接口

1. 是有序的集合
2. List接口的实现类：ArrayList、LinkedList、stack、Vector等

ArrayList

1. 对于ArrayList而言，它实现了List接口，底层使用数组保存所有元素
2. ArrayList提供了三种方式的构造器

LinkedList

LinkedList类是List接口的链接列表实现类，它支持实现所有List接口可选的列表的操作，并且容许元素值是如何数据，包括null

LinkedList实现了Deque接口，既能将LinkedList当做双端队列使用，

Vector

1. 实现类List接口
2. 动态数组：底层是一个数组
3. 线程安全
4. 支持随机访问
5. 可以包含重复元素
6. 可以插入null元素

stack

1. stack类是一种后进先出的数据结构，实现类栈的特点‘
2. 后进先出
3. 继承自Vector

Set接口

1. Set接口是Collection接口的另外一个常用子接口
2. 无顺序
3. 不重复
4. 不容许使用索引
5. 非同步

HashSet

1. 元素唯一
2. 无序性
3. 基于哈希表
4. 非同步
5. 容许null

TreeSet

1. 实现了Set接口的有序集合，它使用红黑树
2. 元素安装自然排序或者指定的构造器
3. 元素唯一性
4. null元素的处理：不容许null
5. 插入、删除、查找：基于红黑树
6. 迭代器顺序

Map接口

1. 键值对应：
2. 无序性
3. 容许空键值
4. 非同步

HashMap

1. 容许nul键和null值

构造方法

1. HashMap（）无参构造函数：默认容量初始化时16，默认的加载因子是0.75
2. HashMap（intinitialCapacity）可以对容量进行设置，健壮因子默认值是0.75，调用的是下面的有参构造函数
3. HashMap（int initialCapacity,float loadFactor）可以指定容量和加载因子，容量不可以小于0，也不可以无限大，加载因子也不能为0，也不能比0小
4. HashMap（Map map）创建一个新的HashMap，加载因子是默认值0.75.然后通过putMapEnries（）将map的值存储到新的HashMap中
5. HashMap底层原理：底层是数组，称为哈系桶【jdk7是数组+链表、、、jdk8是数组+链表+红黑树】

Hashtable

1. 线程安全
2. 键值不容许为null
3. 解决哈希冲突
4. 动态扩容

Queue接口

1. 继承Collection接口
2. Queue接口不容许null

ArrayDeque是Queue的实现类

1. 继承自AbstractCollection
2. 实现Queue接口
3. 底层是数组存储

LinkedList也是Queue的实现类

1. 继承AbstractSequentialList抽象类
2. 实现List、Deque、Cloneable接口
3. 底层是一个链表

Deque是非线程安全的

List接口

1. 可以存储一组不唯一、无序的对象
2. List接口继承自Collection接口
3. 是有序集合
4. 可以通过索引访问List接口中的元素
5. 实现类：ArrayList、LinkedList、Stack、Vector

ArrayList是List的实现类

1. ArrayList继承自AbstractList抽象类

2. ArrayList实现了List、Cloneable接口

3. 底层的存储使用的是数组

4. 添加元素是先判断数组是否越界，如果越界使用grow()进行扩容

5. 有三种构造方法

6. 非线程安全

7. 删除元素后，因为底层是数组，所以长度会变化

   1. List list = new ArrayList();
            list.add("a");
            list.add("b");
            list.add("c");
            list.remove(0);
            System.out.println(list.get(0));//b
            System.out.println(list.size());//2
      

LinkedList是List的实现类

1. 继承自AbstractSequentialList抽象类
2. 实现了List、Deque、Cloneable接口
3. 容许元素值是如何，可以是null
4. 可以当做双端队列使用
5. 底层是通过双向链表实现的
6. 非线程安全

Stack是List的实现类，但是他不直接实现List，而是通过继承Vector实现List接口

1. 后进先出
2. 继承自Vector
3. 线程安全
4. 底层是数组
5. 可以包含null
6. 支持随机访问

Vector也是List的实现类

1. 继承自AbstractList抽象类
2. 实现了List、Cloneable接口
3. 默认构造的容量为10
4. 线程安全
5. 可以包含重复元素
6. 可以插入null元素

Set接口

1. set接口是Collection接口的另一个常用子接口
2. 存储唯一
3. 无序对象
4. 不容许重复元素
5. 不容许使用索引
6. 非同步（非线程安全）

HashSet是Set的实现类

1. 继承自AbstractSet抽象类
2. 实现了Set、Cloneable接口
3. 基于哈希表实现
4. 非同步
5. 容许null
6. 元素唯一
7. 无序性
8. 默认加载因子0.75

TreeSet实现Set

1. 基于红黑树实现的，具有排序功能
2. TreeSet可以按照元素的自然排序进行排序，也可以提供比较器来指定排序规则
3. 元素唯一性
4. null元素的处理，不容许null

LinkedHashSet实现Set接口

1. 元素唯一
2. 保证元素插入顺序
3. 基于哈希表和链表实现的
4. 容许null
5. 迭代器顺序，按照插入顺序进行遍历
6. 

Map接口

1. 键唯一、值可重复
2. 无序性
3. 容许空键值
4. 非同步

HashMap实现Map接口

1. 继承自AbstractMap抽象类
2. 实现Map、Clonable接口
3. 默认初始容量必须是2的次幂（16）
4. 、构造函数中未指定时使用的负载系数为0.75
5. 链表的长度超过8，转为树
6. 如果树的长度超过64，则对数组进行扩容
7. 负载因子：判断是否需要扩容，默认值为0.75
8. 阈值：当HashMap的大小超过一定阈值时，会触发扩容操作
9. HashMap底层是数组
10. Jdk7==数组+链表
11. Jdk8===数组+链表+红黑树

put的过程

1. 根据key计算hash值，在put的时候判断数组是否存在，如果不存在则用resize方法创建默认长度为16的数组
2. 确定要存入的Node在数组中的位置，根据hash值与数组最大索引进行按位与运行得到索引的位置
3. 判断该位置是否有元素，如果没有直接创建一个Node存入，如果有元素，判断key是否相同，如果相同则覆盖，并且将原来的值直接返回，如果key不相同，在原Node的基础上添加新的Node，判断该位置是否是红黑树
4. 如果是红黑树，将Node存入红黑树
5. 如果是链表，遍历链表，找到最后一位，将Node存入
6. 将Node存入链表之后，判断链表的结构是否要调整，判断链表长度是否超过8，如果超过8需要将链表转为红黑树，这里还有一个条件，如果数组容量小于64，不转换红黑树，而是进行数组扩容，当数组的容量大于64的时候，再将链表转为红黑树
7. 存完之后，在判断数组是否进行扩容，根据负载因子来判断

入，如果有元素，判断key是否相同，如果相同则覆盖，并且将原来的值直接返回，如果key不相同，在原Node的基础上添加新的Node，判断该位置是否是红黑树
4. 如果是红黑树，将Node存入红黑树
5. 如果是链表，遍历链表，找到最后一位，将Node存入
6. 将Node存入链表之后，判断链表的结构是否要调整，判断链表长度是否超过8，如果超过8需要将链表转为红黑树，这里还有一个条件，如果数组容量小于64，不转换红黑树，而是进行数组扩容，当数组的容量大于64的时候，再将链表转为红黑树
7. 存完之后，在判断数组是否进行扩容，根据负载因子来判断