java集合（附源码分析）

集合分类

Collection接口（单列集合）

List接口： 特性继承collection集合，排列有序且可重复
- LinkedList 接口实现类：链表实现，适用于插入删除型链表，线程不安全
- ArrayList 接口实现类：数组实现，适用于随机访问型链表，线程不安全
- Vector 接口实现类：数组实现，线程安全。
**Set接口：**特性继承collection集合，排列无序且不可重复
- HashSet 接口实现类：适用hash表（数组）存储元素。
  - LinkedHashSet 继承HashSet，实现Set,链表维护元素的插入次序。
- TreeSet 接口实现类：二叉树实现，元素有序。

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_ELEMENTDATAif (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节点中也用到nextNode<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 thresholdnewCap = oldThr;else {               // zero initial threshold signifies using defaultsnewCap = DEFAULT_INITIAL_CAPACITY;newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);}
复制代码

首先将table和他的长度赋给oldTab和oldCap，其值自然等于空和0；就直接进入了最后一个else，就把将容量设置成了默认的16

TreeMap

与HashMap相比，TreeMap是一个能比较元素大小的Map集合，其本质就是红黑树，会对传入的key进行大小排序。其中，可以使用元素的自然顺序，也可以使用集合中自定义的比较器来进行排序；所以这里就不详细说了。