附录:集合主题

本附录是一些比第十二章 集合中介绍的更高级的内容。

示例数据

这里创建一些样本数据用于集合示例。 以下数据将颜色名称与HTML颜色的RGB值相关联。请注意，每个键和值都是唯一的：

  1. // onjava/HTMLColors.java
  2. // Sample data for collection examples
  3. package onjava;
  4. import java.util.*;
  5. import java.util.stream.*;
  6. import java.util.concurrent.*;
  8. public class HTMLColors {
  9.   public static final Object[][] ARRAY = {
  10.     { 0xF0F8FF, "AliceBlue" },
  11.     { 0xFAEBD7, "AntiqueWhite" },
  12.     { 0x7FFFD4, "Aquamarine" },
  13.     { 0xF0FFFF, "Azure" },
  14.     { 0xF5F5DC, "Beige" },
  15.     { 0xFFE4C4, "Bisque" },
  16.     { 0x000000, "Black" },
  17.     { 0xFFEBCD, "BlanchedAlmond" },
  18.     { 0x0000FF, "Blue" },
  19.     { 0x8A2BE2, "BlueViolet" },
  20.     { 0xA52A2A, "Brown" },
  21.     { 0xDEB887, "BurlyWood" },
  22.     { 0x5F9EA0, "CadetBlue" },
  23.     { 0x7FFF00, "Chartreuse" },
  24.     { 0xD2691E, "Chocolate" },
  25.     { 0xFF7F50, "Coral" },
  26.     { 0x6495ED, "CornflowerBlue" },
  27.     { 0xFFF8DC, "Cornsilk" },
  28.     { 0xDC143C, "Crimson" },
  29.     { 0x00FFFF, "Cyan" },
  30.     { 0x00008B, "DarkBlue" },
  31.     { 0x008B8B, "DarkCyan" },
  32.     { 0xB8860B, "DarkGoldenRod" },
  33.     { 0xA9A9A9, "DarkGray" },
  34.     { 0x006400, "DarkGreen" },
  35.     { 0xBDB76B, "DarkKhaki" },
  36.     { 0x8B008B, "DarkMagenta" },
  37.     { 0x556B2F, "DarkOliveGreen" },
  38.     { 0xFF8C00, "DarkOrange" },
  39.     { 0x9932CC, "DarkOrchid" },
  40.     { 0x8B0000, "DarkRed" },
  41.     { 0xE9967A, "DarkSalmon" },
  42.     { 0x8FBC8F, "DarkSeaGreen" },
  43.     { 0x483D8B, "DarkSlateBlue" },
  44.     { 0x2F4F4F, "DarkSlateGray" },
  45.     { 0x00CED1, "DarkTurquoise" },
  46.     { 0x9400D3, "DarkViolet" },
  47.     { 0xFF1493, "DeepPink" },
  48.     { 0x00BFFF, "DeepSkyBlue" },
  49.     { 0x696969, "DimGray" },
  50.     { 0x1E90FF, "DodgerBlue" },
  51.     { 0xB22222, "FireBrick" },
  52.     { 0xFFFAF0, "FloralWhite" },
  53.     { 0x228B22, "ForestGreen" },
  54.     { 0xDCDCDC, "Gainsboro" },
  55.     { 0xF8F8FF, "GhostWhite" },
  56.     { 0xFFD700, "Gold" },
  57.     { 0xDAA520, "GoldenRod" },
  58.     { 0x808080, "Gray" },
  59.     { 0x008000, "Green" },
  60.     { 0xADFF2F, "GreenYellow" },
  61.     { 0xF0FFF0, "HoneyDew" },
  62.     { 0xFF69B4, "HotPink" },
  63.     { 0xCD5C5C, "IndianRed" },
  64.     { 0x4B0082, "Indigo" },
  65.     { 0xFFFFF0, "Ivory" },
  66.     { 0xF0E68C, "Khaki" },
  67.     { 0xE6E6FA, "Lavender" },
  68.     { 0xFFF0F5, "LavenderBlush" },
  69.     { 0x7CFC00, "LawnGreen" },
  70.     { 0xFFFACD, "LemonChiffon" },
  71.     { 0xADD8E6, "LightBlue" },
  72.     { 0xF08080, "LightCoral" },
  73.     { 0xE0FFFF, "LightCyan" },
  74.     { 0xFAFAD2, "LightGoldenRodYellow" },
  75.     { 0xD3D3D3, "LightGray" },
  76.     { 0x90EE90, "LightGreen" },
  77.     { 0xFFB6C1, "LightPink" },
  78.     { 0xFFA07A, "LightSalmon" },
  79.     { 0x20B2AA, "LightSeaGreen" },
  80.     { 0x87CEFA, "LightSkyBlue" },
  81.     { 0x778899, "LightSlateGray" },
  82.     { 0xB0C4DE, "LightSteelBlue" },
  83.     { 0xFFFFE0, "LightYellow" },
  84.     { 0x00FF00, "Lime" },
  85.     { 0x32CD32, "LimeGreen" },
  86.     { 0xFAF0E6, "Linen" },
  87.     { 0xFF00FF, "Magenta" },
  88.     { 0x800000, "Maroon" },
  89.     { 0x66CDAA, "MediumAquaMarine" },
  90.     { 0x0000CD, "MediumBlue" },
  91.     { 0xBA55D3, "MediumOrchid" },
  92.     { 0x9370DB, "MediumPurple" },
  93.     { 0x3CB371, "MediumSeaGreen" },
  94.     { 0x7B68EE, "MediumSlateBlue" },
  95.     { 0x00FA9A, "MediumSpringGreen" },
  96.     { 0x48D1CC, "MediumTurquoise" },
  97.     { 0xC71585, "MediumVioletRed" },
  98.     { 0x191970, "MidnightBlue" },
  99.     { 0xF5FFFA, "MintCream" },
  100.     { 0xFFE4E1, "MistyRose" },
  101.     { 0xFFE4B5, "Moccasin" },
  102.     { 0xFFDEAD, "NavajoWhite" },
  103.     { 0x000080, "Navy" },
  104.     { 0xFDF5E6, "OldLace" },
  105.     { 0x808000, "Olive" },
  106.     { 0x6B8E23, "OliveDrab" },
  107.     { 0xFFA500, "Orange" },
  108.     { 0xFF4500, "OrangeRed" },
  109.     { 0xDA70D6, "Orchid" },
  110.     { 0xEEE8AA, "PaleGoldenRod" },
  111.     { 0x98FB98, "PaleGreen" },
  112.     { 0xAFEEEE, "PaleTurquoise" },
  113.     { 0xDB7093, "PaleVioletRed" },
  114.     { 0xFFEFD5, "PapayaWhip" },
  115.     { 0xFFDAB9, "PeachPuff" },
  116.     { 0xCD853F, "Peru" },
  117.     { 0xFFC0CB, "Pink" },
  118.     { 0xDDA0DD, "Plum" },
  119.     { 0xB0E0E6, "PowderBlue" },
  120.     { 0x800080, "Purple" },
  121.     { 0xFF0000, "Red" },
  122.     { 0xBC8F8F, "RosyBrown" },
  123.     { 0x4169E1, "RoyalBlue" },
  124.     { 0x8B4513, "SaddleBrown" },
  125.     { 0xFA8072, "Salmon" },
  126.     { 0xF4A460, "SandyBrown" },
  127.     { 0x2E8B57, "SeaGreen" },
  128.     { 0xFFF5EE, "SeaShell" },
  129.     { 0xA0522D, "Sienna" },
  130.     { 0xC0C0C0, "Silver" },
  131.     { 0x87CEEB, "SkyBlue" },
  132.     { 0x6A5ACD, "SlateBlue" },
  133.     { 0x708090, "SlateGray" },
  134.     { 0xFFFAFA, "Snow" },
  135.     { 0x00FF7F, "SpringGreen" },
  136.     { 0x4682B4, "SteelBlue" },
  137.     { 0xD2B48C, "Tan" },
  138.     { 0x008080, "Teal" },
  139.     { 0xD8BFD8, "Thistle" },
  140.     { 0xFF6347, "Tomato" },
  141.     { 0x40E0D0, "Turquoise" },
  142.     { 0xEE82EE, "Violet" },
  143.     { 0xF5DEB3, "Wheat" },
  144.     { 0xFFFFFF, "White" },
  145.     { 0xF5F5F5, "WhiteSmoke" },
  146.     { 0xFFFF00, "Yellow" },
  147.     { 0x9ACD32, "YellowGreen" },
  148.   };
  149.   public static final Map<Integer,String> MAP =
  150.     Arrays.stream(ARRAY)
  151.       .collect(Collectors.toMap(
  152.         element -> (Integer)element[0],
  153.         element -> (String)element[1],
  154.         (v1, v2) -> { // Merge function
  155.           throw new IllegalStateException();
  156.         },
  157.         LinkedHashMap::new
  158.       ));
  159.   // Inversion only works if values are unique:
  160.   public static <V, K> Map<V, K>
  161.   invert(Map<K, V> map) {
  162.     return map.entrySet().stream()
  163.       .collect(Collectors.toMap(
  164.         Map.Entry::getValue,
  165.         Map.Entry::getKey,
  166.         (v1, v2) -> {
  167.           throw new IllegalStateException();
  168.         },
  169.         LinkedHashMap::new
  170.       ));
  171.   }
  172.   public static final Map<String,Integer>
  173.     INVMAP = invert(MAP);
  174.   // Look up RGB value given a name:
  175.   public static Integer rgb(String colorName) {
  176.     return INVMAP.get(colorName);
  177.   }
  178.   public static final List<String> LIST =
  179.     Arrays.stream(ARRAY)
  180.       .map(item -> (String)item[1])
  181.       .collect(Collectors.toList());
  182.   public static final List<Integer> RGBLIST =
  183.     Arrays.stream(ARRAY)
  184.       .map(item -> (Integer)item[0])
  185.       .collect(Collectors.toList());
  186.   public static
  187.   void show(Map.Entry<Integer,String> e) {
  188.     System.out.format(
  189.       "0x%06X: %s%n", e.getKey(), e.getValue());
  190.   }
  191.   public static void
  192.   show(Map<Integer,String> m, int count) {
  193.     m.entrySet().stream()
  194.       .limit(count)
  195.       .forEach(e -> show(e));
  196.   }
  197.   public static void show(Map<Integer,String> m) {
  198.     show(m, m.size());
  199.   }
  200.   public static
  201.   void show(Collection<String> lst, int count) {
  202.     lst.stream()
  203.       .limit(count)
  204.       .forEach(System.out::println);
  205.   }
  206.   public static void show(Collection<String> lst) {
  207.     show(lst, lst.size());
  208.   }
  209.   public static
  210.   void showrgb(Collection<Integer> lst, int count) {
  211.     lst.stream()
  212.       .limit(count)
  213.       .forEach(n -> System.out.format("0x%06X%n", n));
  214.   }
  215.   public static void showrgb(Collection<Integer> lst) {
  216.     showrgb(lst, lst.size());
  217.   }
  218.   public static
  219.   void showInv(Map<String,Integer> m, int count) {
  220.     m.entrySet().stream()
  221.       .limit(count)
  222.       .forEach(e ->
  223.         System.out.format(
  224.           "%-20s  0x%06X%n", e.getKey(), e.getValue()));
  225.   }
  226.   public static void showInv(Map<String,Integer> m) {
  227.     showInv(m, m.size());
  228.   }
  229.   public static void border() {
  230.     System.out.println(
  231.       "******************************");
  232.   }
  233. }

MAP 是使用Streams（第十四章 流式编程）创建的。 二维数组 ARRAY 作为流传输到 Map 中，但请注意我们不仅仅是使用简单版本的 Collectors.toMap() 。 那个版本生成一个 HashMap ，它使用散列函数来控制对键的排序。 为了保留原来的顺序，我们必须将键值对直接放入 TreeMap 中，这意味着我们需要使用更复杂的 Collectors.toMap() 版本。这需要两个函数从每个流元素中提取键和值，就像简单版本的Collectors.toMap() 一样。 然后它需要一个合并函数（merge function），它解决了与同一个键相关的两个值之间的冲突。这里的数据已经预先审查过，因此绝不会发生这种情况，如果有的话，这里会抛出异常。最后，传递生成所需类型的空map的函数，然后用流来填充它。

rgb() 方法是一个便捷函数（convenience function），它接受颜色名称 String 参数并生成其数字RGB值。为此，我们需要一个反转版本的 COLORS ，它接受一个 String键并查找RGB的 Integer 值。 这是通过 invert() 方法实现的，如果任何 COLORS 值不唯一，则抛出异常。

我们还创建包含所有名称的 LIST ，以及包含十六进制表示法的RGB值的 RGBLIST 。

第一个 show() 方法接受一个 Map.Entry 并显示以十六进制表示的键，以便轻松地对原始 ARRAY 进行双重检查。 名称以 show 开头的每个方法都会重载两个版本，其中一个版本采用 count 参数来指示要显示的元素数量，第二个版本显示序列中的所有元素。

这里是一个基本的测试：

  1. // collectiontopics/HTMLColorTest.java
  2. import static onjava.HTMLColors.*;
  4. public class HTMLColorTest {
  5.   static final int DISPLAY_SIZE = 20;
  6.   public static void main(String[] args) {
  7.     show(MAP, DISPLAY_SIZE);
  8.     border();
  9.     showInv(INVMAP, DISPLAY_SIZE);
  10.     border();
  11.     show(LIST, DISPLAY_SIZE);
  12.     border();
  13.     showrgb(RGBLIST, DISPLAY_SIZE);
  14.   }
  15. }
  16. /* Output:
  17. 0xF0F8FF: AliceBlue
  18. 0xFAEBD7: AntiqueWhite
  19. 0x7FFFD4: Aquamarine
  20. 0xF0FFFF: Azure
  21. 0xF5F5DC: Beige
  22. 0xFFE4C4: Bisque
  23. 0x000000: Black
  24. 0xFFEBCD: BlanchedAlmond
  25. 0x0000FF: Blue
  26. 0x8A2BE2: BlueViolet
  27. 0xA52A2A: Brown
  28. 0xDEB887: BurlyWood
  29. 0x5F9EA0: CadetBlue
  30. 0x7FFF00: Chartreuse
  31. 0xD2691E: Chocolate
  32. 0xFF7F50: Coral
  33. 0x6495ED: CornflowerBlue
  34. 0xFFF8DC: Cornsilk
  35. 0xDC143C: Crimson
  36. 0x00FFFF: Cyan
  37. ******************************
  38. AliceBlue             0xF0F8FF
  39. AntiqueWhite          0xFAEBD7
  40. Aquamarine            0x7FFFD4
  41. Azure                 0xF0FFFF
  42. Beige                 0xF5F5DC
  43. Bisque                0xFFE4C4
  44. Black                 0x000000
  45. BlanchedAlmond        0xFFEBCD
  46. Blue                  0x0000FF
  47. BlueViolet            0x8A2BE2
  48. Brown                 0xA52A2A
  49. BurlyWood             0xDEB887
  50. CadetBlue             0x5F9EA0
  51. Chartreuse            0x7FFF00
  52. Chocolate             0xD2691E
  53. Coral                 0xFF7F50
  54. CornflowerBlue        0x6495ED
  55. Cornsilk              0xFFF8DC
  56. Crimson               0xDC143C
  57. Cyan                  0x00FFFF
  58. ******************************
  59. AliceBlue
  60. AntiqueWhite
  61. Aquamarine
  62. Azure
  63. Beige
  64. Bisque
  65. Black
  66. BlanchedAlmond
  67. Blue
  68. BlueViolet
  69. Brown
  70. BurlyWood
  71. CadetBlue
  72. Chartreuse
  73. Chocolate
  74. Coral
  75. CornflowerBlue
  76. Cornsilk
  77. Crimson
  78. Cyan
  79. ******************************
  80. 0xF0F8FF
  81. 0xFAEBD7
  82. 0x7FFFD4
  83. 0xF0FFFF
  84. 0xF5F5DC
  85. 0xFFE4C4
  86. 0x000000
  87. 0xFFEBCD
  88. 0x0000FF
  89. 0x8A2BE2
  90. 0xA52A2A
  91. 0xDEB887
  92. 0x5F9EA0
  93. 0x7FFF00
  94. 0xD2691E
  95. 0xFF7F50
  96. 0x6495ED
  97. 0xFFF8DC
  98. 0xDC143C
  99. 0x00FFFF
  100. */

可以看到，使用 LinkedHashMap 确实能够保留 HTMLColors.ARRAY 的顺序。

List行为

Lists 是存储和检索对象（次于数组）的最基本方法。基本列表操作包括：

  • add() 用于插入元素
  • get() 用于随机访问元素
  • iterator() 获取序列上的一个 Iterator
  • stream() 生成元素的一个 Stream

列表构造方法始终保留元素的添加顺序。

