集合分类
Collection接口（单列集合）
- List接口： 特性 继承collection集合，排列有序且可重复
- LinkedList 接口实现类：链表实现，适用于插入删除型链表，线程不安全
- ArrayList接口实现类：数组实现，适用于随机访问型链表，线程不安全
- Vector接口实现类：数组实现，线程安全。
- **Set接口：**特性 继承collection集合，排列无序且不可重复
- HashSet接口实现类：适用hash表（数组）存储元素。
- LinkedHashSet 继承HashSet，实现Set,链表维护元素的插入次序。
- TreeSet接口实现类：二叉树实现，元素有序。
- HashSet接口实现类：适用hash表（数组）存储元素。
Map接口（双列集合）
- HashTable 接口实现类，线程安全。
- HashMap 接口实现类，线程不安全。
- LinkedHashMap 双向链表和哈希实现类。
- WeakHashMap
- TreeMap 红黑树对所有的key进行排序。
- IdentifyHashMap
总结
Map和List、Set的区别
- Map是接口，而List和Set是Collection的子接口
- Map是双列集合，而List和set是单列集合
List和set的区别
- List 是排列有序且可重复得集合，而且可以通过索引查询集合中的元素。
- Set 排列无序且不可重复，没有索引，当然，Set中的实现类LinkedHshSet是通过链表维护着插入顺序的。
List集合
有序列表，允许存放重复元素；其实现类由三个：
- ArrayList：数组实现，查询快，增删慢，轻量级；(线程不安全)
- LinkedList：双向循环链表实现，增删快，查询慢 (线程不安全)
- Vector：数组实现，重量级 (线程安全、使用少)
List的四种遍历方式
public class ListTest {
public static void main(String[] args) {
List<Integer> list=new ArrayList<>();
list.add(1);
list.add(2);
list.add(3);
//方法一，使用for循环（这种方法Set集合不适用）
for (int i = 0; i <list.size() ; i++) {
System.out.println(list.get(i));
}
//方法二：增强for循环
for(Integer elem:list){
System.out.println(elem);
}
//方法三：迭代器实现遍历（第一种和第二种的底层也是使用迭代器实现
Iterator<Integer> integerIterator=list.iterator();
while (integerIterator.hasNext()){
Integer elem=integerIterator.next();
System.out.println(elem);
}
//方法四：Lambda表达式+流式编程
list.forEach((elem)->System.out.println(elem));
//使用方法引用输出
list.forEach(System.out::println);
}
}
ArrayList自动扩充机制
源码：
private void add(E e, Object[] elementData, int s) {
// 判断元素个数是否等于当前容量
if (s == elementData.length)
elementData = grow();
elementData[s] = e;
size = s + 1;
}
private Object[] grow() {
return grow(size + 1);
}
private Object[] grow(int minCapacity) {
// 获取老容量，也就是当前容量
int oldCapacity = elementData.length;
// 如果当前容量大于0 或者 数组不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
int newCapacity = ArraysSupport.newLength(oldCapacity,
minCapacity - oldCapacity, /* minimum growth */
oldCapacity >> 1 /* preferred growth */);
return elementData = Arrays.copyOf(elementData, newCapacity);
// 如果 数组是DEFAULTCAPACITY_EMPTY_ELEMENTDATA（容量等于0的话，只剩这一种情况了）
} else {
return elementData = new Object[Math.max(DEFAULT_CAPACITY, minCapacity)];
}
}
扩容可分为两种情况：
第一种情况，当ArrayList的容量为0时，此时添加元素的话，需要扩容，三种构造方法创建的ArrayList在扩容时略有不同：
1.无参构造，创建ArrayList后容量为0，添加第一个元素后，容量变为10，此后若需要扩容，则正常扩容。
2.传容量构造，当参数为0时，创建ArrayList后容量为0，添加第一个元素后，容量为1，此时ArrayList是满的，下次添加元素时需正常扩容。
3.传列表构造，当列表为空时，创建ArrayList后容量为0，添加第一个元素后，容量为1，此时ArrayList是满的，下次添加元素时需正常扩容。
第二种情况，当ArrayList的容量大于0，并且ArrayList是满的时，此时添加元素的话，进行正常扩容，每次扩容到原来的1.5倍。
ArrayList的线程安全解决方案
-
用victor代替；List list = new Vector<>();
-
用Colections：List list = Collections.synchronizedList(new ArrayList);
-
List list = CopyOnWriteArrayList<>();
LinkedList
采用双向链表实现，可以用来实现stack，queue，双向队列，但是哟实现的时候需要遵循实现结构的特性，比如实现栈的时候不能提供不是栈顶的元素出栈的方法，实现对列的时候需要遵循先进先出原则。
vector
和ArrayList类似，但是其实重量级组件，同时也是线程安全的，适用于高并发的场景。
List常用方法
-
void add(int index, Object element) ：添加对象element到位置index上
-
boolean addAll(int index, Collection collection) ：在index位置后添加容器collection中所有的元素
-
Object get(int index) ：取出下标为index的位置的元素
-
int indexOf(Object element) ：查找对象element 在List中第一次出现的位置
-
int lastIndexOf(Object element) ：查找对象element 在List中最后出现的位置
-
Object remove(int index) ：删除index位置上的元素
-
ListIterator listIterator(int startIndex) ：返回一个ListIterator 跌代器，开始位置为startIndex
-
List subList(int fromIndex, int toIndex) ：返回一个子列表List ,元素存放为从 fromIndex 到toIndex之前的一个元素
Set集合
继承collection接口，一个无序集合，存放唯一元素（允许存放空值）。
Set集合的实现类可说是基于Map集合去写的。通过内部封装Map集合来实现的比如HashSet内部封装了HashMap。
Set集合的数据库不能重复（== 或 eqauls）的元素
Set集合的常用实现类有 HashSet TreeSet
HashSet
底层实现是对hashmap的封装；内部不能存放相同的对象（通过hashcode和equal实现，实际运用过程中需要自己重写这两个方法）；
- 根据hashcode方法计算对象的hashcode。
- hashcode就决定了该元素存放在数据结构中的什么位置，然后再查看这个位置上是否存在元素，如果没有就直接放入，如果有对象存储就需要调用equal方法判断两个对象是否相同，如果相同就拒绝添加，否则就进行存储，也就实现了对象的不重复。
所以，hashcode相同的，也不见得两个对象就相等，而两个对象相等，hashcode一定相等；但我们最好让每个对象的hashcode和equal方法判断的结果一致，也就是说只要hashcode相等，我们就尽量让equal方法也判断为true；
重写hashcode：
@Override
public void hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((age==null)? 0 : age.hashCode());
//通过迭代的方式进行
result = prime * result + ((age==null)? 0 : name.hashCode());
return result;
}
LinkedHashSet
跟hashset 的区别是底层通过链表维护了添加元素的顺序，每个元素都保存了下一个元素的所在位置，这样在遍历的时候就能找到对应的元素。
TreeSet
TreeSet基于TreeMap实现，TreeMap本质就是红黑树。所以TreeSet其实于是基于红黑树的。
TreeSet有个特点，插入无序内部有序。
插入数据实现Comparable接口，通过compareTo方法去比较大小，或者在实l例化TreeSet的时候自定义排序Comparator方法。内部的int compare(T o1, T o2)比较对象大小。
如果插入数据即不实现Commparable或在插入的时候也不指定排序方式Comparator那么就会报错
Set集合的遍历
1.增强for循环（底层依赖迭代器实现）
for (Object object : set) {
System.out.println(object);
}
2.迭代器
Iterator iterator = set.iterator();
while(iterator.hasNext()) {
System.out.println(iterator.next());
}
3.jdk8新特性
set.forEach((x) -> System.out.println(x));
//或者
set.forEach((x)->System.out::println);
Map集合
HashMap
HashMap是由数组+链表+红黑树（JDK1.8后增加了红黑树部分）实现的。
Node<k,v>用来实现数组及链表的数据结构：
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //保存节点的hash值
final K key; //保存节点的key值
V value; //保存节点的value值
//next是指向链表结构下当前节点的next节点，红黑树TreeNode节点中也用到next
Node<K,V> next;
......
}
TreeNode<K,V>用来实现红黑树相关的存储结构：
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; //存储当前节点的父节点
TreeNode<K,V> left; //存储当前节点的左孩子 TreeNode<K,V> right; //存储当前节点的右孩子
TreeNode<K,V> prev; //存储当前节点的前一个节点
boolean red; //存储当前节点的颜色（红、黑） TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
hashmap中常量：
//hashmap未指定初始容量的默认容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 16
//hashmap的最大容量
static final int MAXIMUM_CAPACITY = 1 << 30; //1073741824
//hashmap默认的装载因子，当超过容量*因子时，进行扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//指定何时解决hash冲突，链表转换为红黑树
static final int TREEIFY_THRESHOLD = 8;
//何时解决hash冲突的，红黑树转变为链表
static final int UNTREEIFY_THRESHOLD = 6;
//当想要将解决hash冲突的链表转变为红黑树时，需要判断下此时数组的容量，若是由于数组容量太小而导致hash冲突，则不进行链表转为红黑树的操作，而是利用resize()函数对HashMap扩容
static final int MIN_TREEIFY_CAPACITY = 64;
hashmap的扩容：
final Node<K,V>[] resize() {
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int newCap;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {//略}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
}
}
-
hashmap刚创建的时候，table是null，size是0，是为了节约空间，当添加第一个元素后，table容量就调整为16.
-
当元素个数大于阈值（容量*容量因子）就会进行扩容，扩容后的大小为原来的两倍，减少元素调整的个数
-
在jdk1.8中当每个链表的长度大于8，并且数组元素个数大于64时，会调整成红黑树，目的是提高元素的查找效率。当链表的长度小于6时，调整成链表。
-
在jdk1.8之前链表元素的插入是头插，jdk1.8之后链表元素的插入是尾插。
hashmap的put方法：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
put方法把key和value传给了putVal，同时还传入了一个hash(Key)所返回的值(产生hashcode)
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else{
//略
}
}
第一个if是判断table是否为空，刚创建HashMap对象时，此时tab和table都为空，满足条件，执行内部代码，这条代码其实就是把resize()所返回的结果赋给tab，n就是tab的长度，resize顾名思义就是重新调整大小。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
首先将table和他的长度赋给oldTab和oldCap，其值自然等于空和0；就直接进入了最后一个else，就把将容量设置成了默认的16
TreeMap
与HashMap相比，TreeMap是一个能比较元素大小的Map集合，其本质就是红黑树，会对传入的key进行大小排序。其中，可以使用元素的自然顺序，也可以使用集合中自定义的比较器来进行排序；所以这里就不详细说了。
