Java主要容器
总结容器中重要使用的数据结构。
先罗列接口和抽象类（主要的）的组织结构：
接口：
-Collection
--List
--Set
---SortedSet
----NavigableSet
--Queue
---Deque
-Map
--SortedMap
---NavigableMap抽象类：
-AbstractCollection
--AbstractList
---AbstractSequentialList
----LinkedList(1.掌握)
---ArrayList(2.掌握)
---Vector(3.掌握)
----Stack(4.掌握)
--AbstractSet
---HashSet(5.掌握)
---TreeSet(6.掌握)
--ArrayDeque(7.掌握)
-AbstractMap
--HashMap(8.掌握)
--TreeMap(9.掌握)
--IdentityHashMap(10.熟悉)
--WeakHashMap(11.熟悉)
-Hashtable(12.掌握)
-LinkedHashMap(13.掌握)1.LinkedList
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, Serializable
基本结构：
Node<E> first;//头指针
Node<E> last;//尾指针
结构特点：
1.双向链表
2.not synchronized(非同步)
思想：
采用双向链表的方式进行数据存储。每个结点含有三个域:一个数据域，两个指针域(prev,next)。
优点：
1.在内存无限制的环境下，数据存储量不限。
2.在数据的插入、删除操作上简单。只需要改变prev和next的指向对象。
3.数据的写入顺序和逻辑存储顺序一致
缺点：
1.每查找特点的元素，需要遍历整个链表。最坏的时间复杂度为o(n)
2.ArrayList
public class ArrayList<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
基本结构：
transient Object[] elementData;//数组
private static final int DEFAULT_CAPACITY = 10;//默认存储大小
private int size;//记录数据
结构特点：
1.动态数组
2.not synchronized(非同步)
思想：
采用动态数组对数据进行存储，设置数组默认大小，超过容量扩容，每次扩容大小为原始容量的0.5倍。数组最大
容量为Integer.MAX_VALUE。
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);//扩容
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
elementData = Arrays.copyOf(elementData, newCapacity);
}
优点：
1.利用数组的优点，随机读取速度快。时间复杂度O(1)。
2.数据的写入顺序和逻辑存储顺序一致
缺点：
1.插入和删除改变了数组的结构，数组中其他元素需要移位。时间开销最坏为o(n)
2.数组容量有限，数组过大时，扩容开销也大。
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));//扩容的核心：数组的拷贝
return copy;
}
3.Vector
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, Serializable
基本结构：
protected Object[] elementData;//数组
protected int elementCount;//计数
protected int capacityIncrement;//数组增量
结构特点：
1.动态数组
2.synchronized(同步)
优点：1.同ArrayList
2.线程安全
缺点：1.同ArrayList
2.在不需要线程安全的情况下，使用Vector效率低于ArrayList
不同于ArrayList之处：
1.Vector同步，ArrayList不同步
2.Vector自定义数组扩容大小，ArrayList系统默认。
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//不指定capacityIncrement时，扩容一倍;指定capacityIncrement,按capacityIncrement扩容
int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
capacityIncrement : oldCapacity);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
4.Stack
public class Stack<E>
extends Vector<E>
基本结构：
protected Object[] elementData;//数组
protected int elementCount;//计数
结构特点：
1.栈
2.synchronized(同步)
2.动态数组
优点：1.先进后出
2.线程安全
3.争议：Stack实现了Vector，可以调用父类的方法，不但可以对栈顶元素进行操作，还可以进行随机
元素的增删查改。
缺点：1.容量有限
5.HashSet
public class HashSet<E>
extends AbstractSet<E>
implements Set<E>, Cloneable, Serializable
基本结构：
private transient HashMap<E,Object> map;
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
结构特点：
1.动态数组+单向链表+红黑树
2.not synchronized(非同步)
3.散列表
思想：
1.利用HashMap 的键的唯一性，构建“集”。
2.集通过数据的hashcode值进行映射地址。
3.采用单向链表对同一地址的数据进行存储
hash映射方法：
见HashMap
优点：1.读取、插入、删除速度时间短
缺点：1.存储地址根据hash映射，无法顺序存储
6.TreeSet
public class TreeSet<E>
extends AbstractSet<E>
implements NavigableSet<E>, Cloneable, Serializable
基本结构：
private transient NavigableMap<E,Object> m;//TreeMap
// Dummy value to associate with an Object in the backing Map
private static final Object PRESENT = new Object();
结构特点：
1.红黑树
2.not synchronized(非同步)
思想：
1.利用红黑树的二分查找思想，对数据进行顺序存储
注意：存储的元素类必须实现Comparable接口 或者 在构造方法中给出Comparator并实现compare方法
优点：1.顺序存储
缺点：1.相比HashSet类，TreeSet类插入元素和删除元素速度较慢。因为需要重新对红黑数进行平衡。
7.ArrayDeque
public class ArrayDeque<E>
extends AbstractCollection<E>
implements Deque<E>, Cloneable, Serializable
基本结构：
transient Object[] elements; // non-private to simplify nested class access
/**
* The index of the element at the head of the deque (which is the
* element that would be removed by remove() or pop()); or an
* arbitrary number equal to tail if the deque is empty.
*/
transient int head;
/**
* The index at which the next element would be added to the tail
* of the deque (via addLast(E), add(E), or push(E)).
*/
transient int tail;
结构特点：
1.动态数组
2.栈
3.队列
4.双向队列
5.循环队列
思想：
对数组指定一个头指针和尾指针。即可以头插头删，也可以尾插尾删。不可以对非头尾结点进行查找。
栈：数组进行尾插尾删
循环队列：头删尾入。当头遇到尾时，数组扩容。
private static final int MIN_INITIAL_CAPACITY = 8;//默认数组大小
private void doubleCapacity() {//数组扩容1倍
assert head == tail;
int p = head;
int n = elements.length;
int r = n - p; // number of elements to the right of p
int newCapacity = n << 1;
if (newCapacity < 0)
throw new IllegalStateException("Sorry, deque too big");
Object[] a = new Object[newCapacity];
System.arraycopy(elements, p, a, 0, r);
System.arraycopy(elements, 0, a, r, p);
elements = a;
head = 0;
tail = n;
}
public void addFirst(E e) {//头插
if (e == null)
throw new NullPointerException();
elements[head = (head - 1) & (elements.length - 1)] = e;//循环数组
if (head == tail)//头遇到尾
doubleCapacity();//扩容
}
public void addLast(E e) {//尾插
if (e == null)
throw new NullPointerException();
elements[tail] = e;
if ( (tail = (tail + 1) & (elements.length - 1)) == head)//循环数组
doubleCapacity();//扩容
}
优点：1.实现栈和队列两个数据结构
2.循环数组利用空间
缺点：1.not synchronized(非同步)
8.HashMap
public class HashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable
基本结构：
transient Node<K,V>[] table;//数组
static class Node<K,V> implements Map.Entry<K,V>;//单向链表
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> ;//红黑树
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;//默认数组容量
static final int MAXIMUM_CAPACITY = 1 << 30;//最大数组容量
static final float DEFAULT_LOAD_FACTOR = 0.75f;//装填因子
static final int TREEIFY_THRESHOLD = 8;//树化阈值
static final int UNTREEIFY_THRESHOLD = 6;//链化阈值
transient int size;//键值对数
int threshold;//临界容量
结构特点：
1.动态数组+单向链表+红黑树
2.键值对映射
3.散列表
hash映射方法：
static final int hash(Object key) {
int h;
//hashcode值 异或 h >>> 16
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
数组下标地址映射：
/*
*hash 为 数的hash映射值，n为数组容量。i为映射下标值
*/
tab[i = (n - 1) & hash]
同一hash映射值存储于同一个数组单元中，每个单元默认采用单向链表连接数据。
当链表长度小于 8 时，采用 单向链表 连接
单向链表查找元素速度为o(n)
当链表长度大于 8 时，转换为 红黑树 存储
红黑树查找元素采用二分查找，速度为log(n)
当 table数组元素 size 大于 threshold 时，进行扩容 和 再散列。
if (++size > threshold)
resize();
扩容
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)//容量扩充一倍
newThr = oldThr << 1; // double threshold
新临界阈值：
float ft = (float)newCap * loadFactor;//新容量 * 装填因子
再散列：
对每个元素进行重新的hash映射地址。
若新的下标元素集元素低于 UNTREEIFY_THRESHOLD 值 时，红黑树 转为 单向链表
注意：
jdk1.8之前，HashMap 只采用单向链表来解决哈希冲突。
jdk1.8及以后，HashMap采用 单向链表+红黑树的方式来综合使用，大大提高了查找的效率。
优点：1.动态数组+链表
缺点：1.not synchronized(非同步)
9.TreeMap
public class TreeMap<K,V>
extends AbstractMap<K,V>
implements NavigableMap<K,V>, Cloneable, Serializable
基本结构：
private final Comparator<? super K> comparator;//比较器接口
private transient Entry<K,V> root;//根节点
/**
* The number of entries in the tree
*/
private transient int size = 0;//键值对数
/**
* The number of structural modifications to the tree.
*/
private transient int modCount = 0;//修改计数
static final class Entry<K,V> implements Map.Entry<K,V>;//红黑树结构
结构特点：
1.红黑树
思想：利用红黑树对数据的二分排列，实现数据的有序存储
注意：元素必须实现Comparable接口或者提供实现了compare方法的Comparator接口
优点：1.查找，插入，删除速度快
缺点：1.在非要求顺序的情况下，HashMap更快
2.not synchronized(非同步)
10.IdentityHashMap
public class IdentityHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>, Serializable, Cloneable
基本结构：
private static final int DEFAULT_CAPACITY = 32;
private static final int MINIMUM_CAPACITY = 4;
private static final int MAXIMUM_CAPACITY = 1 << 29;
transient Object[] table;
transient int modCount;
结构特点：
1.动态数组+单向链表
2.散列表
思想：
private static int hash(Object x, int length) {
int h = System.identityHashCode(x);//利用System.identityHashCode方法映射hash
// Multiply by -127, and left-shift to use least bit as part of hash
return ((h << 1) - (h << 8)) & (length - 1);
}
优点：1.每个不同的对象都对应着不同的地址，即使内容相同
缺点：not synchronized(非同步)
11.WeakHashMap
public class WeakHashMap<K,V>
extends AbstractMap<K,V>
implements Map<K,V>
基本结构：
Entry<K,V>[] table;
private int threshold;
private final float loadFactor;
private final ReferenceQueue<Object> queue = new ReferenceQueue<>();//元素引用队列
结构特点：
1.动态数组+单向链表
2.散列表
3.引用队列
思想：对无其他对象访问的键值对(本数组下标除外)，添加到queue中，并结合jvm垃圾回收进行处理。
优点：1.内存友好
缺点：not synchronized(非同步)
12.Hashtable
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, Serializable
属性、结构同HashMap一致
优点：synchronized(同步)
13.LinkedHashMap
public class LinkedHashMap<K,V>
extends HashMap<K,V>
implements Map<K,V>
基本结构：
transient LinkedHashMap.Entry<K,V> head;
transient LinkedHashMap.Entry<K,V> tail;
final boolean accessOrder;//元素发生改变，就将该元素移到数组最后
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);
}
}
结构特点：
1.将 HashMap.Node 的 四个域 变成 六个域，添加了 before 域 和 after 域。用于存储前一个结点和后一个结点，建立顺序关系。
优点：1.按数据存入顺序存储
2.aeecessOrder为true时，常操作的元素总在链表最后，最近不常用的数据总在最前面。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