以下示例中的方法各自涵盖了一组不同的行为：每个 List 可以执行的操作（ basicTest() ），使用 Iterator （ iterMotion() ）遍历序列，使用 Iterator （ iterManipulation() ）更改内容，查看 List 操作（ testVisual() ）的效果，以及仅可用于 LinkedLists 的操作：

  1. // collectiontopics/ListOps.java
  2. // Things you can do with Lists
  3. import java.util.*;
  4. import onjava.HTMLColors;
  6. public class ListOps {
  7.   // Create a short list for testing:
  8.   static final List<String> LIST =
  9.     HTMLColors.LIST.subList(0, 10);
  10.   private static boolean b;
  11.   private static String s;
  12.   private static int i;
  13.   private static Iterator<String> it;
  14.   private static ListIterator<String> lit;
  15.   public static void basicTest(List<String> a) {
  16.     a.add(1, "x"); // Add at location 1
  17.     a.add("x"); // Add at end
  18.     // Add a collection:
  19.     a.addAll(LIST);
  20.     // Add a collection starting at location 3:
  21.     a.addAll(3, LIST);
  22.     b = a.contains("1"); // Is it in there?
  23.     // Is the entire collection in there?
  24.     b = a.containsAll(LIST);
  25.     // Lists allow random access, which is cheap
  26.     // for ArrayList, expensive for LinkedList:
  27.     s = a.get(1); // Get (typed) object at location 1
  28.     i = a.indexOf("1"); // Tell index of object
  29.     b = a.isEmpty(); // Any elements inside?
  30.     it = a.iterator(); // Ordinary Iterator
  31.     lit = a.listIterator(); // ListIterator
  32.     lit = a.listIterator(3); // Start at location 3
  33.     i = a.lastIndexOf("1"); // Last match
  34.     a.remove(1); // Remove location 1
  35.     a.remove("3"); // Remove this object
  36.     a.set(1, "y"); // Set location 1 to "y"
  37.     // Keep everything that's in the argument
  38.     // (the intersection of the two sets):
  39.     a.retainAll(LIST);
  40.     // Remove everything that's in the argument:
  41.     a.removeAll(LIST);
  42.     i = a.size(); // How big is it?
  43.     a.clear(); // Remove all elements
  44.   }
  45.   public static void iterMotion(List<String> a) {
  46.     ListIterator<String> it = a.listIterator();
  47.     b = it.hasNext();
  48.     b = it.hasPrevious();
  49.     s = it.next();
  50.     i = it.nextIndex();
  51.     s = it.previous();
  52.     i = it.previousIndex();
  53.   }
  54.   public static void iterManipulation(List<String> a) {
  55.     ListIterator<String> it = a.listIterator();
  56.     it.add("47");
  57.     // Must move to an element after add():
  58.     it.next();
  59.     // Remove the element after the new one:
  60.     it.remove();
  61.     // Must move to an element after remove():
  62.     it.next();
  63.     // Change the element after the deleted one:
  64.     it.set("47");
  65.   }
  66.   public static void testVisual(List<String> a) {
  67.     System.out.println(a);
  68.     List<String> b = LIST;
  69.     System.out.println("b = " + b);
  70.     a.addAll(b);
  71.     a.addAll(b);
  72.     System.out.println(a);
  73.     // Insert, remove, and replace elements
  74.     // using a ListIterator:
  75.     ListIterator<String> x =
  76.       a.listIterator(a.size()/2);
  77.     x.add("one");
  78.     System.out.println(a);
  79.     System.out.println(x.next());
  80.     x.remove();
  81.     System.out.println(x.next());
  82.     x.set("47");
  83.     System.out.println(a);
  84.     // Traverse the list backwards:
  85.     x = a.listIterator(a.size());
  86.     while(x.hasPrevious())
  87.       System.out.print(x.previous() + " ");
  88.     System.out.println();
  89.     System.out.println("testVisual finished");
  90.   }
  91.   // There are some things that only LinkedLists can do:
  92.   public static void testLinkedList() {
  93.     LinkedList<String> ll = new LinkedList<>();
  94.     ll.addAll(LIST);
  95.     System.out.println(ll);
  96.     // Treat it like a stack, pushing:
  97.     ll.addFirst("one");
  98.     ll.addFirst("two");
  99.     System.out.println(ll);
  100.     // Like "peeking" at the top of a stack:
  101.     System.out.println(ll.getFirst());
  102.     // Like popping a stack:
  103.     System.out.println(ll.removeFirst());
  104.     System.out.println(ll.removeFirst());
  105.     // Treat it like a queue, pulling elements
  106.     // off the tail end:
  107.     System.out.println(ll.removeLast());
  108.     System.out.println(ll);
  109.   }
  110.   public static void main(String[] args) {
  111.     // Make and fill a new list each time:
  112.     basicTest(new LinkedList<>(LIST));
  113.     basicTest(new ArrayList<>(LIST));
  114.     iterMotion(new LinkedList<>(LIST));
  115.     iterMotion(new ArrayList<>(LIST));
  116.     iterManipulation(new LinkedList<>(LIST));
  117.     iterManipulation(new ArrayList<>(LIST));
  118.     testVisual(new LinkedList<>(LIST));
  119.     testLinkedList();
  120.   }
  121. }
  122. /* Output:
  123. [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  124. Bisque, Black, BlanchedAlmond, Blue, BlueViolet]
  125. b = [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  126. Bisque, Black, BlanchedAlmond, Blue, BlueViolet]
  127. [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  128. Bisque, Black, BlanchedAlmond, Blue, BlueViolet,
  129. AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  130. Bisque, Black, BlanchedAlmond, Blue, BlueViolet,
  131. AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  132. Bisque, Black, BlanchedAlmond, Blue, BlueViolet]
  133. [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  134. Bisque, Black, BlanchedAlmond, Blue, BlueViolet,
  135. AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, one,
  136. Bisque, Black, BlanchedAlmond, Blue, BlueViolet,
  137. AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  138. Bisque, Black, BlanchedAlmond, Blue, BlueViolet]
  139. Bisque
  140. Black
  141. [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  142. Bisque, Black, BlanchedAlmond, Blue, BlueViolet,
  143. AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige, one,
  144. 47, BlanchedAlmond, Blue, BlueViolet, AliceBlue,
  145. AntiqueWhite, Aquamarine, Azure, Beige, Bisque, Black,
  146. BlanchedAlmond, Blue, BlueViolet]
  147. BlueViolet Blue BlanchedAlmond Black Bisque Beige Azure
  148. Aquamarine AntiqueWhite AliceBlue BlueViolet Blue
  149. BlanchedAlmond 47 one Beige Azure Aquamarine
  150. AntiqueWhite AliceBlue BlueViolet Blue BlanchedAlmond
  151. Black Bisque Beige Azure Aquamarine AntiqueWhite
  152. AliceBlue
  153. testVisual finished
  154. [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  155. Bisque, Black, BlanchedAlmond, Blue, BlueViolet]
  156. [two, one, AliceBlue, AntiqueWhite, Aquamarine, Azure,
  157. Beige, Bisque, Black, BlanchedAlmond, Blue, BlueViolet]
  158. two
  159. two
  160. one
  161. BlueViolet
  162. [AliceBlue, AntiqueWhite, Aquamarine, Azure, Beige,
  163. Bisque, Black, BlanchedAlmond, Blue]
  164. */

在 basicTest() 和 iterMotion() 中，方法调用是为了展示正确的语法，尽管获取了返回值，但不会使用它。在某些情况下，根本不会去获取返回值。在使用这些方法之前，请查看JDK文档中这些方法的完整用法。

Set行为

Set 的主要用处是测试成员身份，不过也可以将其用作删除重复元素的工具。如果不关心元素顺序或并发性， HashSet 总是最好的选择，因为它是专门为了快速查找而设计的（这里使用了在附录：理解equals和hashCode方法章节中探讨的散列函数）。

其它的 Set 实现产生不同的排序行为：

  1. // collectiontopics/SetOrder.java
  2. import java.util.*;
  3. import onjava.HTMLColors;
  5. public class SetOrder {
  6.   static String[] sets = {
  7.     "java.util.HashSet",
  8.     "java.util.TreeSet",
  9.     "java.util.concurrent.ConcurrentSkipListSet",
  10.     "java.util.LinkedHashSet",
  11.     "java.util.concurrent.CopyOnWriteArraySet",
  12.   };
  13.   static final List<String> RLIST =
  14.     new ArrayList<>(HTMLColors.LIST);
  15.   static {
  16.     Collections.reverse(RLIST);
  17.   }
  18.   public static void
  19.   main(String[] args) throws Exception {
  20.     for(String type: sets) {
  21.       System.out.format("[-> %s <-]%n",
  22.         type.substring(type.lastIndexOf('.') + 1));
  23.       @SuppressWarnings("unchecked")
  24.       Set<String> set = (Set<String>)
  25.         Class.forName(type).newInstance();
  26.       set.addAll(RLIST);
  27.       set.stream()
  28.         .limit(10)
  29.         .forEach(System.out::println);
  30.     }
  31.   }
  32. }
  33. /* Output:
  34. [-> HashSet <-]
  35. MediumOrchid
  36. PaleGoldenRod
  37. Sienna
  38. LightSlateGray
  39. DarkSeaGreen
  40. Black
  41. Gainsboro
  42. Orange
  43. LightCoral
  44. DodgerBlue
  45. [-> TreeSet <-]
  46. AliceBlue
  47. AntiqueWhite
  48. Aquamarine
  49. Azure
  50. Beige
  51. Bisque
  52. Black
  53. BlanchedAlmond
  54. Blue
  55. BlueViolet
  56. [-> ConcurrentSkipListSet <-]
  57. AliceBlue
  58. AntiqueWhite
  59. Aquamarine
  60. Azure
  61. Beige
  62. Bisque
  63. Black
  64. BlanchedAlmond
  65. Blue
  66. BlueViolet
  67. [-> LinkedHashSet <-]
  68. YellowGreen
  69. Yellow
  70. WhiteSmoke
  71. White
  72. Wheat
  73. Violet
  74. Turquoise
  75. Tomato
  76. Thistle
  77. Teal
  78. [-> CopyOnWriteArraySet <-]
  79. YellowGreen
  80. Yellow
  81. WhiteSmoke
  82. White
  83. Wheat
  84. Violet
  85. Turquoise
  86. Tomato
  87. Thistle
  88. Teal
  89. */

这里需要使用 @SuppressWarnings(“unchecked”) ，因为这里将一个 String （可能是任何东西）传递给了 Class.forName(type).newInstance() 。编译器并不能保证这是一次成功的操作。

RLIST 是 HTMLColors.LIST 的反转版本。因为 Collections.reverse() 是通过修改参数来执行反向操作，而不是返回包含反向元素的新 List ，所以该调用在 static 块内执行。 RLIST 可以防止我们意外地认为 Set 对其结果进行了排序。

HashSet 的输出结果似乎没有可辨别的顺序，因为它是基于散列函数的。 TreeSet 和 ConcurrentSkipListSet 都对它们的元素进行了排序，它们都实现了 SortedSet 接口来标识这个特点。因为实现该接口的 Set 按顺序排列，所以该接口还有一些其他的可用操作。 LinkedHashSet 和 CopyOnWriteArraySet 尽管没有用于标识的接口，但它们还是保留了元素的插入顺序。

ConcurrentSkipListSet 和 CopyOnWriteArraySet 是线程安全的。

在附录的最后，我们将了解在非 HashSet 实现的 Set 上添加额外排序的性能成本，以及不同实现中的任何其他功能的成本。

在Map中使用函数式操作

与 Collection 接口一样，forEach() 也内置在 Map 接口中。但是如果想要执行任何其他的基本功能操作，比如 map() ，flatMap() ，reduce() 或 filter() 时，该怎么办？ 查看 Map 接口发现并没有这些。

可以通过 entrySet() 连接到这些方法，该方法会生成一个由 Map.Entry 对象组成的 Set 。这个 Set 包含 stream() 和 parallelStream() 方法。只需要记住一件事，这里正在使用的是 Map.Entry 对象：

  1. // collectiontopics/FunctionalMap.java
  2. // Functional operations on a Map
  3. import java.util.*;
  4. import java.util.stream.*;
  5. import java.util.concurrent.*;
  6. import static onjava.HTMLColors.*;
  8. public class FunctionalMap {
  9.   public static void main(String[] args) {
  10.     MAP.entrySet().stream()
  11.       .map(Map.Entry::getValue)
  12.       .filter(v -> v.startsWith("Dark"))
  13.       .map(v -> v.replaceFirst("Dark", "Hot"))
  14.       .forEach(System.out::println);
  15.   }
  16. }
  17. /* Output:
  18. HotBlue
  19. HotCyan
  20. HotGoldenRod
  21. HotGray
  22. HotGreen
  23. HotKhaki
  24. HotMagenta
  25. HotOliveGreen
  26. HotOrange
  27. HotOrchid
  28. HotRed
  29. HotSalmon
  30. HotSeaGreen
  31. HotSlateBlue
  32. HotSlateGray
  33. HotTurquoise
  34. HotViolet
  35. */

生成 Stream 后，所有的基本功能方法，甚至更多就都可以使用了。

选择Map片段

由 TreeMap 和 ConcurrentSkipListMap 实现的 NavigableMap 接口解决了需要选择Map片段的问题。下面是一个示例，使用了 HTMLColors ：

  1. // collectiontopics/NavMap.java
  2. // NavigableMap produces pieces of a Map
  3. import java.util.*;
  4. import java.util.concurrent.*;
  5. import static onjava.HTMLColors.*;
  7. public class NavMap {
  8.   public static final
  9.   NavigableMap<Integer,String> COLORS =
  10.     new ConcurrentSkipListMap<>(MAP);
  11.   public static void main(String[] args) {
  12.     show(COLORS.firstEntry());
  13.     border();
  14.     show(COLORS.lastEntry());
  15.     border();
  16.     NavigableMap<Integer, String> toLime =
  17.       COLORS.headMap(rgb("Lime"), true);
  18.     show(toLime);
  19.     border();
  20.     show(COLORS.ceilingEntry(rgb("DeepSkyBlue") - 1));
  21.     border();
  22.     show(COLORS.floorEntry(rgb("DeepSkyBlue") - 1));
  23.     border();
  24.     show(toLime.descendingMap());
  25.     border();
  26.     show(COLORS.tailMap(rgb("MistyRose"), true));
  27.     border();
  28.     show(COLORS.subMap(
  29.       rgb("Orchid"), true,
  30.       rgb("DarkSalmon"), false));
  31.   }
  32. }
  33. /* Output:
  34. 0x000000: Black
  35. ******************************
  36. 0xFFFFFF: White
  37. ******************************
  38. 0x000000: Black
  39. 0x000080: Navy
  40. 0x00008B: DarkBlue
  41. 0x0000CD: MediumBlue
  42. 0x0000FF: Blue
  43. 0x006400: DarkGreen
  44. 0x008000: Green
  45. 0x008080: Teal
  46. 0x008B8B: DarkCyan
  47. 0x00BFFF: DeepSkyBlue
  48. 0x00CED1: DarkTurquoise
  49. 0x00FA9A: MediumSpringGreen
  50. 0x00FF00: Lime
  51. ******************************
  52. 0x00BFFF: DeepSkyBlue
  53. ******************************
  54. 0x008B8B: DarkCyan
  55. ******************************
  56. 0x00FF00: Lime
  57. 0x00FA9A: MediumSpringGreen
  58. 0x00CED1: DarkTurquoise
  59. 0x00BFFF: DeepSkyBlue
  60. 0x008B8B: DarkCyan
  61. 0x008080: Teal
  62. 0x008000: Green
  63. 0x006400: DarkGreen
  64. 0x0000FF: Blue
  65. 0x0000CD: MediumBlue
  66. 0x00008B: DarkBlue
  67. 0x000080: Navy
  68. 0x000000: Black
  69. ******************************
  70. 0xFFE4E1: MistyRose
  71. 0xFFEBCD: BlanchedAlmond
  72. 0xFFEFD5: PapayaWhip
  73. 0xFFF0F5: LavenderBlush
  74. 0xFFF5EE: SeaShell
  75. 0xFFF8DC: Cornsilk
  76. 0xFFFACD: LemonChiffon
  77. 0xFFFAF0: FloralWhite
  78. 0xFFFAFA: Snow
  79. 0xFFFF00: Yellow
  80. 0xFFFFE0: LightYellow
  81. 0xFFFFF0: Ivory
  82. 0xFFFFFF: White
  83. ******************************
  84. 0xDA70D6: Orchid
  85. 0xDAA520: GoldenRod
  86. 0xDB7093: PaleVioletRed
  87. 0xDC143C: Crimson
  88. 0xDCDCDC: Gainsboro
  89. 0xDDA0DD: Plum
  90. 0xDEB887: BurlyWood
  91. 0xE0FFFF: LightCyan
  92. 0xE6E6FA: Lavender
  93. */

在主方法中可以看到 NavigableMap 的各种功能。 因为 NavigableMap 具有键顺序，所以它使用了 firstEntry() 和 lastEntry() 的概念。调用 headMap() 会生成一个 NavigableMap ，其中包含了从 Map 的开头到 headMap() 参数中所指向的一组元素，其中 boolean 值指示结果中是否包含该参数。调用 tailMap() 执行了类似的操作，只不过是从参数开始到 Map 的末尾。 subMap() 则允许生成 Map 中间的一部分。

ceilingEntry() 从当前键值对向上搜索下一个键值对，floorEntry() 则是向下搜索。 descendingMap() 反转了 NavigableMap 的顺序。

如果需要通过分割 Map 来简化所正在解决的问题，则 NavigableMap 可以做到。具有类似的功能的其它集合实现也可以用来帮助解决问题。

填充集合

与 Arrays 一样，这里有一个名为 Collections 的伴随类（companion class），包含了一些 static 的实用方法，其中包括一个名为 fill() 的方法。 fill() 只复制整个集合中的单个对象引用。此外，它仅适用于 List 对象，但结果列表可以传递给构造方法或 addAll() 方法：

  1. // collectiontopics/FillingLists.java
  2. // Collections.fill() & Collections.nCopies()
  3. import java.util.*;
  5. class StringAddress {
  6.   private String s;
  7.   StringAddress(String s) { this.s = s; }
  8.   @Override
  9.   public String toString() {
  10.     return super.toString() + " " + s;
  11.   }
  12. }
  14. public class FillingLists {
  15.   public static void main(String[] args) {
  16.     List<StringAddress> list = new ArrayList<>(
  17.       Collections.nCopies(4,
  18.         new StringAddress("Hello")));
  19.     System.out.println(list);
  20.     Collections.fill(list,
  21.       new StringAddress("World!"));
  22.     System.out.println(list);
  23.   }
  24. }
  25. /* Output:
  26. [StringAddress@15db9742 Hello, StringAddress@15db9742
  27. Hello, StringAddress@15db9742 Hello,
  28. StringAddress@15db9742 Hello]
  29. [StringAddress@6d06d69c World!, StringAddress@6d06d69c
  30. World!, StringAddress@6d06d69c World!,
  31. StringAddress@6d06d69c World!]
  32. */

这个示例展示了两种使用对单个对象的引用来填充 Collection 的方法。 第一个： Collections.nCopies() ，创建一个 List，并传递给 ArrayList 的构造方法，进而填充了 ArrayList 。

StringAddress 中的 toString() 方法调用了 Object.toString() ，它先生成类名，后跟着对象的哈希码的无符号十六进制表示（哈希吗由 hashCode() 方法生成）。 输出显示所有的引用都指向同一个对象。调用第二个方法 Collections.fill() 后也是如此。 fill() 方法的用处非常有限，它只能替换 List 中已有的元素,而且不会添加新元素，

使用 Suppliers 填充集合

第二十章 泛型章节中介绍的 onjava.Suppliers 类为填充集合提供了通用解决方案。 这是一个使用 Suppliers 初始化几种不同类型的 Collection 的示例：

  1. // collectiontopics/SuppliersCollectionTest.java
  2. import java.util.*;
  3. import java.util.function.*;
  4. import java.util.stream.*;
  5. import onjava.*;
  7. class Government implements Supplier<String> {
  8.   static String[] foundation = (
  9.     "strange women lying in ponds " +
  10.     "distributing swords is no basis " +
  11.     "for a system of government").split(" ");
  12.   private int index;
  13.   @Override
  14.   public String get() {
  15.     return foundation[index++];
  16.   }
  17. }
  19. public class SuppliersCollectionTest {
  20.   public static void main(String[] args) {
  21.     // Suppliers class from the Generics chapter:
  22.     Set<String> set = Suppliers.create(
  23.       LinkedHashSet::new, new Government(), 15);
  24.     System.out.println(set);
  25.     List<String> list = Suppliers.create(
  26.       LinkedList::new, new Government(), 15);
  27.     System.out.println(list);
  28.     list = new ArrayList<>();
  29.     Suppliers.fill(list, new Government(), 15);
  30.     System.out.println(list);
  32.     // Or we can use Streams:
  33.     set = Arrays.stream(Government.foundation)
  34.       .collect(Collectors.toSet());
  35.     System.out.println(set);
  36.     list = Arrays.stream(Government.foundation)
  37.       .collect(Collectors.toList());
  38.     System.out.println(list);
  39.     list = Arrays.stream(Government.foundation)
  40.       .collect(Collectors
  41.         .toCollection(LinkedList::new));
  42.     System.out.println(list);
  43.     set = Arrays.stream(Government.foundation)
  44.       .collect(Collectors
  45.         .toCollection(LinkedHashSet::new));
  46.     System.out.println(set);
  47.   }
  48. }
  49. /* Output:
  50. [strange, women, lying, in, ponds, distributing,
  51. swords, is, no, basis, for, a, system, of, government]
  52. [strange, women, lying, in, ponds, distributing,
  53. swords, is, no, basis, for, a, system, of, government]
  54. [strange, women, lying, in, ponds, distributing,
  55. swords, is, no, basis, for, a, system, of, government]
  56. [ponds, no, a, in, swords, for, is, basis, strange,
  57. system, government, distributing, of, women, lying]
  58. [strange, women, lying, in, ponds, distributing,
  59. swords, is, no, basis, for, a, system, of, government]
  60. [strange, women, lying, in, ponds, distributing,
  61. swords, is, no, basis, for, a, system, of, government]
  62. [strange, women, lying, in, ponds, distributing,
  63. swords, is, no, basis, for, a, system, of, government]
  64. */

