JDK源码阅读

Object

1) wait(), notify(), notifyAll(), wait(timeout)
2) hashCode(), equals()
3) clone()

hashCode(), equals()关系：
  因为重写的equal（）里一般比较的比较全面比较复杂，这样效率就比较低，而利用hashCode()进行对比，则只要生成一个hash值进行比较就可以了，效率很高，那么hashCode()既然效率这么高为什么还要equal()呢？
   因为hashCode()并不是完全可靠，有时候不同的对象他们生成的hashcode也会一样（生成hash值得公式可能存在的问题），所以hashCode()只能说是大部分时候可靠，并不是绝对可靠，所以我们可以得出：
1.equal()相等的两个对象他们的hashCode()肯定相等，也就是用equal()对比是绝对可靠的。
2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。  
  所有对于需要大量并且快速的对比的话如果都用equal()去做显然效率太低，所以解决方式是，每当需要对比的时候，首先用hashCode()去对比，如果hashCode()不一样，则表示这两个对象肯定不相等（也就是不必再用equal()去再对比了）,如果hashCode()相同，此时再对比他们的equal()，如果equal()也相同，则表示这两个对象是真的相同了，这样既能大大提高了效率也保证了对比的绝对正确性！

String

final class String(最终类)
1) char[] value
2) int hash
3) equals(), startWith(), endWith(), replace()

String a = "hello2";
String b = "hello";
String c = b + 2;
System.out.println((a == c));//false
String d = "hello"+2;
System.out.println((a == d));//true

AbstractStringBuilder

1) char[] value
2) int count
3) 扩容：翻倍，不够取所需最小

StringBuffer

1) 继承AbstractStringBuilder
2) synchronized方法保证线程安全
3) char[] toStringCache

StringBuilder 继承AbstractStringBuilder

ArrayList

1) Object[] elementData
2) int size
3) 默认大小10
4) 扩容：翻倍，不够取所需最小

LinkedList

1) Node {E item, Node prev, Node next}
2) int size
3) Node first
4) Node last
5) linkFirst(), linkLast(), linkBefore(), unLinkFirst(), unLinkLast(), unLink(), indexOf()

HashMap

1) Node{int hash, K key, V value, Node next}
2) 默认容量16，负载因子0.75f
3) int size, modCount, threshold, float loadFactor
4) Node[] table
5) Set entrySet
6) put():根据key算hash，根据容量和hash算index，table[index]没有直接添加到数组中，table[index]有，若index位置同一个key则更新，否则遍历next是否有，有则更新，无则新增，最后根据thread与size判断是否扩容。注：扩容时容量翻倍，重新算hash复制到新数组
7）get()类似
注：先比较hash，若相等在比较equals

Hashtable

1) 结构实现与HashMap基本一致
2)通过synchronized方法保证线程安全

HashSet

委托给HashMap，其Value是同一个默认对象

LinkedHashMap

1) Entry{HashMap.Node, Entry before, after}
2) Entry head, tail
3) 重写newNode()添加节点时，除像HashMap中添加外，保存before、after信息

LinkedHashSet

继承HashSet,HashSet委派给LinkedHashMap

ConcurrentHashMap

1) JDK1.7及以前：
a、Segment[] ,HashEntry[] , HashEntry{hash, k, v, next}
b、根据key算hash，根据hash和Segment的大小算位置，每个segment拥有一个自己的HashEntry[]
c、get()：不加锁，volatile类型
d、put(): 对相应segment加锁
e、size()：各HashEntry[] 之和，先不加锁算两遍，若一致则返回，若不一致则加锁重新计算
2）JDK1.8
a、Node{hash, key, value, next}
b、Node[] table
c、大多数操作类似于HashMap，不同CAS方式设置，根据key算hash，在根据hash和容量算index，对table[index]加锁，从而达到更大的并发量
d、get(): 同HashMap
e、put(): 对table[index]加锁
f、size():
   JDK7：遍历两次ConcurrentHashMap中的segments，每次遍历是记录每一个Segment的modCount，比较两次遍历的modCount值的和是否相同，如果相同就返回在遍历过程中获取的Segment的count的和，也就是所有元素的个数。如果不相同就重复再做一次。重复一次还不相同就将所有Segment锁住，一个一个的获取其大小(count)，最后将这些count加起来得到总的大小。当然了最后需要将锁一一释放（https://www.cnblogs.com/lanhzbupt/p/4154336.html）
  JDK8:

TreeMap

1）红黑树，即自平衡二叉查找树，时间复杂度O(logn)
2）Entry{K k, V v, Entry parent, left, right, boolean color}
3）Entry root，int size， int modeCount

TreeSet：委托TreeMap实现