以上这段官方文档的定义，我们可以抽出成以下几个关键点：

1. /** The value is used for character storage. */
2. private final char value[];

由于String是常量，当我们处理长度变化的String时效率低下，因此官方提供了StringBuffer和StringBuilder两个类。

两个类有共同的父类：AbstractStringBuilder，方法也差不多，底层也是由char数组存储数据的，但是StringBuffer是线程安全的（关键方法都加了synchronized关键字），而StringBuilder不是线程安全的，因此StringBuilder处理字符串的效率比较高。

先上Java容器分类图（虚线框表示抽象类）：

Map即映射表，里面保存的是一组成对的"键值对"对象，一个映射不能包含重复的键，每个键最多只能映射到一个值，我们可以通过"键"找到该键对应的"值"。

常用的Map的方法有：

1. clear：移除Map中的所有元素
2. containsKey：判断Map中是否含有指定的“键”
3. containsValue：判断Map中是否含有指定的“值”
4. entrySet：返回Map中键值对的集合
5. get：通过“键”获取指定的“值”
6. isEmpty：是否为空Map
7. keySet：返回Map中“键”的集合
8. put：加入新的键值对，返回该键的旧值
9. remove：移除指定“键”的键值对，返回该键的值
10. size：Map含有的键值对数目
11. values：返回值的容器视图

常用的Map的实现类有：

1. HashMap：哈希映射表，最常用的Map，使用了hashCode（散列码）优化的Map结构，不保证遍历顺序（例：先存入a后存入b，但遍历时可能先出现b再出现a）
2. LinkedHashMap：HashMap的子类，但内部维护了一个双向链表，保证遍历顺序是插入顺序或基于LRU（最近最少使用）算法
3. WeakHashMap：使用弱引用实现的HashMap，当其中的某些键值对不再被使用时会被自动GC掉
4. HashTable：与HashMap大致上类似，但是是线程安全的
5. IdentityHashMap：使用==代替equals对“键”进行比较的HashMap
6. TreeMap：基于红黑树实现的HashMap，查看“键”或“键值对”时，它们会被排序，另外可以使用subMap方法返回子树

Set：

Set即集合，里面保存的是一堆不可重复的元素，使用equals方法来确保对象的唯一性。

常用的Set的方法有：

1. add：为Set加入新的元素，返回是否加入成功（存在则失败，反之则成功）
2. clear：清除所有元素
3. contains：判断是否含有某元素
4. isEmpty：判断是否为空Set
5. iterator：返回迭代器
6. remove：移除某元素
7. size：Set含有元素的数目

1. HashSet：为快速查找而设计的Set，存入的元素必须定义hashCode
2. LinkedHashSet：具有HashSet的查询速度，且内部有链表维护元素顺序的Set
3. TreeSet：保持排序的Set，底层为树结构

List：

List即列表，与数组类似，按照元素插入的顺序保存元素。

常用的List的方法有：

1. add：在最后或特定位置加入新的元素
2. clear：清除所有元素
3. contains：是否含有指定元素
4. get：获取特定索引元素
5. indexOf：返回特定元素第一次出现的索引，没有则返回-1
6. isEmpty：判断是否为空
7. iterator：返回迭代器
8. lastIndexOf：返回特定元素最后一次出现的索引，没有则返回-1
9. remove：移除特定元素
10. size：返回List大小
11. subList：根据传入的两个索引返回子列表

1. ArrayList：擅长随机访问的列表
2. LinkedList：擅长插入和删除操作的列表
3. Vector：与ArrayList类似，线程安全的列表

常用的Queue的实现类有：

Stack的实现类即Stack。

HashMap和HashTable类声明：

1. public class HashMap<K,V> extends AbstractMap<K,V>
2. implements Map<K,V>, Cloneable, Serializable

1. public class Hashtable<K,V>
2. extends Dictionary<K,V>
3. implements Map<K,V>, Cloneable, java.io.Serializable

1. public V put(K key, V value) {
2. return putVal(hash(key), key, value, false, true);
3. }
4. final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
5. boolean evict) {
6. Node<K,V>[] tab; Node<K,V> p; int n, i;
7. if ((tab = table) == null || (n = tab.length) == 0)
8. n = (tab = resize()).length;
9. if ((p = tab[i = (n - 1) & hash]) == null)
10. tab[i] = newNode(hash, key, value, null);
11. else {
12. Node<K,V> e; K k;
13. if (p.hash == hash &&
14. ((k = p.key) == key || (key != null && key.equals(k))))
15. e = p;
16. else if (p instanceof TreeNode)
17. e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
18. else {
19. for (int binCount = 0; ; ++binCount) {
20. if ((e = p.next) == null) {
21. p.next = newNode(hash, key, value, null);
22. if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
23. treeifyBin(tab, hash);
24. break;
25. }
26. if (e.hash == hash &&
27. ((k = e.key) == key || (key != null && key.equals(k))))
28. break;
29. p = e;
30. }
31. }
32. if (e != null) { // existing mapping for key
33. V oldValue = e.value;
34. if (!onlyIfAbsent || oldValue == null)
35. e.value = value;
36. afterNodeAccess(e);
37. return oldValue;
38. }
39. }
40. ++modCount;
41. if (++size > threshold)
42. resize();
43. afterNodeInsertion(evict);
44. return null;
45. }

1. public synchronized V put(K key, V value) {
2. // Make sure the value is not null
3. if (value == null) {
4. throw new NullPointerException();
5. }
6. // Makes sure the key is not already in the hashtable.
7. Entry<?,?> tab[] = table;
8. int hash = key.hashCode();
9. int index = (hash & 0x7FFFFFFF) % tab.length;
10. @SuppressWarnings("unchecked")
11. Entry<K,V> entry = (Entry<K,V>)tab[index];
12. for(; entry != null ; entry = entry.next) {
13. if ((entry.hash == hash) && entry.key.equals(key)) {
14. V old = entry.value;
15. entry.value = value;
16. return old;
17. }
18. }
19. addEntry(hash, key, value, index);
20. return null;
21. }