LinkedHashSet 中的的元素按插入顺序排列，因为它维护一个链表来保存该顺序。

但是请注意示例的第二部分：大多数情况下都可以使用 Stream 来创建和填充 Collection 。在本例中的 Stream 版本不需要声明 Supplier 所想要创建的元素数量;，它直接吸收了 Stream 中的所有元素。

尽可能优先选择 Stream 来解决问题。

Map Suppliers

使用 Supplier 来填充 Map 时需要一个 Pair 类，因为每次调用一个 Supplier 的 get() 方法时，都必须生成一对对象（一个键和一个值）：

  1. // onjava/Pair.java
  2. package onjava;
  4. public class Pair<K, V> {
  5.   public final K key;
  6.   public final V value;
  7.   public Pair(K k, V v) {
  8.     key = k;
  9.     value = v;
  10.   }
  11.   public K key() { return key; }
  12.   public V value() { return value; }
  13.   public static <K,V> Pair<K, V> make(K k, V v) {
  14.     return new Pair<K,V>(k, v);
  15.   }
  16. }

Pair 是一个只读的 数据传输对象 （Data Transfer Object）或 信使 （Messenger）。 这与第二十章 泛型章节中的 Tuple2 基本相同，但名字更适合 Map 初始化。我还添加了静态的 make() 方法，以便为创建 Pair 对象提供一个更简洁的名字。

Java 8 的 Stream 提供了填充 Map 的便捷方法：

  1. // collectiontopics/StreamFillMaps.java
  2. import java.util.*;
  3. import java.util.function.*;
  4. import java.util.stream.*;
  5. import onjava.*;
  7. class Letters
  8. implements Supplier<Pair<Integer,String>> {
  9.   private int number = 1;
  10.   private char letter = 'A';
  11.   @Override
  12.   public Pair<Integer,String> get() {
  13.     return new Pair<>(number++, "" + letter++);
  14.   }
  15. }
  17. public class StreamFillMaps {
  18.   public static void main(String[] args) {
  19.     Map<Integer,String> m =
  20.       Stream.generate(new Letters())
  21.       .limit(11)
  22.       .collect(Collectors
  23.         .toMap(Pair::key, Pair::value));
  24.     System.out.println(m);
  26.     // Two separate Suppliers:
  27.     Rand.String rs = new Rand.String(3);
  28.     Count.Character cc = new Count.Character();
  29.     Map<Character,String> mcs = Stream.generate(
  30.       () -> Pair.make(cc.get(), rs.get()))
  31.       .limit(8)
  32.       .collect(Collectors
  33.         .toMap(Pair::key, Pair::value));
  34.     System.out.println(mcs);
  36.     // A key Supplier and a single value:
  37.     Map<Character,String> mcs2 = Stream.generate(
  38.       () -> Pair.make(cc.get(), "Val"))
  39.       .limit(8)
  40.       .collect(Collectors
  41.         .toMap(Pair::key, Pair::value));
  42.     System.out.println(mcs2);
  43.   }
  44. }
  45. /* Output:
  46. {1=A, 2=B, 3=C, 4=D, 5=E, 6=F, 7=G, 8=H, 9=I, 10=J,
  47. 11=K}
  48. {b=btp, c=enp, d=ccu, e=xsz, f=gvg, g=mei, h=nne,
  49. i=elo}
  50. {p=Val, q=Val, j=Val, k=Val, l=Val, m=Val, n=Val,
  51. o=Val}
  52. */

上面的示例中出现了一个模式，可以使用它来创建一个自动创建和填充 Map 的工具：

  1. // onjava/FillMap.java
  2. package onjava;
  3. import java.util.*;
  4. import java.util.function.*;
  5. import java.util.stream.*;
  7. public class FillMap {
  8.   public static <K, V> Map<K,V>
  9.   basic(Supplier<Pair<K,V>> pairGen, int size) {
  10.     return Stream.generate(pairGen)
  11.       .limit(size)
  12.       .collect(Collectors
  13.         .toMap(Pair::key, Pair::value));
  14.   }
  15.   public static <K, V> Map<K,V>
  16.   basic(Supplier<K> keyGen,
  17.         Supplier<V> valueGen, int size) {
  18.     return Stream.generate(
  19.       () -> Pair.make(keyGen.get(), valueGen.get()))
  20.       .limit(size)
  21.       .collect(Collectors
  22.         .toMap(Pair::key, Pair::value));
  23.   }
  24.   public static <K, V, M extends Map<K,V>>
  25.   M create(Supplier<K> keyGen,
  26.            Supplier<V> valueGen,
  27.            Supplier<M> mapSupplier, int size) {
  28.     return Stream.generate( () ->
  29.       Pair.make(keyGen.get(), valueGen.get()))
  30.         .limit(size)
  31.         .collect(Collectors
  32.           .toMap(Pair::key, Pair::value,
  33.                  (k, v) -> k, mapSupplier));
  34.   }
  35. }

basic() 方法生成一个默认的 Map ，而 create() 方法允许指定一个确切的 Map 类型，并返回那个确切的类型。

下面是一个测试：

  1. // collectiontopics/FillMapTest.java
  2. import java.util.*;
  3. import java.util.function.*;
  4. import java.util.stream.*;
  5. import onjava.*;
  7. public class FillMapTest {
  8.   public static void main(String[] args) {
  9.     Map<String,Integer> mcs = FillMap.basic(
  10.       new Rand.String(4), new Count.Integer(), 7);
  11.     System.out.println(mcs);
  12.     HashMap<String,Integer> hashm =
  13.       FillMap.create(new Rand.String(4),
  14.         new Count.Integer(), HashMap::new, 7);
  15.     System.out.println(hashm);
  16.     LinkedHashMap<String,Integer> linkm =
  17.       FillMap.create(new Rand.String(4),
  18.         new Count.Integer(), LinkedHashMap::new, 7);
  19.     System.out.println(linkm);
  20.   }
  21. }
  22. /* Output:
  23. {npcc=1, ztdv=6, gvgm=3, btpe=0, einn=4, eelo=5,
  24. uxsz=2}
  25. {npcc=1, ztdv=6, gvgm=3, btpe=0, einn=4, eelo=5,
  26. uxsz=2}
  27. {btpe=0, npcc=1, uxsz=2, gvgm=3, einn=4, eelo=5,
  28. ztdv=6}
  29. */

使用享元（Flyweight）自定义Collection和Map

本节介绍如何创建自定义 Collection 和 Map 实现。每个 java.util 中的集合都有自己的 Abstract 类，它提供了该集合的部分实现，因此只需要实现必要的方法来生成所需的集合。你将看到通过继承 java.util.Abstract 类来创建自定义 Map 和 Collection 是多么简单。例如，要创建一个只读的 Set ，则可以从 AbstractSet 继承并实现 iterator() 和 size() 。最后一个示例是生成测试数据的另一种方法。生成的集合通常是只读的，并且所提供的方法最少。

该解决方案还演示了 享元 （Flyweight）设计模式。当普通解决方案需要太多对象时，或者当生成普通对象占用太多空间时，可以使用享元。享元设计模式将对象的一部分外部化（externalizes）。相比于把对象的所有内容都包含在对象中，这样做使得对象的部分或者全部可以在更有效的外部表中查找，或通过一些节省空间的其他计算生成。

下面是一个可以是任何大小的 List ，并且（有效地）使用 Integer 数据进行预初始化。要从 AbstractList 创建只读 List ，必须实现 get() 和 size()：

  1. // onjava/CountingIntegerList.java
  2. // List of any length, containing sample data
  3. // {java onjava.CountingIntegerList}
  4. package onjava;
  5. import java.util.*;
  7. public class CountingIntegerList
  8. extends AbstractList<Integer> {
  9.   private int size;
  10.   public CountingIntegerList() { size = 0; }
  11.   public CountingIntegerList(int size) {
  12.     this.size = size < 0 ? 0 : size;
  13.   }
  14.   @Override
  15.   public Integer get(int index) {
  16.     return index;
  17.   }
  18.   @Override
  19.   public int size() { return size; }
  20.   public static void main(String[] args) {
  21.     List<Integer> cil =
  22.       new CountingIntegerList(30);
  23.     System.out.println(cil);
  24.     System.out.println(cil.get(500));
  25.   }
  26. }
  27. /* Output:
  28. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
  29. 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
  30. 500
  31. */

只有当想要限制 List 的长度时， size 值才是重要的，就像在主方法中那样。即使在这种情况下， get() 也会产生任何值。

这个类是享元模式的一个简洁的例子。当需要的时候， get() “计算”所需的值，因此没必要存储和初始化实际的底层 List 结构。

在大多数程序中，这里所保存的存储结构永远都不会改变。但是，它允许用非常大的 index 来调用 List.get() ，而 List 并不需要填充到这么大。此外，还可以在程序中大量使用 CountingIntegerLists 而无需担心存储问题。实际上，享元的一个好处是它允许使用更好的抽象而不用担心资源。

可以使用享元设计模式来实现具有任何大小数据集的其他“初始化”自定义集合。下面是一个 Map ，它为每一个 Integer 键产生唯一的值：

  1. // onjava/CountMap.java
  2. // Unlimited-length Map containing sample data
  3. // {java onjava.CountMap}
  4. package onjava;
  5. import java.util.*;
  6. import java.util.stream.*;
  8. public class CountMap
  9. extends AbstractMap<Integer,String> {
  10.   private int size;
  11.   private static char[] chars =
  12.     "ABCDEFGHIJKLMNOPQRSTUVWXYZ".toCharArray();
  13.   private static String value(int key) {
  14.     return
  15.       chars[key % chars.length] +
  16.       Integer.toString(key / chars.length);
  17.   }
  18.   public CountMap(int size) {
  19.     this.size = size < 0 ? 0 : size;
  20.   }
  21.   @Override
  22.   public String get(Object key) {
  23.     return value((Integer)key);
  24.   }
  25.   private static class Entry
  26.   implements Map.Entry<Integer,String> {
  27.     int index;
  28.     Entry(int index) { this.index = index; }
  29.     @Override
  30.     public boolean equals(Object o) {
  31.       return o instanceof Entry &&
  32.         Objects.equals(index, ((Entry)o).index);
  33.     }
  34.     @Override
  35.     public Integer getKey() { return index; }
  36.     @Override
  37.     public String getValue() {
  38.       return value(index);
  39.     }
  40.     @Override
  41.     public String setValue(String value) {
  42.       throw new UnsupportedOperationException();
  43.     }
  44.     @Override
  45.     public int hashCode() {
  46.       return Objects.hashCode(index);
  47.     }
  48.   }
  49.   @Override
  50.   public Set<Map.Entry<Integer,String>> entrySet() {
  51.     // LinkedHashSet retains initialization order:
  52.     return IntStream.range(0, size)
  53.       .mapToObj(Entry::new)
  54.       .collect(Collectors
  55.         .toCollection(LinkedHashSet::new));
  56.   }
  57.   public static void main(String[] args) {
  58.     final int size = 6;
  59.     CountMap cm = new CountMap(60);
  60.     System.out.println(cm);
  61.     System.out.println(cm.get(500));
  62.     cm.values().stream()
  63.       .limit(size)
  64.       .forEach(System.out::println);
  65.     System.out.println();
  66.     new Random(47).ints(size, 0, 1000)
  67.       .mapToObj(cm::get)
  68.       .forEach(System.out::println);
  69.   }
  70. }
  71. /* Output:
  72. {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0,
  73. 9=J0, 10=K0, 11=L0, 12=M0, 13=N0, 14=O0, 15=P0, 16=Q0,
  74. 17=R0, 18=S0, 19=T0, 20=U0, 21=V0, 22=W0, 23=X0, 24=Y0,
  75. 25=Z0, 26=A1, 27=B1, 28=C1, 29=D1, 30=E1, 31=F1, 32=G1,
  76. 33=H1, 34=I1, 35=J1, 36=K1, 37=L1, 38=M1, 39=N1, 40=O1,
  77. 41=P1, 42=Q1, 43=R1, 44=S1, 45=T1, 46=U1, 47=V1, 48=W1,
  78. 49=X1, 50=Y1, 51=Z1, 52=A2, 53=B2, 54=C2, 55=D2, 56=E2,
  79. 57=F2, 58=G2, 59=H2}
  80. G19
  81. A0
  82. B0
  83. C0
  84. D0
  85. E0
  86. F0
  88. Y9
  89. J21
  90. R26
  91. D33
  92. Z36
  93. N16
  94. */

要创建一个只读的 Map ，则从 AbstractMap 继承并实现 entrySet() 。私有的 value() 方法计算任何键的值，并在 get() 和 Entry.getValue() 中使用。可以忽略 CountMap 的大小。

这里是使用了 LinkedHashSet 而不是创建自定义 Set 类，因此并未完全实现享元。只有在调用 entrySet() 时才会生成此对象。

