JDK源码学习（jdk1.8.0_20）
集合框架
ArrayList
基于jdk1.8.0_20
| 关注点 | 结论 |
|---|---|
| ArrayList是否允许空 | 允许 |
| ArrayList是否允许重复数据 | 允许 |
| ArrayList是否有序 | 有序 |
| ArrayList是否线程安全 | 非线程安全 |
继承关系图 
ArrayList的定义
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.SerializableArrayList的底层使用Object数组来存储的
transient Object[] elementData;以前听说ArrayList的初始大小为10，应该是以前的版本，我这个版本中ArrayList如果不指定大小时默认为空
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}在这里主要关注一下自动扩容的实现
public boolean addAll(Collection c) {
Object[] a = c.toArray();
int numNew = a.length;
//确保数组大小超过size + numNew
ensureCapacityInternal(size + numNew);
//实现数组复制，a是源数组，0是源数组要复制的起始位置，elementData是目的数组
//size是目的数组放置的起始位置，numNew复制的长度
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
//如果c为空则返回false,不为空则返回true
return numNew != 0;
}public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}增加一个元素或者增加好几个元素都会在调用ensureCapacityInternal方法来确保数组大小足够大，可以确定在ensureCapacityInternal方法里面实现了自动扩容
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
private static final int DEFAULT_CAPACITY = 10;private void ensureCapacityInternal(int minCapacity) {
//目前数组为空
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
//要求的容量大小和10取最大值
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}private void ensureExplicitCapacity(int minCapacity) {
modCount++;
//这个是出于2种考虑
//如果需要的容量大于目前的容量，就需要扩容
//如果minCapacity溢出，即minCapacity为负数，就不扩容
//minCapacity为负数的一种情况是addAll(Collection c)传入的参数已经溢出了
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}//之所以定义为Integer.MAX_VALUE - 8，是因为VM会保留一些头结点在数组开头
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//>>是右移运算符，相当于除以2，因此新容量是旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
//这里需要分为2种情况
//1.扩容还不满足，直接将新容量设为需要的容量
//2.newCapacity溢出，变为负数，扩充容量扩的太大了
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);
}private static int hugeCapacity(int minCapacity) {
//溢出了，minCapacity的值大于int能存储的最大值，用int存储会变为负数
//这里minCapacity之所以为负数，可能是因为vm进行了一些操作
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}这个类实现数组复制用的是System.arraycopy方法，这个方法复制比较快，因为是对内存直接进行复制，减少了for循环中的寻址时间
//实现数组复制，a是源数组，0是源数组要复制的起始位置，elementData是目的数组
//size是目的数组放置的起始位置，numNew复制的长度
System.arraycopy(a, 0, elementData, size, numNew);LinkedList
基于jdk1.8.0_20
| 关注点 | 结论 |
|---|---|
| LinkedList是否允许空 | 允许 |
| LinkedList是否允许重复数据 | 允许 |
| LinkedList是否有序 | 有序 |
| LinkedList是否线程安全 | 非线程安全 |
继承关系图 
LinkedList的定义
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.SerializableLinkedList采用的双向链表结构，因此在LinkedList中定义了一个静态内部类
private static class Node {
//存放元素
E item;
//相当于后向指针，指向链表中当前元素的后一个元素
Node next;
//相当于前向指针，指向链表中当前元素的前一个元素
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
} 定义的变量为
//链表的长度
transient int size = 0;
//链表的头结点
transient Node first;
//链表的尾结点
transient Node last; 增加元素的方法，addFirst，addLast，add都很类似，分析一个
public void addFirst(E e) {
linkFirst(e);
}private void linkFirst(E e) {
//把链表的头结点放到f这个中途变量
final Node f = first;
//构造结点，前向指针为null，元素为e，后向指针指到f
final Node newNode = new Node<>(null, e, f);
//插入的结点编程头结点
first = newNode;
//如果原先头结点为空
if (f == null)
//构造的结点不仅为头结点，也是尾结点
last = newNode;
else
//原先头结点的前向指针指向构造的结点
f.prev = newNode;
//元素个数加1
size++;
//每次对元素进行操作时，这个都会增加1，主要为了迭代器校验错误使用
modCount++;
}
删除元素的方法
public boolean remove(Object o) {
if (o == null) {
for (Node x = first; x != null; x = x.next) {
if (x.item == null) {
unlink(x);
return true;
}
}
} else {
for (Node x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
unlink(x);
return true;
}
}
}
return false;
} E unlink(Node x) {
// assert x != null;
final E element = x.item;
final Node next = x.next;
final Node prev = x.prev;
//如果前向指针为空，则说明它是头结点，删除时只要把它的下一个结点赋值为头结点即可
if (prev == null) {
first = next;
} else {
//前向结点的后向指针直接指向后向结点，从开头遍历不到这个结点
prev.next = next;
x.prev = null;
}
//如果后向指针为空，则说明它是尾结点，删除时只要把它的上一个结点赋值为尾结点即可
if (next == null) {
last = prev;
} else {
//后向结点的前向指针直接指向前向结点，从结尾遍历不到这个结点
next.prev = prev;
x.next = null;
}
//把x.prev和x.next赋值为null，LZ猜是为了加速垃圾回收，但没有实际测试
x.item = null;
size--;
modCount++;
return element;
} 获取元素的方法
public E get(int index) {
//检查下标是否越界
checkElementIndex(index);
return node(index).item;
}Node node(int index) {
// assert isElementIndex(index);
//size >> 1和size / 2一个效果，因为将位右移一位相当于除2
//在前半段，正向遍历
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
//在后半段，反向遍历
} else {
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
} 分析源码可知，通过get方式遍历LinkedList是一种很低效的方式，因为每找一个元素都是从头或者尾开始的，最好采用foreach或迭代器方式
Hashtable
基于jdk1.7.0_80
| 关注点 | 结论 |
|---|---|
| Hashtable是否允许空 | key和value均不允许为空 |
| Hashtable是否允许重复数据 | 不允许 |
| Hashtable是否有序 | 无序 |
| Hashtable是否线程安全 | 线程安全 |
构造函数，默认初始容量为11
public Hashtable(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal Load: "+loadFactor);
if (initialCapacity==0)
initialCapacity = 1;
this.loadFactor = loadFactor;
table = new Entry[initialCapacity];
threshold = (int)Math.min(initialCapacity * loadFactor, MAX_ARRAY_SIZE + 1);
initHashSeedAsNeeded(initialCapacity);
}public Hashtable() {
this(11, 0.75f);
}put
public synchronized V put(K key, V value) {
//value为null抛出空指针异常
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry tab[] = table;
int hash = hash(key);
//7FFFFFFF的二进制为1111111111111111111111111111111
//hash & 0x7FFFFFFF是为了保hash值始终为正数
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
modCount++;
//数量已经达到阈值
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
//table的值已经变化
tab = table;
//重新进行hash
hash = hash(key);
index = (hash & 0x7FFFFFFF) % tab.length;
}
//取出目前链表第一位
Entry e = tab[index];
//将新增加的值变为第一个值
tab[index] = new Entry<>(hash, key, value, e);
count++;
return null;
} 和HashMap的区别
| 关注点 | Hashtable | HashMap |
|---|---|---|
| 是否线程安全 | 是 | 否 |
| key和vlaue | 均不允许为空 | 都可以为空 |
| 求index的方法 | (hash & 0x7FFFFFFF) % table.length; | hash & (table.length - 1) |
| 扩容的时机 | count >= threshold | (size >= threshold) && (null != table[bucketIndex]) |
| 扩容的大小 | table.length<<1+1 | 2 * table.length |
get
public synchronized V get(Object key) {
Entry tab[] = table;
int hash = hash(key);
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
return e.value;
}
}
return null;
} 这里put和get方法都没有对key进行空值判断，是因为key为null调用hash会抛出空指针异常
private int hash(Object k) {
// hashSeed will be zero if alternative hashing is disabled.
return hashSeed ^ k.hashCode();
}Vector
基于jdk1.8.0_20
Stack
基于jdk1.8.0_20
ArrayDeque
基于jdk1.8.0_20
参考博客
归并排序
[1]http://www.cnblogs.com/chengxiao/p/6194356.html
>>和>>>的区别
[1]http://blog.csdn.net/blog_szhao/article/details/23997881
modCount的作用
[1]http://blog.csdn.net/u012926924/article/details/50452411
各种链表
[1]http://blog.csdn.net/fisherwan/article/details/25796625
LinkedList源码
[1]http://blog.csdn.net/jzhf2012/article/details/8540543
HashMap实现原理
[1]https://www.cnblogs.com/chengxiao/p/6059914.html
[2]http://ms.csdn.net/geek/187726
System.arraycopy方法
[1]https://segmentfault.com/a/1190000009922279
Hashtable
[1]http://blog.csdn.net/chdjj/article/details/38581035