Java 集合 · ZetCode 中文系列教程

# Java 集合原文：http://zetcode.com/lang/java/collections/ 在本章中，我們將處理集合。 Java 提供了用于數據存儲和檢索的專門類。在前面的章節中，我們描述了數組。集合是對數組的增強。 Java 5 引入了通用集合。通用集合更靈活，它們是使用數據的首選方式。通用集合可增強代碼重用性，類型安全性和性能。集合框架中有許多類。其中一些，例如`ArrayBlockingQueue`或`IdentityHashMap`，是在特定情況下使用的專用容器。我們將提到一些通用容器。 ## Java `ArrayList` `ArrayList`是可調整大小的動態數組。它提供對元素的隨機訪問。隨機訪問意味著我們可以在恒定時間內獲取任何元素。 `ArrayList`隨著添加數據而自動擴展。與`array`不同，`ArrayList`可以保存多種數據類型的數據。 `ArrayList`中的元素通過整數索引訪問。索引從零開始。在`ArrayList`的末尾元素的索引以及插入和刪除需要固定的時間。在動態數組的中間插入或刪除元素的成本更高。它要求將所有后面的元素轉移過來。該過程需要線性時間。您可以在 [Java `ArrayList`教程](/articles/javaarraylist/)中找到有關 Java `ArrayList`的更多信息。 `ArrayListSimpleEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.Arrays; import java.util.List; public class ArrayListSimpleEx { public static void main(String[] args) { List<String> distros = new ArrayList<String>(); distros.add("Manjaro"); distros.add("Xubuntu"); distros.add("Fedora"); distros.add("elementary"); for (String distro : distros) { System.out.println(distro); } List<String> capitals = Arrays.asList("Prague", "Bratislava", "Warsaw", "Budapest", "Washington"); for (String capital : capitals) { System.out.println(capital); } } } ``` 該示例創建兩個列表并打印其內容。 ```java import java.util.ArrayList; import java.util.Arrays; import java.util.List; ``` 必要的類位于`java.util`包中。 ```java List<String> distros = new ArrayList<String>(); ``` 創建一個新的`ArrayList`。該列表可以包含字符串。列表可以包含的類型在菱形括號之間給出。 ```java distros.add("Manjaro"); distros.add("Xubuntu"); distros.add("Fedora"); distros.add("elementary"); ``` 使用`add()`方法，我們將四個條目添加到列表中。 ```java for (String distro : distros) { System.out.println(distro); } ``` 我們使用`for-each`循環遍歷列表。 ```java List<String> capitals = Arrays.asList("Prague", "Bratislava", "Warsaw", "Budapest", "Washington"); ``` 我們可以使用`Arrays.asList()`方法來初始化列表。 `ArrayList`可以包含多種數據類型。 `ArrayListMultipleEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; class Base { } public class ArrayListMultipleEx { public static void main(String[] args) { List da = new ArrayList(); da.add("Java"); da.add(3.5); da.add(55); da.add(new Base()); for (Object el : da) { System.out.println(el); } } } ``` 該示例創建一個`ArrayList`集合。它包含各種數據類型。 ```java import java.util.ArrayList; ``` 從`java.util`包中，導入`ArrayList`類。 ```java List da = new ArrayList(); ``` 創建一個`ArrayList`集合。 ```java da.add("Java"); da.add(3.5); da.add(55); da.add(new Base()); ``` 我們使用`add()`方法向數組添加四個元素。 ```java for (Object el : da) { System.out.println(el); } ``` 我們遍歷數組列表，并將其元素打印到控制臺。 ```java $ java com.zetcode.ArrayListMultipleEx Java 3.5 55 com.zetcode.Base@1535ac ``` 在這里，我們可以看到`com.zetcode.ArrayListMultipleEx`的輸出。下一個示例將介紹一些`ArrayList`方法。 `ArrayListMethodsEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.Iterator; import java.util.List; public class ArrayListMethodsEx { public static void main(String[] args) { List<String> names = new ArrayList<String>(); names.add("Jane"); names.add("Thomas"); names.add("Robin"); names.add("David"); names.add("Becky"); System.out.println(names); names.set(1, "Tom"); System.out.println(names); System.out.format("There are %d elements in the collection%n", names.size()); names.remove(1); System.out.format("There are %d elements in the collection%n", names.size()); System.out.println(names.get(3)); System.out.println("************"); Iterator<String> it = names.iterator(); while (it.hasNext()) { System.out.println(it.next()); } } } ``` 在示例中，我們介紹了`ArrayList`容器的一些有用方法。 ```java List<String> names = new ArrayList<String>(); ``` 將創建一個通用的`ArrayList`。我們將元素的數據類型限制為`String`數據類型。這是通過在`<>`字符之間寫入數據類型來完成的。 ```java names.add("Jane"); names.add("Thomas"); names.add("Robin"); names.add("David"); names.add("Becky"); ``` 我們將五個字符串元素添加到數組列表中。 ```java System.out.println(names); ``` 將容器作為`println()`方法的參數將調用容器的`toString()`方法。它將集合轉換為字符串。 ```java names.set(1, "Tom"); ``` `set()`方法用給定元素替換指定索引處的元素。 `"Tomas"`替換為`"Tom"`。 ```java System.out.format("There are %d elements in the collection%n", names.size()); ``` `ArrayList`的大小由`size()`方法確定。 ```java names.remove(1); ``` 我們從集合中刪除第二個元素。參數是集合的索引。 ```java System.out.println(names.get(3)); ``` `get()`方法檢索容器的第四個元素。 ```java Iterator<String> it = names.iterator(); while (it.hasNext()) { System.out.println(it.next()); } ``` 我們使用`Iterator`對象瀏覽容器。 `hasNext()`方法檢查是否還剩下一些元素，`next()`方法檢索迭代中的下一個元素。 ```java $ java com.zetcode.ArrayListMethodsEx [Jane, Thomas, Robin, David, Becky] [Jane, Tom, Robin, David, Becky] There are 5 elements in the collection There are 4 elements in the collection Becky ************ Jane Robin David Becky ``` 這是`com.zetcode.ArrayListMethodsEx`示例的示例輸出。在下一個示例中，我們繼續介紹`ArrayList`的方法。 `ArrayListMethodsEx2.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class ArrayListMethodsEx2 { public static void main(String[] args) { List<String> names = new ArrayList<>(); names.add("Jane"); names.add(0, "Thomas"); names.add(1, "Robin"); names.add("David"); names.add("Becky"); System.out.println(names); System.out.println(names.isEmpty()); System.out.println(names.contains("Jane")); System.out.println(names.contains("Robert")); System.out.println(names.indexOf("Jane")); System.out.println(names.subList(1, 4)); names.clear(); System.out.println(names.isEmpty()); System.out.println(names); } } ``` 我們展示了可以用于`ArrayList`的另外五種方法。 ```java List<String> names = new ArrayList<>(); ``` 從 Java 7 開始，可以在對通用類的構造器調用中省略顯式類型參數。編譯器為通用類的構造器推斷參數類型。 ```java names.add("Jane"); names.add(0, "Thomas"); ``` `add()`方法將新項目添加到容器。重載的第二個選項指定將放置項目的索引。最后，`"Thomas"`字符串位于`"Jane"`字符串之前。 ```java System.out.println(names.isEmpty()); ``` `empty()`方法檢查容器是否為空。該行返回`false`。目前，容器中有五個字符串。 ```java System.out.println(names.contains("Jane")); ``` `contains()`方法確定容器中是否存在指定的元素。 ```java System.out.println(names.indexOf("Jane")); ``` `indexOf()`方法返回指定元素首次出現的索引，如果列表不包含該元素，則返回 -1。 ```java System.out.println(names.subList(1, 4)); ``` `subList()`方法返回指定索引之間的列表切片。切片中包括第一個索引處的元素，不包括第二個索引處的元素。 ```java names.clear(); ``` `clear()`方法從容器中刪除所有元素。 ```java $ java com.zetcode.ArrayListMethodsEx2 [Thomas, Robin, Jane, David, Becky] false true false 2 [Robin, Jane, David] true [] ``` 這是`com.zetcode.ArrayListMethodsEx2`的輸出。我們可以將其他列表添加到列表中。 `ListOfLists.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class ListOfLists { public static void main(String[] args) { List<Integer> l1 = new ArrayList<>(); l1.add(1); l1.add(2); l1.add(3); List<Integer> l2 = new ArrayList<>(); l2.add(4); l2.add(5); l2.add(6); List<Integer> l3 = new ArrayList<>(); l3.add(7); l3.add(8); l3.add(9); List<List<Integer>> nums = new ArrayList<>(); nums.add(l1); nums.add(l2); nums.add(l3); System.out.println(nums); for (List<Integer> list : nums) { for (Integer n : list) { System.out.printf("%d ", n); } System.out.println(); } } } ``` 該示例創建三個整數列表。以后，這些列表將添加到另一個第四列表中。 ```java List<Integer> l1 = new ArrayList<>(); l1.add(1); l1.add(2); l1.add(3); ``` 將創建一個整數列表。 ```java List<List> nums = new ArrayList<>(); nums.add(l1); nums.add(l2); nums.add(l3); ``` 創建列表列表。 ```java for (List<Integer> list : nums) { for (Integer n : list) { System.out.printf("%d ", n); } System.out.println(); } ``` 我們使用兩個 for 循環遍歷所有元素。 ```java $ java com.zetcode.ListOfListsEx [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 1 2 3 4 5 6 7 8 9 ``` 這是`com.zetcode.ListOfListsEx`的輸出。 ## Java 遍歷列表在下一節中，我們將展示如何遍歷 Java 中的列表。 `TraversingList.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; public class TraversingList { public static void main(String[] args) { List<String> martialArts = new ArrayList<>(); martialArts.add("Silat"); martialArts.add("Wing chun"); martialArts.add("Karate"); martialArts.add("Judo"); martialArts.add("Aikido"); for (int i=0; i < martialArts.size(); i++) { System.out.printf("%s ", martialArts.get(i)); } System.out.print("\n"); for (String e: martialArts) { System.out.printf("%s ", e); } System.out.print("\n"); martialArts.forEach((e) -> System.out.printf("%s ", e)); System.out.print("\n"); } } ``` 我們有一個字符串列表；我們展示了三種遍歷 Java 列表的方法。 ```java for (int i=0; i < martialArts.size(); i++) { System.out.printf("%s ", martialArts.get(i)); } ``` 使用傳統的`for`循環遍歷列表。 ```java for (String e: martialArts) { System.out.printf("%s ", e); } ``` 在這里，列表通過`for-each`循環進行遍歷。 ```java martialArts.forEach((e) -> System.out.printf("%s ", e)); ``` 第三種方法使用`forEach`方法和 lambda 表達式。 ```java $ java com.zetcode.TraversingList Silat Wing chun Karate Judo Aikido Silat Wing chun Karate Judo Aikido Silat Wing chun Karate Judo Aikido ``` 這是輸出。 ## Java `LinkedList` `LinkedList`是 Java 中的雙鏈表。元素的插入和移除需要固定的時間。鏈表提供對元素的順序訪問，這意味著抓取元素需要花費線性時間。由于鏈表需要額外的存儲空間以供參考，因此對于諸如字符之類的小型數據項列表來說，它們是不切實際的。將`ArrayList`與`LinkedList`進行比較時，`ArrayList`用于訪問特定元素的速度很快，但是添加到任一端的速度可能很慢，尤其是在中間刪除時，速度特別慢。 `LinkedList`快速添加和刪除元素，但是訪問特定元素卻很慢。 `LinkedListEx.java` ```java package com.zetcode; import java.util.LinkedList; public class LinkedListEx { public static void main(String[] args) { LinkedList<Integer> nums = new LinkedList<>(); nums.add(5); nums.add(10); nums.add(13); nums.add(12); nums.add(15); nums.add(23); System.out.println(nums); nums.removeFirst(); nums.removeLast(); nums.addFirst(17); nums.addLast(77); System.out.println(nums); } } ``` 這是一個`LinkedList`示例，其中包含一些方法。 ```java LinkedList<Integer> nums = new LinkedList<>(); ``` 該`LinkedList`具有整數。 ```java nums.add(5); nums.add(10); ``` 我們將數字添加到列表中。自動裝箱將原始`int`類型包裝到`Integer`對象。 ```java nums.removeFirst(); nums.removeLast(); ``` 這兩種方法從容器中刪除第一個和最后一個元素。 ```java nums.addFirst(17); nums.addLast(77); ``` 我們在列表的開頭和結尾添加一個元素。 ```java $ java com.zetcode.LinkedListEx [5, 10, 13, 12, 15, 23] [17, 10, 13, 12, 15, 77] ``` 鏈表中包含的元素將兩次打印到控制臺。 ## Java `HashMap` `HashMap`是一個存儲鍵/值對的容器。每個鍵與一個值關聯。鍵必須是唯一的。這種容器類型在其他編程語言中稱為關聯數組或字典。 `HashMap`占用更多內存，因為對于每個值還有一個鍵。刪除和插入操作需要固定的時間。 `HashMap`可以存儲空值。 `HashMapEx.java` ```java package com.zetcode; import java.util.HashMap; import java.util.Map; import java.util.Set; public class HashMapEx { public static void main(String[] args) { Map<String, String> domains = new HashMap<>(); domains.put("de", "Germany"); domains.put("sk", "Slovakia"); domains.put("us", "United States"); domains.put("ru", "Russia"); domains.put("hu", "Hungary"); domains.put("pl", "Poland"); System.out.println(domains.get("pl")); for (String item : domains.values()) { System.out.println(item); } Set keys = domains.keySet(); System.out.println(keys); } } ``` 我們有一個`HashMap`，將域名映射到其國家名稱。 ```java Map<String, String> domains = new HashMap<>(); ``` 我們用字符串鍵和值創建一個`HashMap`。 ```java domains.put("de", "Germany"); domains.put("sk", "Slovakia"); domains.put("us", "United States"); ... ``` 我們將一些數據放入`HashMap`。第一個字符串是鍵。第二是值。 ```java System.out.println(domains.get("pl")); ``` 我們通過其鍵檢索特定值。對于檢索操作，我們使用`get`方法。 ```java for (String item : domains.values()) { System.out.println(item); } ``` `values()`方法返回域`HashMap`中包含的值的集合。我們使用`for`循環遍歷這些值，并將它們打印到控制臺。 ```java Set keys = domains.keySet(); ``` `keySet()`方法返回`Set`集合中`HashMap`的鍵。 `Set`是唯一元素的集合。 ```java System.out.println(keys); ``` 該集合的元素將打印到控制臺。 ```java $ java com.zetcode.HashMapEx Poland Germany Slovakia Hungary Poland United States Russia [de, sk, hu, pl, us, ru] ``` 這是示例的輸出。在下一個示例中，我們創建一個自定義顏色對象的映射。 `HashMapEx2.java` ```java package com.zetcode; import java.util.HashMap; import java.util.Map; class Colour { private String name; private String code; public Colour(String name, String code) { this.name = name; this.code = code; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getCode() { return code; } public void setCode(String code) { this.code = code; } } public class HashMapEx2 { public static void main(String[] args) { Map<Integer, Colour> cols = new HashMap<>(); cols.put(1, new Colour("AliceBlue", "#f0f8ff")); cols.put(2, new Colour("GreenYellow", "#adff2f")); cols.put(3, new Colour("IndianRed", "#cd5c5c")); cols.put(4, new Colour("khaki", "#f0e68c")); System.out.printf("The size of the map is %d%n", cols.size()); int key = 4; if (cols.containsKey(key)) { System.out.printf("The map contains key %d%n", key); } cols.remove(1); System.out.printf("The size of the map is %d%n", cols.size()); cols.replace(3, new Colour("VioletRed", "#d02090")); Colour col = cols.get(3); System.out.printf("Colour name:%s colour code:%s %n", col.getName(), col.getCode()); } } ``` 在此示例中，我們提出以下三種方法：`containsKey()`，`remove()`和`replace()`。 ```java class Colour { private String name; private String code; public Colour(String name, String code) { this.name = name; this.code = code; } ... } ``` 自定義顏色對象包含顏色名稱和顏色代碼屬性。 ```java Map<Integer, Colour> cols = new HashMap<>(); ``` 創建一個映射，其中鍵是整數，值是`Colour`對象。 ```java if (cols.containsKey(key)) { System.out.printf("The map contains key %d%n", key); } ``` `containsKey()`方法確定鍵是否在映射中。 ```java cols.remove(1); ``` `remove()`方法從映射中刪除具有指定鍵的對象。 ```java cols.replace(3, new Colour("VioletRed", "#d02090")); ``` `replace()`方法替換指定鍵的條目。 ```java $ java com.zetcode.HashMapEx2 The size of the map is 4 The map contains key 4 The size of the map is 3 Colour name:VioletRed colour code:#d02090 ``` This is the output of the example. ## 單詞計數在下面的示例中，我們計算文本文件中單詞的出現次數。我們使用`HashMap`存儲單詞及其出現。 `thermopylae.txt` ```java The Battle of Thermopylae was fought between an alliance of Greek city-states, led by King Leonidas of Sparta, and the Persian Empire of Xerxes I over the course of three days, during the second Persian invasion of Greece. It took place simultaneously with the naval battle at Artemisium, in August or September 480 BC, at the narrow coastal pass of Thermopylae. The Persian invasion was a delayed response to the defeat of the first Persian invasion of Greece, which had been ended by the Athenian victory at the Battle of Marathon in 490 BC. Xerxes had amassed a huge army and navy, and set out to conquer all of Greece. ``` 我們從`thermopylae.txt`文件中讀取內容。該文件位于`src/resources/`目錄中。 `CountingWordsEx.java` ```java package com.zetcode; import java.io.IOException; import java.nio.charset.StandardCharsets; import java.nio.file.Files; import java.nio.file.Paths; import java.util.HashMap; import java.util.List; import java.util.Map; public class CountingWordsEx { public static void main(String[] args) throws IOException { Map<String, Integer> wordCount = new HashMap<>(); String fileName = "src/resources/thermopylae.txt"; List<String> lines = Files.readAllLines(Paths.get(fileName), StandardCharsets.UTF_8); for (String line : lines) { String[] words = line.split("\\s+"); for (String word : words) { if (word.endsWith(".") || word.endsWith(",")) { word = word.substring(0, word.length()-1); } if (wordCount.containsKey(word)) { wordCount.put(word, wordCount.get(word) + 1); } else { wordCount.put(word, 1); } } } for (String key : wordCount.keySet()) { System.out.println(key + ": " + wordCount.get(key)); } } } ``` 該示例從文件中讀取文本，將句子拆分為單詞并計算其在文本中的出現頻率。 ```java Map<String, Integer> wordCount = new HashMap<>(); ``` `wordCount`是一個映射，其中鍵是單詞，頻率是整數。 ```java String fileName = "src/resources/thermopylae.txt"; List<String> lines = Files.readAllLines(Paths.get(fileName), StandardCharsets.UTF_8); ``` 我們使用`Files.readAllLines()`方法一次讀取所有內容。 ```java for (String line : lines) { String[] words = line.split("\\s+"); ... ``` 我們遍歷這些行，將它們分成單詞；單詞之間用空格隔開。 ```java if (word.endsWith(".") || word.endsWith(",")) { word = word.substring(0, word.length()-1); } ``` 我們刪除尾隨點和逗號。 ```java if (wordCount.containsKey(word)) { wordCount.put(word, wordCount.get(word) + 1); } else { wordCount.put(word, 1); } ``` 如果單詞已經在映射中，則增加其頻率；否則，我們將其插入映射并將其頻率設置為 1。 ```java for (String key : wordCount.keySet()) { System.out.println(key + ": " + wordCount.get(key)); } ``` 我們遍歷映射并打印其鍵/值對。 ```java $ java com.zetcode.CountingWordsEx been: 1 Athenian: 1 alliance: 1 navy: 1 fought: 1 led: 1 delayed: 1 had: 2 during: 1 three: 1 second: 1 Greece: 3 Leonidas: 1 ... ``` 這是示例的部分輸出。 ## Java `TreeMap` `TreeMap`是根據其鍵的自然順序排序的映射。盡管`HashMap`更省時，但`TreeMap`更節省空間。 `TreeMapEx.java` ```java package com.zetcode; import java.util.TreeMap; public class TreeMapEx { public static void main(String[] args) { TreeMap<String, String> domains = new TreeMap<>(); domains.put("de", "Germany"); domains.put("sk", "Slovakia"); domains.put("us", "United States"); domains.put("ru", "Russia"); domains.put("hu", "Hungary"); domains.put("pl", "Poland"); System.out.println(domains); System.out.println(domains.descendingMap()); } } ``` 在示例中，我們創建一個`TreeMap`并將域名及其國家/地區放入其中。 ```java TreeMap<String, String> domains = new TreeMap<>(); ``` 創建了`TreeMap`。 ```java System.out.println(domains); ``` 這將按鍵/值的自然排序順序（升序）打印。 ```java System.out.println(domains.descendingMap()); ``` `descendingMap()`方法返回此映射中包含的映射的逆序視圖。 ```java $ java com.zetcode.TreeMapEx {de=Germany, hu=Hungary, pl=Poland, ru=Russia, sk=Slovakia, us=United States} {us=United States, sk=Slovakia, ru=Russia, pl=Poland, hu=Hungary, de=Germany} ``` `com.zetcode.TreeMapEx`程序按升序和降序打印鍵值。 ## Java `HashSet` `HashSet`是一個不包含重復元素的集合。此類為基本操作（添加，刪除，包含和調整大小）提供恒定的時間性能。 `HashSet`不提供元素的排序。 `HashSetEx.java` ```java package com.zetcode; import java.util.HashSet; import java.util.Set; public class HashSetEx { public static void main(String[] args) { Set<String> brands = new HashSet<>(); brands.add("Pepsi"); brands.add("Amazon"); brands.add("Volvo"); brands.add("IBM"); brands.add("IBM"); System.out.println(brands); System.out.println(brands.isEmpty()); System.out.println(brands.contains("Volvo")); brands.remove("Volvo"); System.out.println(brands.contains("Volvo")); brands.clear(); System.out.println(brands); } } ``` 名稱下只能注冊一個品牌。因此，品牌名稱是`HashSet`的一個很好的例子。 ```java Set<String> brands = new HashSet<>(); brands.add("Pepsi"); brands.add("Amazon"); brands.add("Volvo"); brands.add("IBM"); brands.add("IBM"); ``` 我們創建一個`HashSet`并添加新元素。 IBM 品牌被添加兩次。但是，IBM 在容器中僅存在一次。 ```java System.out.println(brands); ``` 一鍵打印所有元素。 ```java System.out.println(brands.isEmpty()); ``` `isEmpty()`方法檢查容器是否為空。 ```java System.out.println(brands.contains("Volvo")); ``` 使用`contains()`方法，我們檢查品牌容器中是否存在沃爾沃品牌。該行打印`true`。 ```java brands.remove("Volvo"); System.out.println(brands.contains("Volvo")); ``` 我們從品牌容器中刪除了沃爾沃品牌。第二行打印`false`。 ```java brands.clear(); ``` `clear()`方法從集合中刪除所有元素。 ```java $ java com.zetcode.HashSetEx [IBM, Pepsi, Volvo, Amazon] false true false [] ``` 這是`com.zetcode.HashSetEx`程序的輸出。 ## Java `TreeSet` `TreeSet`是具有使用自然順序排序的元素的集合。 `TreeSet`比`HashSet`慢。 `HashSet`可以包含空值，而`TreeSet`不能包含空值。 `TreeSetEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.List; import java.util.TreeSet; public class TreeSetEx { public static void main(String[] args) { List<String> brands = new ArrayList<>(); brands.add("Pepsi"); brands.add("Amazon"); brands.add("Volvo"); brands.add("IBM"); brands.add("HP"); brands.add("Apple"); brands.add("Starbucks"); TreeSet<String> brands2 = new TreeSet<>(); brands2.addAll(brands); System.out.println(brands2); System.out.println(brands2.descendingSet()); System.out.println(brands2.first()); System.out.println(brands2.last()); System.out.println(brands2.headSet("IBM", true)); System.out.println(brands2.tailSet("IBM", false)); System.out.println(brands2.subSet("Apple", true, "Starbucks", true)); } } ``` 在此示例中，我們使用`TreeSet`。 ```java List<String> brands = new ArrayList<>(); brands.add("Pepsi"); brands.add("Amazon"); brands.add("Volvo"); brands.add("IBM"); brands.add("HP"); brands.add("Apple"); brands.add("Starbucks"); ``` 創建了各種品牌的`ArrayList`。 ```java TreeSet<String> brands2 = new TreeSet<>(); brands2.addAll(brands); ``` 借助`addAll()`方法，從`ArrayList`容器中創建了一個新的`TreeSet`。 ```java System.out.println(brands2); System.out.println(brands2.descendingSet()); ``` 容器的元素按升序和降序打印到控制臺。 ```java System.out.println(brands2.first()); System.out.println(brands2.last()); ``` 我們打印容器的第一個和最后一個元素。 ```java System.out.println(brands2.headSet("IBM", true)); ``` `headSet()`方法返回其元素小于指定元素的集合的一個切片。第二個參數控制是否包含指定的元素。 ```java System.out.println(brands2.tailSet("IBM", false)); ``` `tailSet()`方法返回其元素大于指定元素的集合的一個切片。 ```java System.out.println(brands2.subSet("Apple", true, "Starbucks", true)); ``` `subSet()`方法返回容器的一部分，其元素范圍從第一個指定元素到第二個指定元素。 ```java $ java com.zetcode.TreeSetEx [Amazon, Apple, HP, IBM, Pepsi, Starbucks, Volvo] [Volvo, Starbucks, Pepsi, IBM, HP, Apple, Amazon] Amazon Volvo [Amazon, Apple, HP, IBM] [Pepsi, Starbucks, Volvo] [Apple, HP, IBM, Pepsi, Starbucks] ``` 這是`com.zetcode.TreeSetEx`示例的輸出。 ## Java `Collections`類 `Collections`是一個工具類，提供了許多使用容器的有用方法。它僅由靜態方法組成。某些方法不適用于所有集合類型。例如，不可能在`HashSet`上使用`sort()`方法，因為此容器不支持有序元素。 `CollectionsEx.java` ```java package com.zetcode; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; public class CollectionsEx { public static void main(String[] args) { Integer[] nums = { 4, 3, 2, 4, 5, 6, 4, 2, 7, 8, 9, 0, 1 }; List<Integer> ns = new ArrayList<>(Arrays.asList(nums)); System.out.println("Default order:"); System.out.println(ns); System.out.println("Ascending order:"); Collections.sort(ns); System.out.println(ns); System.out.println("Descending order:"); Collections.reverse(ns); System.out.println(ns); System.out.println("Swapping the first and the last elements:"); Collections.swap(ns, 0, ns.size()-1); System.out.println(ns); System.out.println("Replacing all 4s with 0s:"); Collections.replaceAll(ns, 4, 0); System.out.println(ns); System.out.println("Random order:"); Collections.shuffle(ns); System.out.println(ns); System.out.println(Collections.max(ns)); System.out.println(Collections.min(ns)); } } ``` 在示例中，我們使用`Collections`類的幾種方法。 ```java Integer[] nums = { 4, 3, 2, 4, 5, 6, 4, 2, 7, 8, 9, 0, 1 }; ArrayList<Integer> ns = new ArrayList<>(Arrays.asList(nums)); ``` `ArrayList`由整數數組創建。 `Arrays`類的`asList()`方法用于將數組轉換為列表，然后將其傳遞給構造器。 ```java Collections.sort(ns); ``` `sort()`方法以升序對元素進行排序。 ```java Collections.reverse(ns); ``` `reverse()`方法反轉列表中元素的順序。 ```java Collections.swap(ns, 0, ns.size()-1); ``` `swap()`方法交換兩個元素。在我們的案例中，第一個元素與最后一個元素。 ```java Collections.replaceAll(ns, 4, 0); ``` 該行用 0 替換所有出現的數字 4。 ```java Collections.shuffle(ns); ``` `shuffle()`方法隨機重新排序容器中的元素。 ```java System.out.println(Collections.max(ns)); System.out.println(Collections.min(ns)); ``` 在這里，我們打印列表的最大值和最小值。 ```java $ java com.zetcode.CollectionsEx Default order: [4, 3, 2, 4, 5, 6, 4, 2, 7, 8, 9, 0, 1] Ascending order: [0, 1, 2, 2, 3, 4, 4, 4, 5, 6, 7, 8, 9] Descending order: [9, 8, 7, 6, 5, 4, 4, 4, 3, 2, 2, 1, 0] Swapping the first and the last elements: [0, 8, 7, 6, 5, 4, 4, 4, 3, 2, 2, 1, 9] Replacing all 4s with 0s: [0, 8, 7, 6, 5, 0, 0, 0, 3, 2, 2, 1, 9] Random order: [1, 6, 2, 8, 0, 2, 0, 9, 5, 0, 7, 3, 0] 9 0 ``` 這是`com.zetcode.CollectionsEx`程序的示例輸出。 Java 教程的這一部分專門用于 Java 集合。