现在创建一个更复杂的享元。这个示例中的数据集是世界各国及其首都的 Map 。 capitals() 方法生成一个国家和首都的 Map 。 names() 方法生成一个由国家名字组成的 List 。 当给定了表示所需大小的 int 参数时，两种方法都生成对应大小的列表片段：

  1. // onjava/Countries.java
  2. // "Flyweight" Maps and Lists of sample data
  3. // {java onjava.Countries}
  4. package onjava;
  5. import java.util.*;
  7. public class Countries {
  8.   public static final String[][] DATA = {
  9.     // Africa
  10.     {"ALGERIA","Algiers"},
  11.     {"ANGOLA","Luanda"},
  12.     {"BENIN","Porto-Novo"},
  13.     {"BOTSWANA","Gaberone"},
  14.     {"BURKINA FASO","Ouagadougou"},
  15.     {"BURUNDI","Bujumbura"},
  16.     {"CAMEROON","Yaounde"},
  17.     {"CAPE VERDE","Praia"},
  18.     {"CENTRAL AFRICAN REPUBLIC","Bangui"},
  19.     {"CHAD","N'djamena"},
  20.     {"COMOROS","Moroni"},
  21.     {"CONGO","Brazzaville"},
  22.     {"DJIBOUTI","Dijibouti"},
  23.     {"EGYPT","Cairo"},
  24.     {"EQUATORIAL GUINEA","Malabo"},
  25.     {"ERITREA","Asmara"},
  26.     {"ETHIOPIA","Addis Ababa"},
  27.     {"GABON","Libreville"},
  28.     {"THE GAMBIA","Banjul"},
  29.     {"GHANA","Accra"},
  30.     {"GUINEA","Conakry"},
  31.     {"BISSAU","Bissau"},
  32.     {"COTE D'IVOIR (IVORY COAST)","Yamoussoukro"},
  33.     {"KENYA","Nairobi"},
  34.     {"LESOTHO","Maseru"},
  35.     {"LIBERIA","Monrovia"},
  36.     {"LIBYA","Tripoli"},
  37.     {"MADAGASCAR","Antananarivo"},
  38.     {"MALAWI","Lilongwe"},
  39.     {"MALI","Bamako"},
  40.     {"MAURITANIA","Nouakchott"},
  41.     {"MAURITIUS","Port Louis"},
  42.     {"MOROCCO","Rabat"},
  43.     {"MOZAMBIQUE","Maputo"},
  44.     {"NAMIBIA","Windhoek"},
  45.     {"NIGER","Niamey"},
  46.     {"NIGERIA","Abuja"},
  47.     {"RWANDA","Kigali"},
  48.     {"SAO TOME E PRINCIPE","Sao Tome"},
  49.     {"SENEGAL","Dakar"},
  50.     {"SEYCHELLES","Victoria"},
  51.     {"SIERRA LEONE","Freetown"},
  52.     {"SOMALIA","Mogadishu"},
  53.     {"SOUTH AFRICA","Pretoria/Cape Town"},
  54.     {"SUDAN","Khartoum"},
  55.     {"SWAZILAND","Mbabane"},
  56.     {"TANZANIA","Dodoma"},
  57.     {"TOGO","Lome"},
  58.     {"TUNISIA","Tunis"},
  59.     {"UGANDA","Kampala"},
  60.     {"DEMOCRATIC REPUBLIC OF THE CONGO (ZAIRE)",
  61.      "Kinshasa"},
  62.     {"ZAMBIA","Lusaka"},
  63.     {"ZIMBABWE","Harare"},
  64.     // Asia
  65.     {"AFGHANISTAN","Kabul"},
  66.     {"BAHRAIN","Manama"},
  67.     {"BANGLADESH","Dhaka"},
  68.     {"BHUTAN","Thimphu"},
  69.     {"BRUNEI","Bandar Seri Begawan"},
  70.     {"CAMBODIA","Phnom Penh"},
  71.     {"CHINA","Beijing"},
  72.     {"CYPRUS","Nicosia"},
  73.     {"INDIA","New Delhi"},
  74.     {"INDONESIA","Jakarta"},
  75.     {"IRAN","Tehran"},
  76.     {"IRAQ","Baghdad"},
  77.     {"ISRAEL","Jerusalem"},
  78.     {"JAPAN","Tokyo"},
  79.     {"JORDAN","Amman"},
  80.     {"KUWAIT","Kuwait City"},
  81.     {"LAOS","Vientiane"},
  82.     {"LEBANON","Beirut"},
  83.     {"MALAYSIA","Kuala Lumpur"},
  84.     {"THE MALDIVES","Male"},
  85.     {"MONGOLIA","Ulan Bator"},
  86.     {"MYANMAR (BURMA)","Rangoon"},
  87.     {"NEPAL","Katmandu"},
  88.     {"NORTH KOREA","P'yongyang"},
  89.     {"OMAN","Muscat"},
  90.     {"PAKISTAN","Islamabad"},
  91.     {"PHILIPPINES","Manila"},
  92.     {"QATAR","Doha"},
  93.     {"SAUDI ARABIA","Riyadh"},
  94.     {"SINGAPORE","Singapore"},
  95.     {"SOUTH KOREA","Seoul"},
  96.     {"SRI LANKA","Colombo"},
  97.     {"SYRIA","Damascus"},
  98.     {"TAIWAN (REPUBLIC OF CHINA)","Taipei"},
  99.     {"THAILAND","Bangkok"},
  100.     {"TURKEY","Ankara"},
  101.     {"UNITED ARAB EMIRATES","Abu Dhabi"},
  102.     {"VIETNAM","Hanoi"},
  103.     {"YEMEN","Sana'a"},
  104.     // Australia and Oceania
  105.     {"AUSTRALIA","Canberra"},
  106.     {"FIJI","Suva"},
  107.     {"KIRIBATI","Bairiki"},
  108.     {"MARSHALL ISLANDS","Dalap-Uliga-Darrit"},
  109.     {"MICRONESIA","Palikir"},
  110.     {"NAURU","Yaren"},
  111.     {"NEW ZEALAND","Wellington"},
  112.     {"PALAU","Koror"},
  113.     {"PAPUA NEW GUINEA","Port Moresby"},
  114.     {"SOLOMON ISLANDS","Honaira"},
  115.     {"TONGA","Nuku'alofa"},
  116.     {"TUVALU","Fongafale"},
  117.     {"VANUATU","Port Vila"},
  118.     {"WESTERN SAMOA","Apia"},
  119.     // Eastern Europe and former USSR
  120.     {"ARMENIA","Yerevan"},
  121.     {"AZERBAIJAN","Baku"},
  122.     {"BELARUS (BYELORUSSIA)","Minsk"},
  123.     {"BULGARIA","Sofia"},
  124.     {"GEORGIA","Tbilisi"},
  125.     {"KAZAKSTAN","Almaty"},
  126.     {"KYRGYZSTAN","Alma-Ata"},
  127.     {"MOLDOVA","Chisinau"},
  128.     {"RUSSIA","Moscow"},
  129.     {"TAJIKISTAN","Dushanbe"},
  130.     {"TURKMENISTAN","Ashkabad"},
  131.     {"UKRAINE","Kyiv"},
  132.     {"UZBEKISTAN","Tashkent"},
  133.     // Europe
  134.     {"ALBANIA","Tirana"},
  135.     {"ANDORRA","Andorra la Vella"},
  136.     {"AUSTRIA","Vienna"},
  137.     {"BELGIUM","Brussels"},
  138.     {"BOSNIA-HERZEGOVINA","Sarajevo"},
  139.     {"CROATIA","Zagreb"},
  140.     {"CZECH REPUBLIC","Prague"},
  141.     {"DENMARK","Copenhagen"},
  142.     {"ESTONIA","Tallinn"},
  143.     {"FINLAND","Helsinki"},
  144.     {"FRANCE","Paris"},
  145.     {"GERMANY","Berlin"},
  146.     {"GREECE","Athens"},
  147.     {"HUNGARY","Budapest"},
  148.     {"ICELAND","Reykjavik"},
  149.     {"IRELAND","Dublin"},
  150.     {"ITALY","Rome"},
  151.     {"LATVIA","Riga"},
  152.     {"LIECHTENSTEIN","Vaduz"},
  153.     {"LITHUANIA","Vilnius"},
  154.     {"LUXEMBOURG","Luxembourg"},
  155.     {"MACEDONIA","Skopje"},
  156.     {"MALTA","Valletta"},
  157.     {"MONACO","Monaco"},
  158.     {"MONTENEGRO","Podgorica"},
  159.     {"THE NETHERLANDS","Amsterdam"},
  160.     {"NORWAY","Oslo"},
  161.     {"POLAND","Warsaw"},
  162.     {"PORTUGAL","Lisbon"},
  163.     {"ROMANIA","Bucharest"},
  164.     {"SAN MARINO","San Marino"},
  165.     {"SERBIA","Belgrade"},
  166.     {"SLOVAKIA","Bratislava"},
  167.     {"SLOVENIA","Ljuijana"},
  168.     {"SPAIN","Madrid"},
  169.     {"SWEDEN","Stockholm"},
  170.     {"SWITZERLAND","Berne"},
  171.     {"UNITED KINGDOM","London"},
  172.     {"VATICAN CITY","Vatican City"},
  173.     // North and Central America
  174.     {"ANTIGUA AND BARBUDA","Saint John's"},
  175.     {"BAHAMAS","Nassau"},
  176.     {"BARBADOS","Bridgetown"},
  177.     {"BELIZE","Belmopan"},
  178.     {"CANADA","Ottawa"},
  179.     {"COSTA RICA","San Jose"},
  180.     {"CUBA","Havana"},
  181.     {"DOMINICA","Roseau"},
  182.     {"DOMINICAN REPUBLIC","Santo Domingo"},
  183.     {"EL SALVADOR","San Salvador"},
  184.     {"GRENADA","Saint George's"},
  185.     {"GUATEMALA","Guatemala City"},
  186.     {"HAITI","Port-au-Prince"},
  187.     {"HONDURAS","Tegucigalpa"},
  188.     {"JAMAICA","Kingston"},
  189.     {"MEXICO","Mexico City"},
  190.     {"NICARAGUA","Managua"},
  191.     {"PANAMA","Panama City"},
  192.     {"ST. KITTS AND NEVIS","Basseterre"},
  193.     {"ST. LUCIA","Castries"},
  194.     {"ST. VINCENT AND THE GRENADINES","Kingstown"},
  195.     {"UNITED STATES OF AMERICA","Washington, D.C."},
  196.     // South America
  197.     {"ARGENTINA","Buenos Aires"},
  198.     {"BOLIVIA","Sucre (legal)/La Paz(administrative)"},
  199.     {"BRAZIL","Brasilia"},
  200.     {"CHILE","Santiago"},
  201.     {"COLOMBIA","Bogota"},
  202.     {"ECUADOR","Quito"},
  203.     {"GUYANA","Georgetown"},
  204.     {"PARAGUAY","Asuncion"},
  205.     {"PERU","Lima"},
  206.     {"SURINAME","Paramaribo"},
  207.     {"TRINIDAD AND TOBAGO","Port of Spain"},
  208.     {"URUGUAY","Montevideo"},
  209.     {"VENEZUELA","Caracas"},
  210.   };
  211.   // Use AbstractMap by implementing entrySet()
  212.   private static class FlyweightMap
  213.   extends AbstractMap<String,String> {
  214.     private static class Entry
  215.     implements Map.Entry<String,String> {
  216.       int index;
  217.       Entry(int index) { this.index = index; }
  218.       @Override
  219.       public boolean equals(Object o) {
  220.         return o instanceof FlyweightMap &&
  221.           Objects.equals(DATA[index][0], o);
  222.       }
  223.       @Override
  224.       public int hashCode() {
  225.         return Objects.hashCode(DATA[index][0]);
  226.       }
  227.       @Override
  228.       public String getKey() { return DATA[index][0]; }
  229.       @Override
  230.       public String getValue() {
  231.         return DATA[index][1];
  232.       }
  233.       @Override
  234.       public String setValue(String value) {
  235.         throw new UnsupportedOperationException();
  236.       }
  237.     }
  238.     // Implement size() & iterator() for AbstractSet:
  239.     static class EntrySet
  240.     extends AbstractSet<Map.Entry<String,String>> {
  241.       private int size;
  242.       EntrySet(int size) {
  243.         if(size < 0)
  244.           this.size = 0;
  245.         // Can't be any bigger than the array:
  246.         else if(size > DATA.length)
  247.           this.size = DATA.length;
  248.         else
  249.           this.size = size;
  250.       }
  251.       @Override
  252.       public int size() { return size; }
  253.       private class Iter
  254.       implements Iterator<Map.Entry<String,String>> {
  255.         // Only one Entry object per Iterator:
  256.         private Entry entry = new Entry(-1);
  257.         @Override
  258.         public boolean hasNext() {
  259.           return entry.index < size - 1;
  260.         }
  261.         @Override
  262.         public Map.Entry<String,String> next() {
  263.           entry.index++;
  264.           return entry;
  265.         }
  266.         @Override
  267.         public void remove() {
  268.           throw new UnsupportedOperationException();
  269.         }
  270.       }
  271.       @Override
  272.       public
  273.       Iterator<Map.Entry<String,String>> iterator() {
  274.         return new Iter();
  275.       }
  276.     }
  277.     private static
  278.     Set<Map.Entry<String,String>> entries =
  279.       new EntrySet(DATA.length);
  280.     @Override
  281.     public Set<Map.Entry<String,String>> entrySet() {
  282.       return entries;
  283.     }
  284.   }
  285.   // Create a partial map of 'size' countries:
  286.   static Map<String,String> select(final int size) {
  287.     return new FlyweightMap() {
  288.       @Override
  289.       public Set<Map.Entry<String,String>> entrySet() {
  290.         return new EntrySet(size);
  291.       }
  292.     };
  293.   }
  294.   static Map<String,String> map = new FlyweightMap();
  295.   public static Map<String,String> capitals() {
  296.     return map; // The entire map
  297.   }
  298.   public static Map<String,String> capitals(int size) {
  299.     return select(size); // A partial map
  300.   }
  301.   static List<String> names =
  302.     new ArrayList<>(map.keySet());
  303.   // All the names:
  304.   public static List<String> names() { return names; }
  305.   // A partial list:
  306.   public static List<String> names(int size) {
  307.     return new ArrayList<>(select(size).keySet());
  308.   }
  309.   public static void main(String[] args) {
  310.     System.out.println(capitals(10));
  311.     System.out.println(names(10));
  312.     System.out.println(new HashMap<>(capitals(3)));
  313.     System.out.println(
  314.       new LinkedHashMap<>(capitals(3)));
  315.     System.out.println(new TreeMap<>(capitals(3)));
  316.     System.out.println(new Hashtable<>(capitals(3)));
  317.     System.out.println(new HashSet<>(names(6)));
  318.     System.out.println(new LinkedHashSet<>(names(6)));
  319.     System.out.println(new TreeSet<>(names(6)));
  320.     System.out.println(new ArrayList<>(names(6)));
  321.     System.out.println(new LinkedList<>(names(6)));
  322.     System.out.println(capitals().get("BRAZIL"));
  323.   }
  324. }
  325. /* Output:
  326. {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo,
  327. BOTSWANA=Gaberone, BURKINA FASO=Ouagadougou,
  328. BURUNDI=Bujumbura, CAMEROON=Yaounde, CAPE VERDE=Praia,
  329. CENTRAL AFRICAN REPUBLIC=Bangui, CHAD=N'djamena}
  330. [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO,
  331. BURUNDI, CAMEROON, CAPE VERDE, CENTRAL AFRICAN
  332. REPUBLIC, CHAD]
  333. {BENIN=Porto-Novo, ANGOLA=Luanda, ALGERIA=Algiers}
  334. {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo}
  335. {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo}
  336. {ALGERIA=Algiers, ANGOLA=Luanda, BENIN=Porto-Novo}
  337. [BENIN, BOTSWANA, ANGOLA, BURKINA FASO, ALGERIA,
  338. BURUNDI]
  339. [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO,
  340. BURUNDI]
  341. [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO,
  342. BURUNDI]
  343. [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO,
  344. BURUNDI]
  345. [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO,
  346. BURUNDI]
  347. Brasilia
  348. */

二维数组 String DATA 是 public 的，因此可以在别处使用。 FlyweightMap 必须实现 entrySet() 方法，该方法需要一个自定义 Set 实现和一个自定义 Map.Entry 类。这是实现享元的另一种方法：每个 Map.Entry 对象存储它自身的索引，而不是实际的键和值。当调用 getKey() 或 getValue() 时，它使用索引返回相应的 DATA 元素。 EntrySet 确保它的 size 不大于 DATA 。

享元的另一部分在 EntrySet.Iterator 中实现。相比于为 DATA 中的每个数据对创建一个 Map.Entry 对象，这里每个迭代器只有一个 Map.Entry 对象。 Entry 对象作为数据的窗口，它只包含 String 静态数组的索引。每次为迭代器调用 next() 时，Entry 中的索引都会递增，因此它会指向下一个数据对，然后从 next() 返回 Iterators 的单个 Entry 对象。[^1]

select() 方法生成一个包含所需大小的 EntrySet 的 FlyweightMap ，这用于在主方法中演示的重载的 capitals() 和 names() 方法。

集合功能

下面这个表格展示了可以对 Collection 执行的所有操作（不包括自动继承自 Object 的方法），因此，可以用 List ， Set ， Queue 或 Deque 执行这里的所有操作（这些接口可能也提供了一些其他的功能）。Map 不是从 Collection 继承的，所以要单独处理它。

方法名 描述
boolean add(T) 确保集合包含该泛型类型 T 的参数。如果不添加参数，则返回 false 。 （这是一种“可选”方法，将在下一节中介绍。）
boolean addAll(Collection\<? extends T>) 添加参数集合中的所有元素。只要有元素被成功添加则返回 true。（“可选的”）
void clear() 删除集合中的所有元素。（“可选的”）
boolean contains(T) 如果目标集合包含该泛型类型 T 的参数，则返回 true 。
boolean containsAll(Collection\<?>) 如果目标集合包含参数集合中的所有元素，则返回 true
boolean isEmpty() 如果集合为空，则返回 true
Iterator\ iterator() Spliterator\ spliterator() 返回一个迭代器来遍历集合中的元素。 Spliterators 更复杂一些，它用在并发场景
boolean remove(Object) 如果目标集合包含该参数，则在集合中删除该参数，如果成功删除则返回 true 。（“可选的”）
boolean removeAll(Collection\<?>) 删除目标集合中，参数集合所包含的全部元素。如果有元素被成功删除则返回 true 。 （“可选的”）
boolean removeIf(Predicate\<? super E>) 删除此集合中，满足给定断言（predicate）的所有元素
Stream\ stream() Stream\ parallelStream() 返回由该 Collection 中元素所组成的一个 Stream
int size() 返回集合中所包含元素的个数
Object[] toArrat() 返回包含该集合所有元素的一个数组
\ T[] toArray(T[] a) 返回包含该集合所有元素的一个数组。结果的运行时类型是参数数组而不是普通的 Object 数组。

这里没有提供用于随机访问元素的 get() 方法，因为 Collection 还包含 Set ，它维护自己的内部排序，所以随机访问查找就没有意义了。因此，要查找 Collection 中的元素必须使用迭代器。

下面这个示例演示了 Collection 的所有方法。这里以 ArrayList 为例：

  1. // collectiontopics/CollectionMethods.java
  2. // Things you can do with all Collections
  3. import java.util.*;
  4. import static onjava.HTMLColors.*;
  6. public class CollectionMethods {
  7.   public static void main(String[] args) {
  8.     Collection<String> c =
  9.         new ArrayList<>(LIST.subList(0, 4));
  10.     c.add("ten");
  11.     c.add("eleven");
  12.     show(c);
  13.     border();
  14.     // Make an array from the List:
  15.     Object[] array = c.toArray();
  16.     // Make a String array from the List:
  17.     String[] str = c.toArray(new String[0]);
  18.     // Find max and min elements; this means
  19.     // different things depending on the way
  20.     // the Comparable interface is implemented:
  21.     System.out.println(
  22.       "Collections.max(c) = " + Collections.max(c));
  23.     System.out.println(
  24.       "Collections.min(c) = " + Collections.min(c));
  25.     border();
  26.     // Add a Collection to another Collection
  27.     Collection<String> c2 =
  28.         new ArrayList<>(LIST.subList(10, 14));
  29.     c.addAll(c2);
  30.     show(c);
  31.     border();
  32.     c.remove(LIST.get(0));
  33.     show(c);
  34.     border();
  35.     // Remove all components that are
  36.     // in the argument collection:
  37.     c.removeAll(c2);
  38.     show(c);
  39.     border();
  40.     c.addAll(c2);
  41.     show(c);
  42.     border();
  43.     // Is an element in this Collection?
  44.     String val = LIST.get(3);
  45.     System.out.println(
  46.       "c.contains(" + val  + ") = " + c.contains(val));
  47.     // Is a Collection in this Collection?
  48.     System.out.println(
  49.       "c.containsAll(c2) = " + c.containsAll(c2));
  50.     Collection<String> c3 =
  51.       ((List<String>)c).subList(3, 5);
  52.     // Keep all the elements that are in both
  53.     // c2 and c3 (an intersection of sets):
  54.     c2.retainAll(c3);
  55.     show(c2);
  56.     // Throw away all the elements
  57.     // in c2 that also appear in c3:
  58.     c2.removeAll(c3);
  59.     System.out.println(
  60.       "c2.isEmpty() = " +  c2.isEmpty());
  61.     border();
  62.     // Functional operation:
  63.     c = new ArrayList<>(LIST);
  64.     c.removeIf(s -> !s.startsWith("P"));
  65.     c.removeIf(s -> s.startsWith("Pale"));
  66.     // Stream operation:
  67.     c.stream().forEach(System.out::println);
  68.     c.clear(); // Remove all elements
  69.     System.out.println("after c.clear():" + c);
  70.   }
  71. }
  72. /* Output:
  73. AliceBlue
  74. AntiqueWhite
  75. Aquamarine
  76. Azure
  77. ten
  78. eleven
  79. ******************************
  80. Collections.max(c) = ten
  81. Collections.min(c) = AliceBlue
  82. ******************************
  83. AliceBlue
  84. AntiqueWhite
  85. Aquamarine
  86. Azure
  87. ten
  88. eleven
  89. Brown
  90. BurlyWood
  91. CadetBlue
  92. Chartreuse
  93. ******************************
  94. AntiqueWhite
  95. Aquamarine
  96. Azure
  97. ten
  98. eleven
  99. Brown
  100. BurlyWood
  101. CadetBlue
  102. Chartreuse
  103. ******************************
  104. AntiqueWhite
  105. Aquamarine
  106. Azure
  107. ten
  108. eleven
  109. ******************************
  110. AntiqueWhite
  111. Aquamarine
  112. Azure
  113. ten
  114. eleven
  115. Brown
  116. BurlyWood
  117. CadetBlue
  118. Chartreuse
  119. ******************************
  120. c.contains(Azure) = true
  121. c.containsAll(c2) = true
  122. c2.isEmpty() = true
  123. ******************************
  124. PapayaWhip
  125. PeachPuff
  126. Peru
  127. Pink
  128. Plum
  129. PowderBlue
  130. Purple
  131. after c.clear():[]
  132. */

为了只演示 Collection 接口的方法，而没有其它额外的内容，所以这里创建包含不同数据集的 ArrayList ，并向上转型为 Collection 对象。

可选操作

在 Collection 接口中执行各种添加和删除操作的方法是 可选操作 （optional operations）。这意味着实现类不需要为这些方法提供功能定义。

这是一种非常不寻常的定义接口的方式。正如我们所知，接口是一种合约（contract）。它表达的意思是，“无论你如何选择实现这个接口，我保证你可以将这些消息发送到这个对象”（我在这里使用术语“接口”来描述正式的 interface 关键字和“任何类或子类都支持的方法”的更一般含义）。但“可选”操作违反了这一基本原则，它表示调用某些方法不会执行有意义的行为。相反，它们会抛出异常！这看起来似乎丢失了编译时的类型安全性。

其实没那么糟糕。如果操作是可选的，编译器仍然能够限制你仅调用该接口中的方法。它不像动态语言那样，可以为任何对象调用任何方法，并在运行时查找特定的调用是否可行。[^2]此外，大多数将 Collection 作为参数的方法仅从该 Collection 中读取，并且 Collection 的所有“读取”方法都不是可选的。

