1. public V put(K key, V value) {
2. return putVal(key, value, false);
3. }

 

调用了putVal方法，我们继续看看putVal方法的源码。

1. final V putVal(K key, V value, boolean onlyIfAbsent) {
2. if (key == null || value == null) throw new NullPointerException();
3. int hash = spread(key.hashCode());
4. int binCount = 0;
5. for (Node<K,V>[] tab = table;;) {
6. Node<K,V> f; int n, i, fh;
7. if (tab == null || (n = tab.length) == 0)
8. tab = initTable();
9. else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
10. if (casTabAt(tab, i, null,
11. new Node<K,V>(hash, key, value, null)))
12. break;                   // no lock when adding to empty bin
13. }
14. else if ((fh = f.hash) == MOVED)
15. tab = helpTransfer(tab, f);
16. else {
17. V oldVal = null;
18. synchronized (f) {
19. if (tabAt(tab, i) == f) {
20. if (fh >= 0) {
21. binCount = 1;
22. for (Node<K,V> e = f;; ++binCount) {
23. K ek;
24. if (e.hash == hash &&
25. ((ek = e.key) == key ||
26. (ek != null && key.equals(ek)))) {
27. oldVal = e.val;
28. if (!onlyIfAbsent)
29. e.val = value;
30. break;
31. }
32. Node<K,V> pred = e;
33. if ((e = e.next) == null) {
34. pred.next = new Node<K,V>(hash, key,
35. value, null);
36. break;
37. }
38. }
39. }
40. else if (f instanceof TreeBin) {
41. Node<K,V> p;
42. binCount = 2;
43. if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
44. value)) != null) {
45. oldVal = p.val;
46. if (!onlyIfAbsent)
47. p.val = value;
48. }
49. }
50. }
51. }
52. if (binCount != 0) {
53. if (binCount >= TREEIFY_THRESHOLD)
54. treeifyBin(tab, i);
55. if (oldVal != null)
56. return oldVal;
57. break;
58. }
59. }
60. }
61. addCount(1L, binCount);
62. return null;
63. }

1. /**
2. * The array of bins. Lazily initialized upon first insertion.
3. * Size is always a power of two. Accessed directly by iterators.
4. */
5. transient volatile Node<K,V>[] table;

1. public V get(Object key) {
2. Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
3. int h = spread(key.hashCode());
4. if ((tab = table) != null && (n = tab.length) > 0 &&
5. (e = tabAt(tab, (n - 1) & h)) != null) {
6. if ((eh = e.hash) == h) {
7. if ((ek = e.key) == key || (ek != null && key.equals(ek)))
8. return e.val;
9. }
10. else if (eh < 0)
11. return (p = e.find(h, key)) != null ? p.val : null;
12. while ((e = e.next) != null) {
13. if (e.hash == h &&
14. ((ek = e.key) == key || (ek != null && key.equals(ek))))
15. return e.val;
16. }
17. }
18. return null;
19. }

补充：本人的JDK版本为1.7，网上找的大部分资料都介绍ConcurrentHashMap使用了分段锁，但从源码来看这种方法在1.7貌似已经弃用了（put方法不一样了）：

 

HashMap就不说了，一个最常用的Map，前面几个问题都提及了。

LinkedHashMap是HashMap的子类，其类的声明如下：

其与HashMap最大的不同在于内部维护了一个用于遍历的双向链表，遍历的时候能够保持元素插入的顺序：

TreeMap:

Collection：

可以看到Java容器中有Collection和Map两种类型，Collection表示元素的集合，Map表示键值对映射的集合，Map中也包含了Collection（key的集合，value的集合以及键值对的集合），而Collection又可以返回Iterator（迭代器）用于容器的遍历和访问。Collection下又细分为多种特点不同的容器，主要有：

1. 按元素插入顺序存储的List
2. 不允许元素重复的Set
3. 先进先出的Queue
4. 后进先出的Stack

 

除了Collection类以外，可以看到图的右下角还有两个工具类，分别是Collections和Arrays。两个类的构造方法均为private，及不允许新建该类的实例，同时两个类包含了大量的静态方法用于处理我们的存储结构（排序，二分查找，填充等操作）。其中，Collections用于处理Collection容器类的存储结构，而Arrays则用于处理基本类型组成的数组。

 

执行，无论发生啥情况，try后面的finally中的代码块必定会执行，示例：

结果：

 

 

Java中有关于异常类的结构图如下：

在Java中，异常的根类是java.lang.Throwable类，而根类又分为两大类：Error和Exception：

• Error是无法处理的异常，比如OutOfMemoryError，一般发生这种异常，JVM会选择终止程序。因此我们编写程序时不需要关心这类异常。
• Exception，也就是我们经常见到的一些异常情况，比如NullPointerException、IndexOutOfBoundsException，这些异常是我们可以处理的异常。

其中，Exception类又细分为checked exception和unchecked exception（也称RuntimeException运行时异常）
对于unchecked exception（非检查异常），也称运行时异常（RuntimeException），比如常见的NullPointerException、IndexOutOfBoundsException，java编译器不要求必须进行异常捕获处理或者抛出声明，由程序员自行决定。（可以处理，也可以不处理）
对于checked exception（检查异常），也称非运行时异常（运行时异常以外的异常就是非运行时异常），java编译器强制程序员必须进行捕获处理，比如常见的IOExeption和SQLException。对于非运行时异常如果不进行捕获或者抛出声明处理，编译都不会通过。