为什么要将方法定义为“可选”的？因为这样做可以防止设计中的接口爆炸。集合库的其他设计往往会产生令人困惑的过多接口来描述主题的每个变体。这甚至使得不可能捕获到接口中的所有特殊情况，因为总有人能发明一个新的接口。“不支持的操作（unsupported operation）”这种方式实现了Java集合库的一个重要目标：集合要易于学习和使用。不支持的操作是一种特殊情况，可以推迟到必要的时候。但是，要使用此方法：

  1. UnsupportedOperationException 必须是一个罕见的事件。也就是说，对于大多数类，所有操作都应该起作用，并且只有在特殊情况下才应该不支持某项操作。这在Java集合库中是正确的，因为99%的时间使用到的类 —— ArrayList ， LinkedList ， HashSet 和 HashMap ，以及其他具体实现，都支持所有操作。该设计确实为创建一个新的 Collection 提供了一个“后门”，可以不为 Collection 接口中的所有方法都提供有意义的定义，这些定义仍然适合现有的类库。

  2. 当不支持某个操作时， UnsupportedOperationException 应该出现在实现阶段，而不是在将产品发送给客户之后。毕竟，这个异常表示编程错误：错误地使用了一个具体实现。

值得注意的是，不支持的操作只能在运行时检测到，因此这代表动态类型检查。如果你来自像 C++ 这样的静态类型语言，Java 可能看起来只是另一种静态类型语言。当然， Java 肯定有静态类型检查，但它也有大量的动态类型，因此很难说它只是静态语言或动态语言。一旦你开始注意到这一点，你就会开始看到 Java 中动态类型检查的其他示例。

不支持的操作

不支持的操作的常见来源是由固定大小的数据结构所支持的集合。使用 Arrays.asList() 方法将数组转换为 List 时，就会得到这样的集合。此外，还可以选择使用 Collections 类中的“不可修改（unmodifiable）”方法使任何集合（包括 Map ）抛出 UnsupportedOperationException 异常。此示例展示了这两种情况：

  1. // collectiontopics/Unsupported.java
  2. // Unsupported operations in Java collections
  3. import java.util.*;
  5. public class Unsupported {
  6.   static void
  7.   check(String description, Runnable tst) {
  8.     try {
  9.       tst.run();
  10.     } catch(Exception e) {
  11.       System.out.println(description + "(): " + e);
  12.     }
  13.   }
  14.   static void test(String msg, List<String> list) {
  15.     System.out.println("--- " + msg + " ---");
  16.     Collection<String> c = list;
  17.     Collection<String> subList = list.subList(1,8);
  18.     // Copy of the sublist:
  19.     Collection<String> c2 = new ArrayList<>(subList);
  20.     check("retainAll", () -> c.retainAll(c2));
  21.     check("removeAll", () -> c.removeAll(c2));
  22.     check("clear", () -> c.clear());
  23.     check("add", () -> c.add("X"));
  24.     check("addAll", () -> c.addAll(c2));
  25.     check("remove", () -> c.remove("C"));
  26.     // The List.set() method modifies the value but
  27.     // doesn't change the size of the data structure:
  28.     check("List.set", () -> list.set(0, "X"));
  29.   }
  30.   public static void main(String[] args) {
  31.     List<String> list = Arrays.asList(
  32.       "A B C D E F G H I J K L".split(" "));
  33.     test("Modifiable Copy", new ArrayList<>(list));
  34.     test("Arrays.asList()", list);
  35.     test("unmodifiableList()",
  36.       Collections.unmodifiableList(
  37.         new ArrayList<>(list)));
  38.   }
  39. }
  40. /* Output:
  41. --- Modifiable Copy ---
  42. --- Arrays.asList() ---
  43. retainAll(): java.lang.UnsupportedOperationException
  44. removeAll(): java.lang.UnsupportedOperationException
  45. clear(): java.lang.UnsupportedOperationException
  46. add(): java.lang.UnsupportedOperationException
  47. addAll(): java.lang.UnsupportedOperationException
  48. remove(): java.lang.UnsupportedOperationException
  49. --- unmodifiableList() ---
  50. retainAll(): java.lang.UnsupportedOperationException
  51. removeAll(): java.lang.UnsupportedOperationException
  52. clear(): java.lang.UnsupportedOperationException
  53. add(): java.lang.UnsupportedOperationException
  54. addAll(): java.lang.UnsupportedOperationException
  55. remove(): java.lang.UnsupportedOperationException
  56. List.set(): java.lang.UnsupportedOperationException
  57. */

因为 Arrays.asList() 生成的 List 由一个固定大小的数组所支持，所以唯一支持的操作是那些不改变数组大小的操作。任何会导致更改基础数据结构大小的方法都会产生 UnsupportedOperationException 异常，来说明这是对不支持的方法的调用（编程错误）。

请注意，始终可以将 Arrays.asList() 的结果作为一个参数传递给任何 Collection 的构造方法（或使用 addAll() 方法或静态的 Collections.addAll() 方法）来创建一个允许使用所有方法的常规集合，在主方法中第一次调用 test() 时显示了这种情况。这种调用产生了一个新的可调整大小的底层数据结构。

Collections 类中的“unmodifiable”方法会将集合包装一个代理中，如果执行任何想要修改集合的操作，则该代理会生成 UnsupportedOperationException 异常。使用这些方法的目的是生成一个“常量”集合对象。稍后将描述“unmodifiable“集合方法的完整列表。

test() 中的最后一个 check() 用于测试List 的 set() 方法。这里，“不支持的操作”技术的粒度（granularity）就派上用场了，得到的“接口”可以通过一种方法在 Arrays.asList() 返回的对象和 Collections.unmodifiableList() 返回的对象之间变换。 Arrays.asList() 返回固定大小的 List ，而 Collections.unmodifiableList() 生成无法更改的 List 。如输出中所示， Arrays.asList() 返回的 List 中的元素是可以修改的，因为这不会违反该 List 的“固定大小”特性。但很明显， unmodifiableList() 的结果不应该以任何方式修改。如果使用接口来描述，则需要两个额外的接口，一个具有可用的 set() 方法，而另一个没有。 Collection 的各种不可修改的子类型都将需要额外的接口。

如果一个方法将一个集合作为它的参数，那么它的文档应该说明必须实现哪些可选方法。

Set和存储顺序

第十二章 集合章节中的 Set 有关示例对 Set 的基本操作做了很好的介绍。 但是，这些示例可以方便地使用预定义的 Java 类型，例如 Integer 和 String ，它们可以在集合中使用。在创建自己的类型时请注意， Set （以及稍后会看到的 Map ）需要一种维护存储顺序的方法，该顺序因 Set 的不同实现而异。因此，不同的 Set 实现不仅具有不同的行为，而且它们对可以放入特定 Set 中的对象类型也有不同的要求：

Set 类型 约束
Set(interface) 添加到 Set 中的每个元素必须是唯一的，否则，Set 不会添加重复元素。添加到 Set 的元素必须至少定义 equals() 方法以建立对象唯一性。 Set 与 Collection 具有完全相同的接口。 Set 接口不保证它将以任何特定顺序维护其元素。
HashSet* 注重快速查找元素的集合，其中元素必须定义 hashCode() 和 equals() 方法。
TreeSet 由树支持的有序 Set。这样，就可以从 Set 中获取有序序列，其中元素必须实现 Comparable 接口。
LinkedHashSet 具有 HashSet 的查找速度，但在内部使用链表维护元素的插入顺序。因此，当在遍历 Set 时，结果将按元素的插入顺序显示。元素必须定义 hashCode() 和 equals() 方法。

HashSet 上的星号表示，在没有其他约束的情况下，这应该是你的默认选择，因为它针对速度进行了优化。

定义 hashCode() 方法在附录:理解equals和hashCode方法中进行了描述。必须为散列和树存储结构创建 equals() 方法，但只有当把类放在 HashSet 中时才需要 hashCode() （当然这很有可能，因为 HashSet 通常应该是作为 Set 实现的首选）或 LinkedHashSet 。 但是，作为一种良好的编程风格，在覆盖 equals() 时应始终覆盖 hashCode() 。

下面的示例演示了成功使用具有特定 Set 实现的类型所需的方法：

  1. // collectiontopics/TypesForSets.java
  2. // Methods necessary to put your own type in a Set
  3. import java.util.*;
  4. import java.util.function.*;
  5. import java.util.Objects;
  7. class SetType {
  8.   protected int i;
  9.   SetType(int n) { i = n; }
  10.   @Override
  11.   public boolean equals(Object o) {
  12.     return o instanceof SetType &&
  13.       Objects.equals(i, ((SetType)o).i);
  14.   }
  15.   @Override
  16.   public String toString() {
  17.     return Integer.toString(i);
  18.   }
  19. }
  21. class HashType extends SetType {
  22.   HashType(int n) { super(n); }
  23.   @Override
  24.   public int hashCode() {
  25.     return Objects.hashCode(i);
  26.   }
  27. }
  29. class TreeType extends SetType
  30. implements Comparable<TreeType> {
  31.   TreeType(int n) { super(n); }
  32.   @Override
  33.   public int compareTo(TreeType arg) {
  34.     return Integer.compare(arg.i, i);
  35.     // Equivalent to:
  36.     // return arg.i < i ? -1 : (arg.i == i ? 0 : 1);
  37.   }
  38. }
  40. public class TypesForSets {
  41.   static <T> void
  42.   fill(Set<T> set, Function<Integer, T> type) {
  43.     for(int i = 10; i >= 5; i--) // Descending
  44.       set.add(type.apply(i));
  45.     for(int i = 0; i < 5; i++) // Ascending
  46.       set.add(type.apply(i));
  47.   }
  48.   static <T> void
  49.   test(Set<T> set, Function<Integer, T> type) {
  50.     fill(set, type);
  51.     fill(set, type); // Try to add duplicates
  52.     fill(set, type);
  53.     System.out.println(set);
  54.   }
  55.   public static void main(String[] args) {
  56.     test(new HashSet<>(), HashType::new);
  57.     test(new LinkedHashSet<>(), HashType::new);
  58.     test(new TreeSet<>(), TreeType::new);
  59.     // Things that don't work:
  60.     test(new HashSet<>(), SetType::new);
  61.     test(new HashSet<>(), TreeType::new);
  62.     test(new LinkedHashSet<>(), SetType::new);
  63.     test(new LinkedHashSet<>(), TreeType::new);
  64.     try {
  65.       test(new TreeSet<>(), SetType::new);
  66.     } catch(Exception e) {
  67.       System.out.println(e.getMessage());
  68.     }
  69.     try {
  70.       test(new TreeSet<>(), HashType::new);
  71.     } catch(Exception e) {
  72.       System.out.println(e.getMessage());
  73.     }
  74.   }
  75. }
  76. /* Output:
  77. [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
  78. [10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4]
  79. [10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
  80. [1, 6, 8, 6, 2, 7, 8, 9, 4, 10, 7, 5, 1, 3, 4, 9, 9,
  81. 10, 5, 3, 2, 0, 4, 1, 2, 0, 8, 3, 0, 10, 6, 5, 7]
  82. [3, 1, 4, 8, 7, 6, 9, 5, 3, 0, 10, 5, 5, 10, 7, 8, 8,
  83. 9, 1, 4, 10, 2, 6, 9, 1, 6, 0, 3, 2, 0, 7, 2, 4]
  84. [10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5,
  85. 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4]
  86. [10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5,
  87. 0, 1, 2, 3, 4, 10, 9, 8, 7, 6, 5, 0, 1, 2, 3, 4]
  88. SetType cannot be cast to java.lang.Comparable
  89. HashType cannot be cast to java.lang.Comparable
  90. */

为了证明特定 Set 需要哪些方法，同时避免代码重复，这里创建了三个类。基类 SetType 存储一个 int 值，并通过 toString() 方法打印它。由于存储在 Set 中的所有类都必须具有 equals() ，因此该方法也放在基类中。基于 int i 来判断元素是否相等。

HashType 继承自 SetType ，并添加了 hashCode() 方法，该方法对于 Set 的散列实现是必需的。

要在任何类型的有序集合中使用对象，由 TreeType 实现的 Comparable 接口都是必需的，例如 SortedSet （ TreeSet 是其唯一实现）。在 compareTo() 中，请注意我没有使用“简单明了”的形式： return i-i2 。虽然这是一个常见的编程错误，但只有当 i 和 i2 是“无符号（unsigned）”整型时才能正常工作（如果 Java 有一个“unsigned”关键字的话，不过它没有）。它破坏了 Java 的有符号 int ，它不足以代表两个有符号整数的差异。如果 i 是一个大的正整数而 j 是一个大的负整数， i-j 将溢出并返回一个负值，这不是我们所需要的。

通常希望 compareTo() 方法生成与 equals() 方法一致的自然顺序。如果 equals() 对于特定比较产生 true，则 compareTo() 应该为该比较返回结果 零，并且如果 equals() 为比较产生 false ，则 compareTo() 应该为该比较产生非零结果。

在 TypesForSets 中， fill() 和 test() 都是使用泛型定义的，以防止代码重复。为了验证 Set 的行为， test() 在测试集上调用 fill() 三次，尝试引入重复的对象。 fill() 方法的参数可以接收任意一个 Set 类型，以及生成该类型的 Function 对象。因为此示例中使用的所有对象都有一个带有单个 int 参数的构造方法，所以可以将构造方法作为此 Function 传递，它将提供用于填充 Set 的对象。

请注意， fill() 方法按降序添加前五个元素，按升序添加后五个元素，以此来指出生成的存储顺序。输出显示 HashSet 按升序保留元素，但是，在附录:理解equals和hashCode方法中，你会发现这只是偶然的，因为散列会创建自己的存储顺序。这里只是因为元素是一个简单的 int ，在这种情况下它是升序的。 LinkedHashSet 按照插入顺序保存元素，TreeSet 按排序顺序维护元素（在此示例中因为 compareTo() 的实现方式，所以元素按降序排列。）

特定的 Set 类型一般都有所必需的操作，如果尝试使用没能正确支持这些操作的类型，那么事情就会出错。将没有重新定义 hashCode() 方法的 SetType 或 TreeType 对象放入任何散列实现会导致重复值，因此违反了 Set 的主要契约。 这是相当令人不安的，因为这甚至不产生运行时错误。但是，默认的 hashCode() 是合法的，所以即使它是不正确的，这也是合法的行为。确保此类程序正确性的唯一可靠方法是将单元测试合并到构建系统中。

如果尝试在 TreeSet 中使用没有实现 Comparable 接口的类型，则会得到更明确的结果：当 TreeSet 尝试将对象用作一个 Comparable 时，将会抛出异常。

SortedSet

SortedSet 中的元素保证按排序规则顺序， SortedSet 接口中的以下方法可以产生其他功能：

  • Comparator comparator() ：生成用于此 Set 的Comparator 或 null 来用于自然排序。
  • Object first() ：返回第一个元素。
  • Object last() ：返回最后一个元素。
  • SortedSet subSet(fromElement，toElement) ：使用 fromElement （包含）和 toElement （不包括）中的元素生成此 Set 的一个视图。
  • SortedSet headSet(toElement) ：使用顺序在 toElement 之前的元素生成此 Set 的一个视图。
  • SortedSet tailSet(fromElement) ：使用顺序在 fromElement 之后（包含 fromElement ）的元素生成此 Set 的一个视图。

下面是一个简单的演示：

  1. // collectiontopics/SortedSetDemo.java
  2. import java.util.*;
  3. import static java.util.stream.Collectors.*;
  5. public class SortedSetDemo {
  6.   public static void main(String[] args) {
  7.     SortedSet<String> sortedSet =
  8.       Arrays.stream(
  9.         "one two three four five six seven eight"
  10.         .split(" "))
  11.         .collect(toCollection(TreeSet::new));
  12.     System.out.println(sortedSet);
  13.     String low = sortedSet.first();
  14.     String high = sortedSet.last();
  15.     System.out.println(low);
  16.     System.out.println(high);
  17.     Iterator<String> it = sortedSet.iterator();
  18.     for(int i = 0; i <= 6; i++) {
  19.       if(i == 3) low = it.next();
  20.       if(i == 6) high = it.next();
  21.       else it.next();
  22.     }
  23.     System.out.println(low);
  24.     System.out.println(high);
  25.     System.out.println(sortedSet.subSet(low, high));
  26.     System.out.println(sortedSet.headSet(high));
  27.     System.out.println(sortedSet.tailSet(low));
  28.   }
  29. }
  30. /* Output:
  31. [eight, five, four, one, seven, six, three, two]
  32. eight
  33. two
  34. one
  35. two
  36. [one, seven, six, three]
  37. [eight, five, four, one, seven, six, three]
  38. [one, seven, six, three, two]
  39. */

注意， SortedSet 表示“根据对象的比较函数进行排序”，而不是“根据插入顺序”。可以使用 LinkedHashSet 保留元素的插入顺序。

队列

有许多 Queue 实现，其中大多数是为并发应用程序设计的。许多实现都是通过排序行为而不是性能来区分的。这是一个涉及大多数 Queue 实现的基本示例，包括基于并发的队列。队列将元素从一端放入并从另一端取出：

  1. // collectiontopics/QueueBehavior.java
  2. // Compares basic behavior
  3. import java.util.*;
  4. import java.util.stream.*;
  5. import java.util.concurrent.*;
  7. public class QueueBehavior {
  8.   static Stream<String> strings() {
  9.     return Arrays.stream(
  10.       ("one two three four five six seven " +
  11.        "eight nine ten").split(" "));
  12.   }
  13.   static void test(int id, Queue<String> queue) {
  14.     System.out.print(id + ": ");
  15.     strings().map(queue::offer).count();
  16.     while(queue.peek() != null)
  17.       System.out.print(queue.remove() + " ");
  18.     System.out.println();
  19.   }
  20.   public static void main(String[] args) {
  21.     int count = 10;
  22.     test(1, new LinkedList<>());
  23.     test(2, new PriorityQueue<>());
  24.     test(3, new ArrayBlockingQueue<>(count));
  25.     test(4, new ConcurrentLinkedQueue<>());
  26.     test(5, new LinkedBlockingQueue<>());
  27.     test(6, new PriorityBlockingQueue<>());
  28.     test(7, new ArrayDeque<>());
  29.     test(8, new ConcurrentLinkedDeque<>());
  30.     test(9, new LinkedBlockingDeque<>());
  31.     test(10, new LinkedTransferQueue<>());
  32.     test(11, new SynchronousQueue<>());
  33.   }
  34. }
  35. /* Output:
  36. 1: one two three four five six seven eight nine ten
  37. 2: eight five four nine one seven six ten three two
  38. 3: one two three four five six seven eight nine ten
  39. 4: one two three four five six seven eight nine ten
  40. 5: one two three four five six seven eight nine ten
  41. 6: eight five four nine one seven six ten three two
  42. 7: one two three four five six seven eight nine ten
  43. 8: one two three four five six seven eight nine ten
  44. 9: one two three four five six seven eight nine ten
  45. 10: one two three four five six seven eight nine ten
  46. 11:
  47. */

Deque 接口也继承自 Queue 。 除优先级队列外，Queue 按照元素的插入顺序生成元素。 在此示例中，SynchronousQueue 不会产生任何结果，因为它是一个阻塞队列，其中每个插入操作必须等待另一个线程执行相应的删除操作，反之亦然。

优先级队列

考虑一个待办事项列表，其中每个对象包含一个 String 以及主要和次要优先级值。通过实现 Comparable 接口来控制此待办事项列表的顺序：

  1. // collectiontopics/ToDoList.java
  2. // A more complex use of PriorityQueue
  3. import java.util.*;
  5. class ToDoItem implements Comparable<ToDoItem> {
  6.   private char primary;
  7.   private int secondary;
  8.   private String item;
  9.   ToDoItem(String td, char pri, int sec) {
  10.     primary = pri;
  11.     secondary = sec;
  12.     item = td;
  13.   }
  14.   @Override
  15.   public int compareTo(ToDoItem arg) {
  16.     if(primary > arg.primary)
  17.       return +1;
  18.     if(primary == arg.primary)
  19.       if(secondary > arg.secondary)
  20.         return +1;
  21.       else if(secondary == arg.secondary)
  22.         return 0;
  23.     return -1;
  24.   }
  25.   @Override
  26.   public String toString() {
  27.     return Character.toString(primary) +
  28.       secondary + ": " + item;
  29.   }
  30. }
  32. class ToDoList {
  33.   public static void main(String[] args) {
  34.     PriorityQueue<ToDoItem> toDo =
  35.       new PriorityQueue<>();
  36.     toDo.add(new ToDoItem("Empty trash", 'C', 4));
  37.     toDo.add(new ToDoItem("Feed dog", 'A', 2));
  38.     toDo.add(new ToDoItem("Feed bird", 'B', 7));
  39.     toDo.add(new ToDoItem("Mow lawn", 'C', 3));
  40.     toDo.add(new ToDoItem("Water lawn", 'A', 1));
  41.     toDo.add(new ToDoItem("Feed cat", 'B', 1));
  42.     while(!toDo.isEmpty())
  43.       System.out.println(toDo.remove());
  44.   }
  45. }
  46. /* Output:
  47. A1: Water lawn
  48. A2: Feed dog
  49. B1: Feed cat
  50. B7: Feed bird
  51. C3: Mow lawn
  52. C4: Empty trash
  53. */

这展示了通过优先级队列自动排序待办事项。

双端队列

Deque （双端队列）就像一个队列，但是可以从任一端添加和删除元素。 Java 6为 Deque 添加了一个显式接口。以下是对实现了 Deque 的类的最基本的 Deque 方法的测试：

  1. // collectiontopics/SimpleDeques.java
  2. // Very basic test of Deques
  3. import java.util.*;
  4. import java.util.concurrent.*;
  5. import java.util.function.*;
  7. class CountString implements Supplier<String> {
  8.   private int n = 0;
  9.   CountString() {}
  10.   CountString(int start) { n = start; }
  11.   @Override
  12.   public String get() {
  13.     return Integer.toString(n++);
  14.   }
  15. }
  17. public class SimpleDeques {
  18.   static void test(Deque<String> deque) {
  19.     CountString s1 = new CountString(),
  20.                 s2 = new CountString(20);
  21.     for(int n = 0; n < 8; n++) {
  22.         deque.offerFirst(s1.get());
  23.         deque.offerLast(s2.get()); // Same as offer()
  24.     }
  25.     System.out.println(deque);
  26.     String result = "";
  27.     while(deque.size() > 0) {
  28.       System.out.print(deque.peekFirst() + " ");
  29.       result += deque.pollFirst() + " ";
  30.       System.out.print(deque.peekLast() + " ");
  31.       result += deque.pollLast() + " ";
  32.     }
  33.     System.out.println("\n" + result);
  34.   }
  35.   public static void main(String[] args) {
  36.     int count = 10;
  37.     System.out.println("LinkedList");
  38.     test(new LinkedList<>());
  39.     System.out.println("ArrayDeque");
  40.     test(new ArrayDeque<>());
  41.     System.out.println("LinkedBlockingDeque");
  42.     test(new LinkedBlockingDeque<>(count));
  43.     System.out.println("ConcurrentLinkedDeque");
  44.     test(new ConcurrentLinkedDeque<>());
  45.   }
  46. }
  47. /* Output:
  48. LinkedList
  49. [7, 6, 5, 4, 3, 2, 1, 0, 20, 21, 22, 23, 24, 25, 26,
  50. 27]
  51. 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20
  52. 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20
  53. ArrayDeque
  54. [7, 6, 5, 4, 3, 2, 1, 0, 20, 21, 22, 23, 24, 25, 26,
  55. 27]
  56. 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20
  57. 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20
  58. LinkedBlockingDeque
  59. [4, 3, 2, 1, 0, 20, 21, 22, 23, 24]
  60. 4 24 3 23 2 22 1 21 0 20
  61. 4 24 3 23 2 22 1 21 0 20
  62. ConcurrentLinkedDeque
  63. [7, 6, 5, 4, 3, 2, 1, 0, 20, 21, 22, 23, 24, 25, 26,
  64. 27]
  65. 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20
  66. 7 27 6 26 5 25 4 24 3 23 2 22 1 21 0 20
  67. */

我只使用了 Deque 方法的“offer”和“poll”版本，因为当 LinkedBlockingDeque 的大小有限时，这些方法不会抛出异常。请注意， LinkedBlockingDeque 仅填充到它的限制大小为止，然后忽略额外的添加。

理解Map

正如在第十二章 集合章节中所了解到的，Map（也称为 关联数组 ）维护键值关联（对），因此可以使用键来查找值。标准 Java 库包含不同的 Map 基本实现，例如 HashMap ， TreeMap ， LinkedHashMap ， WeakHashMap ， ConcurrentHashMap 和 IdentityHashMap 。 它们都具有相同的基本 Map 接口，但它们的行为不同，包括效率，键值对的保存顺序和呈现顺序，保存对象的时间，如何在多线程程序中工作，以及如何确定键的相等性。 Map 接口的实现数量应该告诉你一些关于此工具重要性的信息。

为了更深入地了解 Map ，学习如何构造关联数组会很有帮助。下面是一个非常简单的实现：

  1. // collectiontopics/AssociativeArray.java
  2. // Associates keys with values
  4. public class AssociativeArray<K, V> {
  5.   private Object[][] pairs;
  6.   private int index;
  7.   public AssociativeArray(int length) {
  8.     pairs = new Object[length][2];
  9.   }
  10.   public void put(K key, V value) {
  11.     if(index >= pairs.length)
  12.       throw new ArrayIndexOutOfBoundsException();
  13.     pairs[index++] = new Object[]{ key, value };
  14.   }
  15.   @SuppressWarnings("unchecked")
  16.   public V get(K key) {
  17.     for(int i = 0; i < index; i++)
  18.       if(key.equals(pairs[i][0]))
  19.         return (V)pairs[i][1];
  20.     return null; // Did not find key
  21.   }
  22.   @Override
  23.   public String toString() {
  24.     StringBuilder result = new StringBuilder();
  25.     for(int i = 0; i < index; i++) {
  26.       result.append(pairs[i][0].toString());
  27.       result.append(" : ");
  28.       result.append(pairs[i][1].toString());
  29.       if(i < index - 1)
  30.         result.append("\n");
  31.     }
  32.     return result.toString();
  33.   }
  34.   public static void main(String[] args) {
  35.     AssociativeArray<String,String> map =
  36.       new AssociativeArray<>(6);
  37.     map.put("sky", "blue");
  38.     map.put("grass", "green");
  39.     map.put("ocean", "dancing");
  40.     map.put("tree", "tall");
  41.     map.put("earth", "brown");
  42.     map.put("sun", "warm");
  43.     try {
  44.       map.put("extra", "object"); // Past the end
  45.     } catch(ArrayIndexOutOfBoundsException e) {
  46.       System.out.println("Too many objects!");
  47.     }
  48.     System.out.println(map);
  49.     System.out.println(map.get("ocean"));
  50.   }
  51. }
  52. /* Output:
  53. Too many objects!
  54. sky : blue
  55. grass : green
  56. ocean : dancing
  57. tree : tall
  58. earth : brown
  59. sun : warm
  60. dancing
  61. */

关联数组中的基本方法是 put() 和 get() ，但为了便于显示，重写了 toString() 方法以打印键值对。为了显示它的工作原理，主方法加载一个带有字符串对的 AssociativeArray 并打印生成的映射，然后调用其中一个值的 get() 方法。

要使用 get() 方法，可以传入要查找的 key ，它将生成相关联的值作为结果，如果找不到则返回 null 。 get() 方法使用可能是效率最低的方法来定位值：从数组的头部开始并使用 equals() 来比较键。但这里是侧重于简单，而不是效率。

这个版本很有启发性，但它不是很有效，而且它只有一个固定的大小，这是不灵活的。幸运的是， java.util 中的那些 Map 没有这些问题。

性能

性能是 Map 的基本问题，在 get() 中使用线性方法搜索一个键时会非常慢。这就是 HashMap 要加速的地方。它使用一个称为 哈希码 的特殊值来替代慢速搜索一个键。哈希码是一种从相关对象中获取一些信息并将其转换为该对象的“相对唯一” int 的方法。 hashCode() 是根类 Object 中的一个方法，因此所有 Java 对象都可以生成哈希码。 HashMap 获取对象的 hashCode() 并使用它来快速搜索键。这就使得性能有了显著的提升。[^3]

以下是基本的 Map 实现。 HashMap上的星号表示，在没有其他约束的情况下，这应该是你的默认选择，因为它针对速度进行了优化。其他实现强调其他特性，因此不如 HashMap 快。

Map 实现 描述
HashMap* 基于哈希表的实现。（使用此类来代替 Hashtable 。）为插入和定位键值对提供了常数时间性能。可以通过构造方法调整性能，这些构造方法允许你设置哈希表的容量和装填因子。
LinkedHashMap 与 HashMap 类似，但是当遍历时，可以按插入顺序或最近最少使用（LRU）顺序获取键值对。只比 HashMap 略慢，一个例外是在迭代时，由于其使用链表维护内部顺序，所以会更快些。
TreeMap 基于红黑树的实现。当查看键或键值对时，它们按排序顺序（由 Comparable 或 Comparator 确定）。 TreeMap 的侧重点是按排序顺序获得结果。 TreeMap 是唯一使用 subMap() 方法的 Map ，它返回红黑树的一部分。
WeakHashMap 一种具有 弱键（weak keys） 的 Map ，为了解决某些类型的问题，它允许释放 Map 所引用的对象。如果在 Map 外没有对特定键的引用，则可以对该键进行垃圾回收。
ConcurrentHashMap 不使用同步锁定的线程安全 Map 。这在第二十四章 并发编程 一章中讨论。
IdentityHashMap 使用 == 而不是 equals() 来比较键。仅用于解决特殊问题，不适用于一般用途。

散列是在 Map 中存储元素的最常用方法。

Map 中使用的键的要求与 Set 中的元素的要求相同。可以在 TypesForSets.java 中看到这些。任何键必须具有 equals() 方法。如果键用于散列映射，则它还必须具有正确的 hashCode() 方法。如果键在 TreeMap 中使用，则必须实现 Comparable 接口。

以下示例使用先前定义的 CountMap 测试数据集显示通过 Map 接口可用的操作：

  1. // collectiontopics/MapOps.java
  2. // Things you can do with Maps
  3. import java.util.concurrent.*;
  4. import java.util.*;
  5. import onjava.*;
  7. public class MapOps {
  8.   public static
  9.   void printKeys(Map<Integer,String> map) {
  10.     System.out.print("Size = " + map.size() + ", ");
  11.     System.out.print("Keys: ");
  12.     // Produce a Set of the keys:
  13.     System.out.println(map.keySet());
  14.   }
  15.   public static
  16.   void test(Map<Integer,String> map) {
  17.     System.out.println(
  18.       map.getClass().getSimpleName());
  19.     map.putAll(new CountMap(25));
  20.     // Map has 'Set' behavior for keys:
  21.     map.putAll(new CountMap(25));
  22.     printKeys(map);
  23.     // Producing a Collection of the values:
  24.     System.out.print("Values: ");
  25.     System.out.println(map.values());
  26.     System.out.println(map);
  27.     System.out.println("map.containsKey(11): " +
  28.       map.containsKey(11));
  29.     System.out.println(
  30.       "map.get(11): " + map.get(11));
  31.     System.out.println("map.containsValue(\"F0\"): "
  32.       + map.containsValue("F0"));
  33.     Integer key = map.keySet().iterator().next();
  34.     System.out.println("First key in map: " + key);
  35.     map.remove(key);
  36.     printKeys(map);
  37.     map.clear();
  38.     System.out.println(
  39.       "map.isEmpty(): " + map.isEmpty());
  40.     map.putAll(new CountMap(25));
  41.     // Operations on the Set change the Map:
  42.     map.keySet().removeAll(map.keySet());
  43.     System.out.println(
  44.       "map.isEmpty(): " + map.isEmpty());
  45.   }
  46.   public static void main(String[] args) {
  47.     test(new HashMap<>());
  48.     test(new TreeMap<>());
  49.     test(new LinkedHashMap<>());
  50.     test(new IdentityHashMap<>());
  51.     test(new ConcurrentHashMap<>());
  52.     test(new WeakHashMap<>());
  53.   }
  54. }
  55. /* Output: (First 11 Lines)
  56. HashMap
  57. Size = 25, Keys: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
  58. 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
  59. Values: [A0, B0, C0, D0, E0, F0, G0, H0, I0, J0, K0,
  60. L0, M0, N0, O0, P0, Q0, R0, S0, T0, U0, V0, W0, X0, Y0]
  61. {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0,
  62. 9=J0, 10=K0, 11=L0, 12=M0, 13=N0, 14=O0, 15=P0, 16=Q0,
  63. 17=R0, 18=S0, 19=T0, 20=U0, 21=V0, 22=W0, 23=X0, 24=Y0}
  64. map.containsKey(11): true
  65. map.get(11): L0
  66. map.containsValue("F0"): true
  67. First key in map: 0
  68. Size = 24, Keys: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
  69. 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
  70. map.isEmpty(): true
  71. map.isEmpty(): true
  72.                   ...
  73. */

printKeys() 方法演示了如何生成 Map 的 Collection 视图。 keySet() 方法生成一个由 Map 中的键组成的 Set 。 打印 values() 方法的结果会生成一个包含 Map 中所有值的 Collection 。（请注意，键必须是唯一的，但值可以包含重复项。）由于这些 Collection 由 Map 支持，因此 Collection 中的任何更改都会反映在所关联的 Map 中。

程序的其余部分提供了每个 Map 操作的简单示例，并测试了每种基本类型的 Map 。

SortedMap

使用 SortedMap （由 TreeMap 或 ConcurrentSkipListMap 实现），键保证按排序顺序，这允许在 SortedMap 接口中使用这些方法来提供其他功能：

  • Comparator comparator() ：生成用于此 Map 的比较器， null 表示自然排序。
  • T firstKey() ：返回第一个键。
  • T lastKey() ：返回最后一个键。
  • SortedMap subMap(fromKey，toKey) ：生成此 Map 的视图，其中键从 fromKey（包括），到 toKey （不包括）。
  • SortedMap headMap(toKey) ：使用小于 toKey 的键生成此 Map 的视图。
  • SortedMap tailMap(fromKey) ：使用大于或等于 fromKey 的键生成此 Map 的视图。

这是一个类似于 SortedSetDemo.java 的示例，显示了 TreeMap 的这种额外行为：

  1. // collectiontopics/SortedMapDemo.java
  2. // What you can do with a TreeMap
  3. import java.util.*;
  4. import onjava.*;
  6. public class SortedMapDemo {
  7.   public static void main(String[] args) {
  8.     TreeMap<Integer,String> sortedMap =
  9.       new TreeMap<>(new CountMap(10));
  10.     System.out.println(sortedMap);
  11.     Integer low = sortedMap.firstKey();
  12.     Integer high = sortedMap.lastKey();
  13.     System.out.println(low);
  14.     System.out.println(high);
  15.     Iterator<Integer> it =
  16.       sortedMap.keySet().iterator();
  17.     for(int i = 0; i <= 6; i++) {
  18.       if(i == 3) low = it.next();
  19.       if(i == 6) high = it.next();
  20.       else it.next();
  21.     }
  22.     System.out.println(low);
  23.     System.out.println(high);
  24.     System.out.println(sortedMap.subMap(low, high));
  25.     System.out.println(sortedMap.headMap(high));
  26.     System.out.println(sortedMap.tailMap(low));
  27.   }
  28. }
  29. /* Output:
  30. {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0,
  31. 9=J0}
  32. 0
  33. 9
  34. 3
  35. 7
  36. {3=D0, 4=E0, 5=F0, 6=G0}
  37. {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0}
  38. {3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0, 9=J0}
  39. */

这里，键值对按照键的排序顺序进行排序。因为 TreeMap 中存在顺序感，所以“位置”的概念很有意义，因此可以拥有第一个、最后一个元素或子图。

LinkedHashMap

LinkedHashMap 针对速度进行哈希处理，但在遍历期间也会按插入顺序生成键值对（ System.out.println() 可以遍历它，因此可以看到遍历的结果）。 此外，可以在构造方法中配置 LinkedHashMap 以使用基于访问的 最近最少使用（LRU） 算法，因此未访问的元素（因此是删除的候选者）会出现在列表的前面。 这样可以轻松创建一个能够定期清理以节省空间的程序。下面是一个显示这两个功能的简单示例：

  1. // collectiontopics/LinkedHashMapDemo.java
  2. // What you can do with a LinkedHashMap
  3. import java.util.*;
  4. import onjava.*;
  6. public class LinkedHashMapDemo {
  7.   public static void main(String[] args) {
  8.     LinkedHashMap<Integer,String> linkedMap =
  9.       new LinkedHashMap<>(new CountMap(9));
  10.     System.out.println(linkedMap);
  11.     // Least-recently-used order:
  12.     linkedMap =
  13.       new LinkedHashMap<>(16, 0.75f, true);
  14.     linkedMap.putAll(new CountMap(9));
  15.     System.out.println(linkedMap);
  16.     for(int i = 0; i < 6; i++)
  17.       linkedMap.get(i);
  18.     System.out.println(linkedMap);
  19.     linkedMap.get(0);
  20.     System.out.println(linkedMap);
  21.   }
  22. }
  23. /* Output:
  24. {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0}
  25. {0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 6=G0, 7=H0, 8=I0}
  26. {6=G0, 7=H0, 8=I0, 0=A0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0}
  27. {6=G0, 7=H0, 8=I0, 1=B0, 2=C0, 3=D0, 4=E0, 5=F0, 0=A0}
  28. */

这些键值对确实是按照插入顺序进行遍历，即使对于LRU版本也是如此。 但是，在LRU版本中访问前六项（仅限）后，最后三项将移至列表的前面。然后，当再次访问“ 0 ”后，它移动到了列表的后面。

集合工具类

集合有许多独立的实用工具程序，在 java.util.Collections 中表示为静态方法。之前已经见过其中一些，例如 addAll() ， reverseOrder() 和 binarySearch() 。以下是其他内容（同步和不可修改的实用工具程序将在后面的章节中介绍）。在此表中，在需要的时候使用了泛型：

方法 描述
checkedCollection(Collection\ c, Class\ type)

checkedList(List\ list, Class\ type)

checkedMap(Map\ m, Class\ keyType, Class\ valueType)

checkedSet(Set\ s, Class\ type)

checkedSortedMap(SortedMap\ m, Class\ keyType, Class\ valueType)

checkedSortedSet(SortedSet\ s, Class\ type)		 生成 Collection 的动态类型安全视图或 Collection 的特定子类型。 当无法使用静态检查版本时使用这个版本。

这些方法的使用在第九章 多态章节的“动态类型安全”标题下进行了展示。
max(Collection)

min(Collection)		 使用 Collection 中对象的自然比较方法生成参数集合中的最大或最小元素。
max(Collection, Comparator)

min(Collection, Comparator)		 使用 Comparator 指定的比较方法生成参数集合中的最大或最小元素。
indexOfSubList(List source, List target) 返回 target 在 source 内第一次出现的起始索引，如果不存在则返回 -1。
lastIndexOfSubList(List source, List target) 返回 target 在 source 内最后一次出现的起始索引，如果不存在则返回 -1。
replaceAll(List\ list, T oldVal, T newVal) 用 newVal 替换列表中所有的 oldVal 。
reverse(List) 反转列表
reverseOrder()

reverseOrder(Comparator\)		 返回一个 Comparator ，它与集合中实现了 comparable\ 接口的对象的自然顺序相反。第二个版本颠倒了所提供的 Comparator 的顺序。
rotate(List, int distance) 将所有元素向前移动 distance ，将尾部的元素移到开头。（译者注：即循环移动）
shuffle(List)

shuffle(List, Random)		 随机置换指定列表（即打乱顺序）。第一个版本使用了默认的随机化源，或者也可以使用第二个版本，提供自己的随机化源。
sort(List\)

sort(List\, Comparator\<? super T> c)		 第一个版本使用元素的自然顺序排序该 List\ 。第二个版本根据提供的 Comparator 排序。
copy(List\<? super T> dest, List\<? extends T> src) 将 src 中的元素复制到 dest 。
swap(List, int i, int j) 交换 List 中位置 i 和 位置 j 的元素。可能比你手工编写的速度快。
fill(List\<? super T>, T x) 用 x 替换 List 中的所有元素。
nCopies(int n, T x) 返回大小为 n 的不可变 List\ ，其引用都指向 x 。
disjoint(Collection, Collection) 如果两个集合没有共同元素，则返回 true 。
frequency(Collection, Object x) 返回 Collection 中，等于 x 的元素个数。
emptyList()

emptyMap()

emptySet()		 返回不可变的空 List ， Map 或 Set 。这些是泛型的，因此生成的 Collection 可以被参数化为所需的类型。
singleton(T x)

singletonList(T x)

singletonMap(K key, V value)		 生成一个不可变的 List ， Set 或 Map ，其中只包含基于给定参数的单个元素。
list(Enumeration\ e) 生成一个 ArrayList\ ，其中元素为（旧式） Enumeration （ Iterator 的前身）中的元素。用于从遗留代码向新式转换。
enumeration(Collection\) 为参数集合生成一个旧式的 Enumeration\ 。

请注意， min（) 和 max() 使用 Collection 对象，而不使用 List ，因此不必担心是否应对 Collection 进行排序。（如前所述，在执行 binarySearch() 之前，将会对 List 或数组进行sort() 排序。）

下面是一个示例，展示了上表中大多数实用工具程序的基本用法：

  1. // collectiontopics/Utilities.java
  2. // Simple demonstrations of the Collections utilities
  3. import java.util.*;
  5. public class Utilities {
  6.   static List<String> list = Arrays.asList(
  7.     "one Two three Four five six one".split(" "));
  8.   public static void main(String[] args) {
  9.     System.out.println(list);
  10.     System.out.println("'list' disjoint (Four)?: " +
  11.       Collections.disjoint(list,
  12.         Collections.singletonList("Four")));
  13.     System.out.println(
  14.       "max: " + Collections.max(list));
  15.     System.out.println(
  16.       "min: " + Collections.min(list));
  17.     System.out.println(
  18.       "max w/ comparator: " + Collections.max(list,
  19.       String.CASE_INSENSITIVE_ORDER));
  20.     System.out.println(
  21.       "min w/ comparator: " + Collections.min(list,
  22.       String.CASE_INSENSITIVE_ORDER));
  23.     List<String> sublist =
  24.       Arrays.asList("Four five six".split(" "));
  25.     System.out.println("indexOfSubList: " +
  26.       Collections.indexOfSubList(list, sublist));
  27.     System.out.println("lastIndexOfSubList: " +
  28.       Collections.lastIndexOfSubList(list, sublist));
  29.     Collections.replaceAll(list, "one", "Yo");
  30.     System.out.println("replaceAll: " + list);
  31.     Collections.reverse(list);
  32.     System.out.println("reverse: " + list);
  33.     Collections.rotate(list, 3);
  34.     System.out.println("rotate: " + list);
  35.     List<String> source =
  36.       Arrays.asList("in the matrix".split(" "));
  37.     Collections.copy(list, source);
  38.     System.out.println("copy: " + list);
  39.     Collections.swap(list, 0, list.size() - 1);
  40.     System.out.println("swap: " + list);
  41.     Collections.shuffle(list, new Random(47));
  42.     System.out.println("shuffled: " + list);
  43.     Collections.fill(list, "pop");
  44.     System.out.println("fill: " + list);
  45.     System.out.println("frequency of 'pop': " +
  46.       Collections.frequency(list, "pop"));
  47.     List<String> dups =
  48.       Collections.nCopies(3, "snap");
  49.     System.out.println("dups: " + dups);
  50.     System.out.println("'list' disjoint 'dups'?: " +
  51.       Collections.disjoint(list, dups));
  52.     // Getting an old-style Enumeration:
  53.     Enumeration<String> e =
  54.       Collections.enumeration(dups);
  55.     Vector<String> v = new Vector<>();
  56.     while(e.hasMoreElements())
  57.       v.addElement(e.nextElement());
  58.     // Converting an old-style Vector
  59.     // to a List via an Enumeration:
  60.     ArrayList<String> arrayList =
  61.       Collections.list(v.elements());
  62.     System.out.println("arrayList: " + arrayList);
  63.   }
  64. }
  65. /* Output:
  66. [one, Two, three, Four, five, six, one]
  67. 'list' disjoint (Four)?: false
  68. max: three
  69. min: Four
  70. max w/ comparator: Two
  71. min w/ comparator: five
  72. indexOfSubList: 3
  73. lastIndexOfSubList: 3
  74. replaceAll: [Yo, Two, three, Four, five, six, Yo]
  75. reverse: [Yo, six, five, Four, three, Two, Yo]
  76. rotate: [three, Two, Yo, Yo, six, five, Four]
  77. copy: [in, the, matrix, Yo, six, five, Four]
  78. swap: [Four, the, matrix, Yo, six, five, in]
  79. shuffled: [six, matrix, the, Four, Yo, five, in]
  80. fill: [pop, pop, pop, pop, pop, pop, pop]
  81. frequency of 'pop': 7
  82. dups: [snap, snap, snap]
  83. 'list' disjoint 'dups'?: true
  84. arrayList: [snap, snap, snap]
  85. */

输出解释了每种实用方法的行为。请注意由于大小写的缘故，普通版本的 min() 和 max() 与带有 String.CASE_INSENSITIVE_ORDER 比较器参数的版本的区别。

排序和搜索列表

用于执行排序和搜索 List 的实用工具程序与用于排序对象数组的程序具有相同的名字和方法签名，只不过是 Collections 的静态方法而不是 Arrays 。 这是一个使用 Utilities.java 中的 list 数据的示例：

  1. // collectiontopics/ListSortSearch.java
  2. // Sorting/searching Lists with Collections utilities
  3. import java.util.*;
  5. public class ListSortSearch {
  6.   public static void main(String[] args) {
  7.     List<String> list =
  8.       new ArrayList<>(Utilities.list);
  9.     list.addAll(Utilities.list);
  10.     System.out.println(list);
  11.     Collections.shuffle(list, new Random(47));
  12.     System.out.println("Shuffled: " + list);
  13.     // Use ListIterator to trim off last elements:
  14.     ListIterator<String> it = list.listIterator(10);
  15.     while(it.hasNext()) {
  16.       it.next();
  17.       it.remove();
  18.     }
  19.     System.out.println("Trimmed: " + list);
  20.     Collections.sort(list);
  21.     System.out.println("Sorted: " + list);
  22.     String key = list.get(7);
  23.     int index = Collections.binarySearch(list, key);
  24.     System.out.println(
  25.       "Location of " + key + " is " + index +
  26.       ", list.get(" + index + ") = " +
  27.       list.get(index));
  28.     Collections.sort(list,
  29.       String.CASE_INSENSITIVE_ORDER);
  30.     System.out.println(
  31.       "Case-insensitive sorted: " + list);
  32.     key = list.get(7);
  33.     index = Collections.binarySearch(list, key,
  34.       String.CASE_INSENSITIVE_ORDER);
  35.     System.out.println(
  36.       "Location of " + key + " is " + index +
  37.       ", list.get(" + index + ") = " +
  38.       list.get(index));
  39.   }
  40. }
  41. /* Output:
  42. [one, Two, three, Four, five, six, one, one, Two,
  43. three, Four, five, six, one]
  44. Shuffled: [Four, five, one, one, Two, six, six, three,
  45. three, five, Four, Two, one, one]
  46. Trimmed: [Four, five, one, one, Two, six, six, three,
  47. three, five]
  48. Sorted: [Four, Two, five, five, one, one, six, six,
  49. three, three]
  50. Location of six is 7, list.get(7) = six
  51. Case-insensitive sorted: [five, five, Four, one, one,
  52. six, six, three, three, Two]
  53. Location of three is 7, list.get(7) = three
  54. */

就像使用数组进行搜索和排序一样，如果使用 Comparator 进行排序，则必须使用相同的 Comparator 执行 binarySearch() 。

该程序还演示了 Collections 中的 shuffle() 方法，该方法随机打乱了 List 的顺序。 ListIterator 是在打乱后的列表中的特定位置创建的，用于从该位置删除元素，直到列表末尾。

创建不可修改的 Collection 或 Map

通常，创建 Collection 或 Map 的只读版本会很方便。 Collections 类通过将原始集合传递给一个方法然后返回一个只读版本的集合。 对于 Collection （如果不能将 Collection 视为更具体的类型）， List ， Set 和 Map ，这类方法有许多变体。这个示例展示了针对每种类型，正确构建只读版本集合的方法：

  1. // collectiontopics/ReadOnly.java
  2. // Using the Collections.unmodifiable methods
  3. import java.util.*;
  4. import onjava.*;
  6. public class ReadOnly {
  7.   static Collection<String> data =
  8.     new ArrayList<>(Countries.names(6));
  9.   public static void main(String[] args) {
  10.     Collection<String> c =
  11.       Collections.unmodifiableCollection(
  12.         new ArrayList<>(data));
  13.     System.out.println(c); // Reading is OK
  14.     //- c.add("one"); // Can't change it
  16.     List<String> a = Collections.unmodifiableList(
  17.         new ArrayList<>(data));
  18.     ListIterator<String> lit = a.listIterator();
  19.     System.out.println(lit.next()); // Reading is OK
  20.     //- lit.add("one"); // Can't change it
  22.     Set<String> s = Collections.unmodifiableSet(
  23.       new HashSet<>(data));
  24.     System.out.println(s); // Reading is OK
  25.     //- s.add("one"); // Can't change it
  27.     // For a SortedSet:
  28.     Set<String> ss =
  29.       Collections.unmodifiableSortedSet(
  30.         new TreeSet<>(data));
  32.     Map<String,String> m =
  33.       Collections.unmodifiableMap(
  34.         new HashMap<>(Countries.capitals(6)));
  35.     System.out.println(m); // Reading is OK
  36.     //- m.put("Ralph", "Howdy!");
  38.     // For a SortedMap:
  39.     Map<String,String> sm =
  40.       Collections.unmodifiableSortedMap(
  41.         new TreeMap<>(Countries.capitals(6)));
  42.   }
  43. }
  44. /* Output:
  45. [ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO,
  46. BURUNDI]
  47. ALGERIA
  48. [BENIN, BOTSWANA, ANGOLA, BURKINA FASO, ALGERIA,
  49. BURUNDI]
  50. {BENIN=Porto-Novo, BOTSWANA=Gaberone, ANGOLA=Luanda,
  51. BURKINA FASO=Ouagadougou, ALGERIA=Algiers,
  52. BURUNDI=Bujumbura}
  53. */

为特定类型调用 “unmodifiable” 方法不会导致编译时检查，但是一旦发生转换，对修改特定集合内容的任何方法调用都将产生 UnsupportedOperationException 异常。

在每种情况下，在将集合设置为只读之前，必须使用有意义的数据填充集合。填充完成后，最好的方法是用 “unmodifiable” 方法调用生成的引用替换现有引用。这样，一旦使得内容无法修改，那么就不会冒有意外更改内容的风险。另一方面，此工具还允许将可修改的集合保留为类中的私有集合，并从方法调用处返回对该集合的只读引用。所以，你可以在类内修改它，但其他人只能读它。

同步 Collection 或 Map

synchronized 关键字是多线程主题的重要组成部分，更复杂的内容在第二十四章 并发编程中介绍。在这里，只需要注意到 Collections 类包含一种自动同步整个集合的方法。 语法类似于 “unmodifiable” 方法：

  1. // collectiontopics/Synchronization.java
  2. // Using the Collections.synchronized methods
  3. import java.util.*;
  5. public class Synchronization {
  6.   public static void main(String[] args) {
  7.     Collection<String> c =
  8.       Collections.synchronizedCollection(
  9.         new ArrayList<>());
  10.     List<String> list = Collections
  11.       .synchronizedList(new ArrayList<>());
  12.     Set<String> s = Collections
  13.       .synchronizedSet(new HashSet<>());
  14.     Set<String> ss = Collections
  15.       .synchronizedSortedSet(new TreeSet<>());
  16.     Map<String,String> m = Collections
  17.       .synchronizedMap(new HashMap<>());
  18.     Map<String,String> sm = Collections
  19.       .synchronizedSortedMap(new TreeMap<>());
  20.   }
  21. }

最好立即通过适当的 “synchronized” 方法传递新集合，如上所示。这样，就不会意外地暴露出非同步版本。

Fail Fast

Java 集合还具有防止多个进程修改集合内容的机制。如果当前正在迭代集合，然后有其他一些进程介入并插入，删除或更改该集合中的对象，则会出现此问题。也许在集合中已经遍历过了那个元素，也许还没有遍历到，也许在调用 size() 之后集合的大小会缩小…有许多灾难情景。 Java 集合库使用一种 fail-fast 的机制，该机制可以检测到除了当前进程引起的更改之外，其它任何对集合的更改操作。如果它检测到其他人正在修改集合，则会立即生成 ConcurrentModificationException 异常。这就是“fail-fast”的含义——它不会在以后使用更复杂的算法尝试检测问题（快速失败）。

通过创建迭代器并向迭代器指向的集合中添加元素，可以很容易地看到操作中的 fail-fast 机制，如下所示：

  1. // collectiontopics/FailFast.java
  2. // Demonstrates the "fail-fast" behavior
  3. import java.util.*;
  5. public class FailFast {
  6.   public static void main(String[] args) {
  7.     Collection<String> c = new ArrayList<>();
  8.     Iterator<String> it = c.iterator();
  9.     c.add("An object");
  10.     try {
  11.       String s = it.next();
  12.     } catch(ConcurrentModificationException e) {
  13.       System.out.println(e);
  14.     }
  15.   }
  16. }
  17. /* Output:
  18. java.util.ConcurrentModificationException
  19. */

异常来自于在从集合中获得迭代器之后，又尝试在集合中添加元素。程序的两个部分可能会修改同一个集合，这种可能性的存在会产生不确定状态，因此异常会通知你更改代码。在这种情况下，应先将所有元素添加到集合，然后再获取迭代器。

ConcurrentHashMap ， CopyOnWriteArrayList 和 CopyOnWriteArraySet 使用了特定的技术来避免产生 ConcurrentModificationException 异常。

持有引用

java.lang.ref 中库包含一组类，这些类允许垃圾收集具有更大的灵活性。特别是当拥有可能导致内存耗尽的大对象时，这些类特别有用。这里有三个从抽象类 Reference 继承来的类： SoftReference （软引用）， WeakReference （弱引用）和 PhantomReference （虚引用）继承了三个类。如果一个对象只能通过这其中的一个 Reference 对象访问，那么这三种类型每个都为垃圾收集器提供不同级别的间接引用（indirection）。

如果一个对象是 可达的（reachable），那么意味着在程序中的某个位置可以找到该对象。这可能意味着在栈上有一个直接引用该对象的普通引用，但也有可能是引用了一个对该对象有引用的对象，这可以有很多中间环节。如果某个对象是可达的，则垃圾收集器无法释放它，因为它仍然被程序所使用。如果某个对象是不可达的，则程序无法使用它，那么垃圾收集器回收该对象就是安全的。

使用 Reference 对象继续保持对该对象的引用，以到达该对象，但也允许垃圾收集器释放该对象。因此，程序可以使用该对象，但如果内存即将耗尽，则允许释放该对象。

可以通过使用 Reference 对象作为你和普通引用之间的中介（代理）来实现此目的。此外，必须没有对象的普通引用（未包含在 Reference 对象中的对象）。如果垃圾收集器发现对象可通过普通引用访问，则它不会释放该对象。

按照 SoftReference ， WeakReference 和 PhantomReference 的顺序，每个都比前一个更“弱”，并且对应于不同的可达性级别。软引用用于实现对内存敏感的缓存。弱引用用于实现“规范化映射”（ canonicalized mappings）——对象的实例可以在程序的多个位置同时使用，以节省存储，但不会阻止其键（或值）被回收。虚引用用于调度 pre-mortem 清理操作，这是一种比 Java 终结机制（Java finalization mechanism）更灵活的方式。

使用 SoftReference 和 WeakReference ，可以选择是否将它们放在 ReferenceQueue （用于 pre-mortem 清理操作的设备）中，但 PhantomReference 只能在 ReferenceQueue 上构建。下面是一个简单的演示：

  1. // collectiontopics/References.java
  2. // Demonstrates Reference objects
  3. import java.lang.ref.*;
  4. import java.util.*;
  6. class VeryBig {
  7.   private static final int SIZE = 10000;
  8.   private long[] la = new long[SIZE];
  9.   private String ident;
  10.   VeryBig(String id) { ident = id; }
  11.   @Override
  12.   public String toString() { return ident; }
  13.   @Override
  14.   protected void finalize() {
  15.     System.out.println("Finalizing " + ident);
  16.   }
  17. }
  19. public class References {
  20.   private static ReferenceQueue<VeryBig> rq =
  21.     new ReferenceQueue<>();
  22.   public static void checkQueue() {
  23.     Reference<? extends VeryBig> inq = rq.poll();
  24.     if(inq != null)
  25.       System.out.println("In queue: " + inq.get());
  26.   }
  27.   public static void main(String[] args) {
  28.     int size = 10;
  29.     // Or, choose size via the command line:
  30.     if(args.length > 0)
  31.       size = Integer.valueOf(args[0]);
  32.     LinkedList<SoftReference<VeryBig>> sa =
  33.       new LinkedList<>();
  34.     for(int i = 0; i < size; i++) {
  35.       sa.add(new SoftReference<>(
  36.         new VeryBig("Soft " + i), rq));
  37.       System.out.println(
  38.         "Just created: " + sa.getLast());
  39.       checkQueue();
  40.     }
  41.     LinkedList<WeakReference<VeryBig>> wa =
  42.       new LinkedList<>();
  43.     for(int i = 0; i < size; i++) {
  44.       wa.add(new WeakReference<>(
  45.         new VeryBig("Weak " + i), rq));
  46.       System.out.println(
  47.         "Just created: " + wa.getLast());
  48.       checkQueue();
  49.     }
  50.     SoftReference<VeryBig> s =
  51.       new SoftReference<>(new VeryBig("Soft"));
  52.     WeakReference<VeryBig> w =
  53.       new WeakReference<>(new VeryBig("Weak"));
  54.     System.gc();
  55.     LinkedList<PhantomReference<VeryBig>> pa =
  56.       new LinkedList<>();
  57.     for(int i = 0; i < size; i++) {
  58.       pa.add(new PhantomReference<>(
  59.         new VeryBig("Phantom " + i), rq));
  60.       System.out.println(
  61.         "Just created: " + pa.getLast());
  62.       checkQueue();
  63.     }
  64.   }
  65. }
  66. /* Output: (First and Last 10 Lines)
  67. Just created: java.lang.ref.SoftReference@15db9742
  68. Just created: java.lang.ref.SoftReference@6d06d69c
  69. Just created: java.lang.ref.SoftReference@7852e922
  70. Just created: java.lang.ref.SoftReference@4e25154f
  71. Just created: java.lang.ref.SoftReference@70dea4e
  72. Just created: java.lang.ref.SoftReference@5c647e05
  73. Just created: java.lang.ref.SoftReference@33909752
  74. Just created: java.lang.ref.SoftReference@55f96302
  75. Just created: java.lang.ref.SoftReference@3d4eac69
  76. Just created: java.lang.ref.SoftReference@42a57993
  77. ...________...________...________...________...
  78. Just created: java.lang.ref.PhantomReference@45ee12a7
  79. In queue: null
  80. Just created: java.lang.ref.PhantomReference@330bedb4
  81. In queue: null
  82. Just created: java.lang.ref.PhantomReference@2503dbd3
  83. In queue: null
  84. Just created: java.lang.ref.PhantomReference@4b67cf4d
  85. In queue: null
  86. Just created: java.lang.ref.PhantomReference@7ea987ac
  87. In queue: null
  88. */

当运行此程序（将输出重定向到文本文件以查看页面中的输出）时，将会看到对象是被垃圾收集了的，虽然仍然可以通过 Reference 对象访问它们（使用 get() 来获取实际的对象引用）。 还可以看到 ReferenceQueue 始终生成包含 null 对象的 Reference 。 要使用它，请从特定的 Reference 类继承，并为新类添加更多有用的方法。

WeakHashMap

集合类库中有一个特殊的 Map 来保存弱引用： WeakHashMap 。 此类可以更轻松地创建规范化映射。在这种映射中，可以通过仅仅创建一个特定值的实例来节省存储空间。当程序需要该值时，它会查找映射中的现有对象并使用它（而不是从头开始创建一个）。 该映射可以将值作为其初始化的一部分，但更有可能的是在需要时创建该值。

由于这是一种节省存储空间的技术，因此 WeakHashMap 允许垃圾收集器自动清理键和值，这是非常方便的。不能对放在 WeakHashMap 中的键和值做任何特殊操作，它们由 map 自动包装在 WeakReference 中。当键不再被使用的时候才允许清理，如下所示：

  1. // collectiontopics/CanonicalMapping.java
  2. // Demonstrates WeakHashMap
  3. import java.util.*;
  5. class Element {
  6.   private String ident;
  7.   Element(String id) { ident = id; }
  8.   @Override
  9.   public String toString() { return ident; }
  10.   @Override
  11.   public int hashCode() {
  12.     return Objects.hashCode(ident);
  13.   }
  14.   @Override
  15.   public boolean equals(Object r) {
  16.     return r instanceof Element &&
  17.       Objects.equals(ident, ((Element)r).ident);
  18.   }
  19.   @Override
  20.   protected void finalize() {
  21.     System.out.println("Finalizing " +
  22.       getClass().getSimpleName() + " " + ident);
  23.   }
  24. }
  26. class Key extends Element {
  27.   Key(String id) { super(id); }
  28. }
  30. class Value extends Element {
  31.   Value(String id) { super(id); }
  32. }
  34. public class CanonicalMapping {
  35.   public static void main(String[] args) {
  36.     int size = 1000;
  37.     // Or, choose size via the command line:
  38.     if(args.length > 0)
  39.       size = Integer.valueOf(args[0]);
  40.     Key[] keys = new Key[size];
  41.     WeakHashMap<Key,Value> map =
  42.       new WeakHashMap<>();
  43.     for(int i = 0; i < size; i++) {
  44.       Key k = new Key(Integer.toString(i));
  45.       Value v = new Value(Integer.toString(i));
  46.       if(i % 3 == 0)
  47.         keys[i] = k; // Save as "real" references
  48.       map.put(k, v);
  49.     }
  50.     System.gc();
  51.   }
  52. }

Key 类必须具有 hashCode() 和 equals() ，因为它将被用作散列数据结构中的键。 hashCode() 的内容在附录：理解hashCode和equals方法中进行了描述。

运行程序，你会看到垃圾收集器每三个键跳过一次。对该键的普通引用也被放置在 keys 数组中，因此这些对象不能被垃圾收集。

Java 1.0 / 1.1 的集合类

不幸的是，许多代码是使用 Java 1.0 / 1.1 中的集合编写的，甚至新代码有时也是使用这些类编写的。编写新代码时切勿使用旧集合。旧的集合类有限，所以关于它们的讨论不多。由于它们是不合时宜的，所以我会尽量避免过分强调一些可怕的设计决定。

Vector 和 Enumeration

Java 1.0 / 1.1 中唯一的自扩展序列是 Vector ，因此它被用于很多地方。它的缺陷太多了，无法在这里描述（参见《Java编程思想》第1版，可从www.OnJava8.com免费下载）。基本上，你可以将它看作是具有冗长且笨拙的方法名称的 ArrayList 。在修订后的 Java 集合库中，Vector 已经被调整适配过，因此可以作为 Collection 和 List 来使用。事实证明这有点不正常，集合类库仍然包含它只是为了支持旧的 Java 代码，但这会让一些人误以为 Vector 已经变得更好了。

迭代器的 Java 1.0 / 1.1 版本选择创建一个新名称“enumeration”，而不是使用每个人都熟悉的术语（“iterator”）。 Enumeration 接口小于 Iterator ，只包含两个方法，并且它使用更长的方法名称：如果还有更多元素，则 boolean hasMoreElements() 返回 true ， Object nextElement() 返回此enumeration的下一个元素 （否则会抛出异常）。

Enumeration 只是一个接口，而不是一个实现，甚至新的类库有时仍然使用旧的 Enumeration ，这是不幸的，但通常是无害的。应该总是在自己的代码中使用 Iterator ，但要做好准备应对那些提供 Enumeration 的类库。

此外，可以使用 Collections.enumeration() 方法为任何 Collection 生成 Enumeration ，如下例所示：

  1. // collectiontopics/Enumerations.java
  2. // Java 1.0/1.1 Vector and Enumeration
  3. import java.util.*;
  4. import onjava.*;
  6. public class Enumerations {
  7.   public static void main(String[] args) {
  8.     Vector<String> v =
  9.       new Vector<>(Countries.names(10));
  10.     Enumeration<String> e = v.elements();
  11.     while(e.hasMoreElements())
  12.       System.out.print(e.nextElement() + ", ");
  13.     // Produce an Enumeration from a Collection:
  14.     e = Collections.enumeration(new ArrayList<>());
  15.   }
  16. }
  17. /* Output:
  18. ALGERIA, ANGOLA, BENIN, BOTSWANA, BURKINA FASO,
  19. BURUNDI, CAMEROON, CAPE VERDE, CENTRAL AFRICAN
  20. REPUBLIC, CHAD,
  21. */

要生成 Enumeration ，可以调用 elements() ，然后可以使用它来执行向前迭代。

最后一行创建一个 ArrayList ，并使用 enumeration() 来将 ArrayList 适配为一个 Enumeration 。 因此，如果有旧代码需要使用 Enumeration ，你仍然可以使用新集合。

Hashtable

正如你在本附录中的性能比较中所看到的，基本的 Hashtable 与 HashMap 非常相似，甚至方法名称都相似。在新代码中没有理由使用 Hashtable 而不是 HashMap 。

Stack

之前使用 LinkedList 引入了栈的概念。 Java 1.0 / 1.1 Stack 的奇怪之处在于，不是以组合方式使用 Vector ，而是继承自 Vector 。 因此它具有 Vector 的所有特征和行为以及一些额外的 Stack 行为。很难去知道设计师是否有意识地认为这样做是有用的，或者它是否只是太天真了，无论如何，它在进入发行版之前显然没有经过审查，所以这个糟糕的设计仍然存在（但不要使用它）。

这是 Stack 的简单演示，向栈中放入枚举中每一个类型的 String 形式。它还展示了如何轻松地将 LinkedList 用作栈，或者使用在第十二章：集合章节中创建的 Stack 类：

  1. // collectiontopics/Stacks.java
  2. // Demonstration of Stack Class
  3. import java.util.*;
  5. enum Month { JANUARY, FEBRUARY, MARCH, APRIL,
  6.   MAY, JUNE, JULY, AUGUST, SEPTEMBER,
  7.   OCTOBER, NOVEMBER }
  9. public class Stacks {
  10.   public static void main(String[] args) {
  11.     Stack<String> stack = new Stack<>();
  12.     for(Month m : Month.values())
  13.       stack.push(m.toString());
  14.     System.out.println("stack = " + stack);
  15.     // Treating a stack as a Vector:
  16.     stack.addElement("The last line");
  17.     System.out.println(
  18.       "element 5 = " + stack.elementAt(5));
  19.     System.out.println("popping elements:");
  20.     while(!stack.empty())
  21.       System.out.print(stack.pop() + " ");
  23.     // Using a LinkedList as a Stack:
  24.     LinkedList<String> lstack = new LinkedList<>();
  25.     for(Month m : Month.values())
  26.       lstack.addFirst(m.toString());
  27.     System.out.println("lstack = " + lstack);
  28.     while(!lstack.isEmpty())
  29.       System.out.print(lstack.removeFirst() + " ");
  31.     // Using the Stack class from
  32.     // the Collections Chapter:
  33.     onjava.Stack<String> stack2 =
  34.       new onjava.Stack<>();
  35.     for(Month m : Month.values())
  36.       stack2.push(m.toString());
  37.     System.out.println("stack2 = " + stack2);
  38.     while(!stack2.isEmpty())
  39.       System.out.print(stack2.pop() + " ");
  41.   }
  42. }
  43. /* Output:
  44. stack = [JANUARY, FEBRUARY, MARCH, APRIL, MAY, JUNE,
  45. JULY, AUGUST, SEPTEMBER, OCTOBER, NOVEMBER]
  46. element 5 = JUNE
  47. popping elements:
  48. The last line NOVEMBER OCTOBER SEPTEMBER AUGUST JULY
  49. JUNE MAY APRIL MARCH FEBRUARY JANUARY lstack =
  50. [NOVEMBER, OCTOBER, SEPTEMBER, AUGUST, JULY, JUNE, MAY,
  51. APRIL, MARCH, FEBRUARY, JANUARY]
  52. NOVEMBER OCTOBER SEPTEMBER AUGUST JULY JUNE MAY APRIL
  53. MARCH FEBRUARY JANUARY stack2 = [NOVEMBER, OCTOBER,
  54. SEPTEMBER, AUGUST, JULY, JUNE, MAY, APRIL, MARCH,
  55. FEBRUARY, JANUARY]
  56. NOVEMBER OCTOBER SEPTEMBER AUGUST JULY JUNE MAY APRIL
  57. MARCH FEBRUARY JANUARY
  58. */

String 形式是由 Month 中的枚举常量生成的，使用 push() 压入到栈中，然后使用 pop() 从栈顶部取出。为了说明一点，将 Vector 的操作也在 Stack 对象上执行， 这是可能的，因为凭借继承， Stack 是 Vector 。 因此，可以在 Vector 上执行的所有操作也可以在 Stack 上执行，例如 elementAt() 。

如前所述，在需要栈行为时使用 LinkedList ，或者从 LinkedList 类创建的 onjava.Stack 类。

BitSet

BitSet 用于有效地存储大量的开关信息。仅从尺寸大小的角度来看它是有效的，如果你正在寻找有效的访问，它比使用本机数组（native array）稍慢。

此外， BitSet 的最小大小是 long ：64位。这意味着如果你要存储更小的东西，比如8位， BitSet 就是浪费，如果尺寸有问题，你最好创建自己的类，或者只是用一个数组来保存你的标志。（只有在你创建许多包含开关信息列表的对象时才会出现这种情况，并且只应根据分析和其他指标来决定。如果你做出此决定只是因为您认为 BitSet 太大，那么最终会产生不必要的复杂性并且浪费大量时间。）

当添加更多元素时，普通集合会扩展， BitSet也会这样做。以下示例显示了 BitSet 的工作原理：

  1. // collectiontopics/Bits.java
  2. // Demonstration of BitSet
  3. import java.util.*;
  5. public class Bits {
  6.   public static void printBitSet(BitSet b) {
  7.     System.out.println("bits: " + b);
  8.     StringBuilder bbits = new StringBuilder();
  9.     for(int j = 0; j < b.size() ; j++)
  10.       bbits.append(b.get(j) ? "1" : "0");
  11.     System.out.println("bit pattern: " + bbits);
  12.   }
  13.   public static void main(String[] args) {
  14.     Random rand = new Random(47);
  15.     // Take the LSB of nextInt():
  16.     byte bt = (byte)rand.nextInt();
  17.     BitSet bb = new BitSet();
  18.     for(int i = 7; i >= 0; i--)
  19.       if(((1 << i) &  bt) != 0)
  20.         bb.set(i);
  21.       else
  22.         bb.clear(i);
  23.     System.out.println("byte value: " + bt);
  24.     printBitSet(bb);
  26.     short st = (short)rand.nextInt();
  27.     BitSet bs = new BitSet();
  28.     for(int i = 15; i >= 0; i--)
  29.       if(((1 << i) &  st) != 0)
  30.         bs.set(i);
  31.       else
  32.         bs.clear(i);
  33.     System.out.println("short value: " + st);
  34.     printBitSet(bs);
  36.     int it = rand.nextInt();
  37.     BitSet bi = new BitSet();
  38.     for(int i = 31; i >= 0; i--)
  39.       if(((1 << i) &  it) != 0)
  40.         bi.set(i);
  41.       else
  42.         bi.clear(i);
  43.     System.out.println("int value: " + it);
  44.     printBitSet(bi);
  46.     // Test bitsets >= 64 bits:
  47.     BitSet b127 = new BitSet();
  48.     b127.set(127);
  49.     System.out.println("set bit 127: " + b127);
  50.     BitSet b255 = new BitSet(65);
  51.     b255.set(255);
  52.     System.out.println("set bit 255: " + b255);
  53.     BitSet b1023 = new BitSet(512);
  54.     b1023.set(1023);
  55.     b1023.set(1024);
  56.     System.out.println("set bit 1023: " + b1023);
  57.   }
  58. }
  59. /* Output:
  60. byte value: -107
  61. bits: {0, 2, 4, 7}
  62. bit pattern: 101010010000000000000000000000000000000000
  63. 0000000000000000000000
  64. short value: 1302
  65. bits: {1, 2, 4, 8, 10}
  66. bit pattern: 011010001010000000000000000000000000000000
  67. 0000000000000000000000
  68. int value: -2014573909
  69. bits: {0, 1, 3, 5, 7, 9, 11, 18, 19, 21, 22, 23, 24,
  70. 25, 26, 31}
  71. bit pattern: 110101010101000000110111111000010000000000
  72. 0000000000000000000000
  73. set bit 127: {127}
  74. set bit 255: {255}
  75. set bit 1023: {1023, 1024}
  76. */

随机数生成器用于创建随机 byte ， short 和 int ，并且每个都在 BitSet 中转换为相应的位模式。这样可以正常工作，因为 BitSet 是64位，所以这些都不会导致它的大小增加，然后创建更大的 BitSet 。 请注意， BitSet 会根据需要进行扩展。

对于可以命名的固定标志集， EnumSet （参见第二十二章：枚举章节）通常比 BitSet 更好，因为 EnumSet 允许操作名称而不是数字位位置，从而可以减少错误。 EnumSet 还可以防止意外地添加新的标记位置，这可能会导致一些严重的，难以发现的错误。使用 BitSet 而不是 EnumSet 的唯一原因是，不知道在运行时需要多少标志，或者为标志分配名称是不合理的，或者需要 BitSet 中的一个特殊操作（请参阅 BitSet 和 EnumSet 的 JDK 文档）。

本章小结

集合可以说是编程语言中最常用的工具。有些语言（例如Python）甚至将基本集合组件（列表，映射和集合）作为内置函数包含在其中。

正如在第十二章：集合章节中看到的那样，可以使用集合执行许多非常有用的操作，而不需要太多努力。但是，在某些时候，为了正确地使用它们而不得不更多地了解集合，特别是，必须充分了解散列操作以编写自己的 hashCode() 方法（并且必须知道何时需要），并且你必须充分了解各种集合实现，以根据你的需求选择合适的集合。本附录涵盖了这些概念，并讨论了有关集合库的其他有用详细信息。你现在应该已经准备好在日常编程任务中使用 Java 集合了。

集合库的设计很困难（大多数库设计问题都是如此）。在 C++ 中，集合类涵盖了许多不同类的基础。这比之前可用的 C++ 集合类更好，但它没有很好地转换为 Java 。在另一个极端，我看到了一个由单个类“collection”组成的集合库，它同时充当线性序列和关联数组。 Java 集合库试图在功能和复杂性之间取得平衡。结果在某些地方看起来有点奇怪。与早期 Java 库中的一些决策不同，这些奇怪的不是事故，而是在基于复杂性的权衡下而仔细考虑的决策。

[^1]: java.util 中的 Map 使用 Map 的 getKey() 和 getValue() 执行批量复制，因此这是有效的。如果自定义 Map 只是复制整个 Map.Entry ，那么这种方法就会出现问题。

[^2]: 虽然当我用这种方式描述它的时候听起来很奇怪而且好像没什么用处，但在第十九章 类型信息章节中已经看到过，这种动态行为也可以非常强大有用。

[^3]: 如果这些加速仍然无法满足性能需求，则可以通过编写自己的 Map 并将其自定义为特定类型来进一步加速表查找，以避免因向 对象 转换而导致的延迟。为了达到更高的性能水平，速度爱好者可以使用 Donald Knuth 的《计算机程序设计艺术（第3卷）：排序与查找》（第二版），将溢出桶列表（overflow bucket lists）替换为具有两个额外优势的阵列：它们可以针对磁盘存储进行优化，并且它们可以节省大部分创建和回收个别记录（individual records）的时间。