傑哥教你面試之一百問系列:java集合

集合是我們在java中經常會用到的東西，熟悉了集合我們就熟悉了java。當面試官在Java面試中涉及到Java集合的問題時，通常會涉及到集合的概念、型別、常見操作、效能等方面的內容。

1. 什麼是Java集合？請簡要介紹一下集合框架。

回答：
Java集合是用於儲存、管理和操作一組物件的類和介面的集合。集合框架提供了多種不同型別的集合實現，以滿足不同的需求，包括列表、集合、對映等。集合框架位於java.util包下，它提供了一組介面和類，用於儲存和操作物件，使得資料處理更加方便和高效。

2. Java集合框架主要分為哪幾種型別？

回答：
Java集合框架主要分為以下三種型別：

• List（列表）： 有序集合，允許重複元素。常見實現類有ArrayList、LinkedList等。
• Set（集合）： 無序集合，不允許重複元素。常見實現類有HashSet、TreeSet等。
• Map（對映）： 鍵值對對映，每個鍵只能對應一個值。常見實現類有HashMap、TreeMap等。

3. 什麼是迭代器（Iterator）？它的作用是什麼？

回答：
迭代器是集合框架中的一個介面，用於遍歷集合中的元素。它提供了一種統一的方式來訪問集合中的元素，而不需要關心集合的具體實現。透過迭代器，可以按順序逐個訪問集合中的元素，而不需要暴露集合內部的結構。

程式碼示例：

List<String> list = new ArrayList<>();
list.add("Apple");
list.add("Banana");
list.add("Orange");

Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    String fruit = iterator.next();
    System.out.println(fruit);
}

4. ArrayList和LinkedList有什麼區別？它們何時適用？

回答：

• ArrayList： 基於動態陣列實現，適用於隨機訪問和讀取操作較多的場景。插入和刪除元素需要移動元素位置，因此在頻繁的插入和刪除操作時效率相對較低。
• LinkedList： 基於雙向連結串列實現，適用於頻繁的插入和刪除操作，因為在連結串列中插入和刪除元素只需要修改相鄰節點的指標，效率較高。但隨機訪問較慢。

選擇哪種集合取決於具體的使用場景和操作頻率。

5. HashMap和HashTable有什麼區別？

回答：

• HashMap： 允許使用null鍵和null值，不是執行緒安全的（非同步），在大多數情況下效能較好。
• HashTable： 不允許使用null鍵和null值，是執行緒安全的（同步），效能相對較差。

由於HashTable的同步效能開銷較大，一般在單執行緒環境下使用HashMap，而在多執行緒環境下可以使用ConcurrentHashMap來替代HashTable。

6. 什麼是ConcurrentModificationException？它是如何引起的，如何避免？

回答：
ConcurrentModificationException是在使用迭代器遍歷集合時，如果在遍歷過程中修改了集合的結構（如增加或刪除元素），就會丟擲的異常。這是因為迭代器在遍歷過程中會使用一個計數器來檢測集合是否被修改。

避免這個異常的常見方法是使用迭代器的刪除方法來進行元素的刪除，而不是直接在集合上使用刪除操作。

程式碼示例：

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);

Iterator<Integer> iterator = numbers.iterator();
while (iterator.hasNext()) {
    Integer number = iterator.next();
    if (number == 2) {
        iterator.remove(); // 正確的刪除方式，不會丟擲ConcurrentModificationException
    }
}

7. 什麼是equals()和hashCode()方法？為什麼它們在集合中很重要？

回答：

• equals()： 是Object類中定義的方法，用於比較兩個物件是否相等。在集合中，比如HashSet和HashMap，用於判斷兩個元素是否相等。
• hashCode()： 也是Object類中定義的方法，返回物件的雜湊碼值。在集合中，比如HashMap，用於確定物件在集合中的儲存位置。

在使用集合框架中的HashSet和HashMap等需要根據元素的相等性進行查詢和儲存的容器中，正確實現equals()和hashCode()方法是非常重要的，以確保元素的一致性和正確性。

8. 什麼是Comparable和Comparator介面？

回答：

• Comparable介面： 定義在物件上的自然排序方式，使物件可以與其他物件進行比較。實現了Comparable介面的類可以使用compareTo()方法來實現比較邏輯。
• Comparator介面： 是一個用於比較兩個物件的定製排序介面，可以在不修改物件類的情況下實現多種不同的比較邏輯。

實現了

Comparable介面的類可以直接使用Collections.sort()進行排序，而使用Comparator介面可以在需要的地方提供定製的比較邏輯。

程式碼示例：

class Person implements Comparable<Person> {
    private String name;
    private int age;

    // Constructors, getters, setters

    @Override
    public int compareTo(Person otherPerson) {
        return Integer.compare(this.age, otherPerson.age);
    }
}

List<Person> people = new ArrayList<>();
// Add people to the list
Collections.sort(people); // 使用自然排序

// 使用Comparator進行定製排序
Comparator<Person> ageComparator = Comparator.comparingInt(Person::getAge);
Collections.sort(people, ageComparator);

9. 什麼是同步集合（Synchronized Collections）？它們在什麼情況下使用？

回答：
同步集合是指對於多執行緒環境，提供了執行緒安全的操作的集合類。在併發訪問的情況下，普通的集合類可能會引發執行緒安全問題，因此Java提供了諸如Collections.synchronizedList、Collections.synchronizedSet等方法來返回同步版本的集合。

程式碼示例：

List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Set<Integer> synchronizedSet = Collections.synchronizedSet(new HashSet<>());

// 在多執行緒環境中使用同步集合

10. 什麼是併發集合（Concurrent Collections）？它們的作用是什麼？

回答：
併發集合是指專為多執行緒併發操作而設計的集合類，能夠提供更高的併發效能。java.util.concurrent包提供了許多併發集合，如ConcurrentHashMap、ConcurrentSkipListMap、ConcurrentLinkedQueue等。

這些集合透過使用不同的併發控制策略，允許多個執行緒同時訪問和修改集合，而不需要顯式的同步控制。這對於高併發的應用場景非常有用。

程式碼示例：

ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("one", 1);
concurrentMap.put("two", 2);

// 在多執行緒環境中安全地進行操作

11. 什麼是Fail-Fast和Fail-Safe迭代器？

回答：

• Fail-Fast迭代器： 當集合在迭代過程中被修改（增加、刪除元素）時，會立即丟擲ConcurrentModificationException，以避免在併發環境中出現潛在的問題。這種迭代器主要用於在迭代過程中檢測集合的非法修改。
• Fail-Safe迭代器： 迭代器會複製原始集合的資料，在迭代過程中允許對集合進行修改，但不會影響正在進行的迭代過程。這種迭代器適用於需要在迭代過程中允許修改集合的情況，如併發環境。

Java集合框架中的CopyOnWriteArrayList和CopyOnWriteArraySet就是Fail-Safe集合的例子。

12. Java集合框架中的主要介面有哪些？

回答：
主要的集合介面包括：

• Collection：表示一組物件，包括List和Set。
• List：有序集合，可以包含重複元素，常見的實現有ArrayList、LinkedList等。
• Set：無序集合，不允許重複元素，常見的實現有HashSet、TreeSet等。
• Map：鍵值對對映，每個鍵只能對應一個值，常見的實現有HashMap、TreeMap等。

13. 什麼是WeakHashMap？

回答：
WeakHashMap是java.util包中提供的一種特殊的Map實現，它的鍵是弱引用（WeakReference）。這意味著當某個鍵不再被程式中的其他部分引用時，它可以被垃圾回收器回收，即使這個鍵在WeakHashMap中。

WeakHashMap常用於需要將物件與相關的附加資訊關聯起來，但又不想妨礙垃圾回收過程的場景。典型的應用是快取和資源管理。

程式碼示例：

WeakHashMap<Key, Value> weakMap = new WeakHashMap<>();
Key key = new Key(); // 僅被weakMap引用
Value value = new Value(); // 與key相關的值
weakMap.put(key, value);

// 當key不再被其他部分引用，垃圾回收時，weakMap中的對應條目會被移除

14. 什麼是HashCode和Equals的約定？

回答：
hashCode和equals方法在集合框架中有一些約定：

• 如果兩個物件透過equals方法相等，它們的hashCode值必須相等。
• 如果兩個物件的hashCode值相等，它們不一定透過equals方法相等，但是在HashMap等集合中，相等的雜湊碼會增加連結串列的長度，影響效能，因此最好保持一致性。

為了符合這些約定，當你在自定義類中重寫equals方法時，也應該重寫hashCode方法，以保證物件在集合中的正確行為和效能。

程式碼示例：

class Student {
    private int id;
    private String name;

    // Constructors, getters, setters

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id && Objects.equals(name, student.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }
}

15. 什麼是IdentityHashMap？

回答：
IdentityHashMap是一個特殊的Map實現，它在比較鍵和值的相等性時使用的是引用的身份（記憶體地址）而不是透過equals方法。這使得它可以區分不同引用指向的相同內容的情況。

IdentityHashMap適用於需要基於物件引用身份而不是內容來儲存鍵值對的場景。

程式碼示例：

IdentityHashMap<String, Integer> identityMap = new IdentityHashMap<>();
String key1 = new String("key");
String key2 = new String("key");
identityMap.put(key1, 1);
identityMap.put(key2, 2);

System.out.println(identityMap.size()); // 輸出 2，因為兩個鍵在引用上不同

16. 什麼是EnumSet和EnumMap？

回答：

• EnumSet： 是java.util包中的一個專門為列舉型別設計的集合類。它基於位向量實現，適用於列舉型別的快速集合操作，非常高效。
• EnumMap： 也是java.util包中的一個專門為列舉型別設計的Map實現。它的鍵必須是同一個列舉類的列舉值，提供了非常高效的列舉鍵值對儲存和查詢操作。

這兩個類在處理列舉型別資料時非常有用，因為它們針對列舉型別做了特殊的最佳化。

程式碼示例：

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

EnumSet<Day> weekdays = EnumSet.range(Day.MONDAY, Day.FRIDAY);
EnumMap<Day, String> activities = new EnumMap<>(Day.class);
activities.put(Day.MONDAY, "Working");
activities.put(Day.FRIDAY, "Partying");

17. 什麼是Collections類的實用方法？

回答：
java.util.Collections類提供了一系列靜態實用方法，用於操作集合。這些方法包括排序、查詢、替換等，它們可以用於各種不同的集合實現。

程式碼示例：

List<Integer> numbers = new ArrayList<>();
numbers.add(5);
numbers.add(2);
numbers.add(8);

Collections.sort(numbers); // 對列表進行排序

int index = Collections.binarySearch(numbers, 5); // 二分查詢

18. 什麼是Collections類的不可修改檢視（Unmodifiable Views）？

回答：
Collections.unmodifiableXXX()方法可以返回一個不可修改的檢視，用於對現有集合進行封裝，使其不允許進行修改操作。這在需要將集合傳遞給其他部分，但又不希望這些部分能夠修改集合時非常有用。

程式碼示例：

List<String> originalList = new ArrayList<>();
originalList.add("Apple");
originalList.add("Banana");

List<String> unmodifiableList = Collections.unmodifiableList(originalList);

// 試圖修改unmodifiableList會引發UnsupportedOperationException

19. 什麼是Collections類的同步方法？

回答：
java.util.Collections類提供了一些靜態方法，用於返回執行緒安全的集合。這些方法在需要保證多執行緒環境下集合的安全訪問時非常有用。常見的同步方法包括Collections.synchronizedList、Collections.synchronizedSet和Collections.synchronizedMap等。

程式碼示例：

List<String> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Set<Integer> synchronizedSet = Collections.synchronizedSet(new HashSet<>());
Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<>());

20. 什麼是ListIterator？

回答：
ListIterator是List介面提供的一個特殊迭代器，除了具有普通迭代器的功能外，它還可以在迭代過程中向列表中插入、刪除元素。ListIterator允許雙向遍歷（向前和向後），並提供了更多的操作。

程式碼示例：

List<String> names = new ArrayList<>();
names.add("Alice");
names.add("Bob");
names.add("Charlie");

ListIterator<String> iterator = names.listIterator();
while (iterator.hasNext()) {
    String name = iterator.next();
    if (name.equals("Bob")) {
        iterator.add("David"); // 在Bob之後插入David
    }
}

21. 什麼是Collections類的reverse()和shuffle()方法？

回答：
Collections.reverse()方法用於將一個List中的元素進行反轉排序。Collections.shuffle()方法用於隨機打亂一個List中的元素順序。這兩個方法在處理列表中的元素順序時非常有用。

程式碼示例：

List<Integer> numbers = new ArrayList<>();
numbers.add(1);
numbers.add(2);
numbers.add(3);
numbers.add(4);

Collections.reverse(numbers); // 反轉列表

Collections.shuffle(numbers); // 隨機打亂列表

22. 什麼是PriorityQueue？

回答：
PriorityQueue是一個基於優先順序堆（heap）的佇列實現，它可以根據元素的優先順序進行排序。預設情況下，PriorityQueue是自然順序排序，但你也可以透過提供自定義的Comparator來指定元素的排序方式。

程式碼示例：

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.add(5);
priorityQueue.add(2);
priorityQueue.add(8);

int highestPriority = priorityQueue.poll(); // 彈出具有最高優先順序的元素

23. 什麼是BitSet？

回答：
BitSet是一個用於儲存位資訊的集合類，它的每個元素只有兩個可能的值：0和1。BitSet經常被用於處理位運算和標誌位操作，例如在點陣圖索引、壓縮演演算法等領域。

程式碼示例：

BitSet bitSet = new BitSet(8); // 建立一個有8位的BitSet

bitSet.set(2); // 設定第2位為1
bitSet.set(5); // 設定第5位為1

boolean isSet = bitSet.get(2); // 獲取第2位的值（true）

24. 什麼是Arrays類的asList()方法？

回答：
Arrays.asList()方法是java.util.Arrays類提供的一個實用方法，用於將陣列轉換為List。注意，這個方法返回的List是固定大小的，不支援新增和刪除操作，但可以使用set()方法修改元素。

程式碼示例：

String[] array = {"Apple", "Banana", "Orange"};
List<String> list = Arrays.asList(array);

list.set(1, "Pear"); // 修改陣列中的元素

25. 什麼是LinkedHashMap？

回答：
LinkedHashMap是java.util包中的一個實現了Map介面的類，它繼承自HashMap，但是額外維護了鍵值對的插入順序。這意味著當你遍歷LinkedHashMap時，鍵值對的順序與插入順序一致。

LinkedHashMap適用於需要保持元素插入順序的場景，同時也可以透過訪問順序模式來遍歷元素。

程式碼示例：

LinkedHashMap<String, Integer> linkedHashMap = new LinkedHashMap<>();
linkedHashMap.put("one", 1);
linkedHashMap.put("two", 2);
linkedHashMap.put("three", 3);

// 遍歷順序與插入順序一致
for (Map.Entry<String, Integer> entry : linkedHashMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

26. 什麼是Stream API？

回答：
Stream API是Java 8引入的一個功能強大的功能，它提供了一種處理集合資料的函式語言程式設計方法。Stream允許你對集合中的元素進行一系列的操作，如過濾、對映、排序、歸約等，以函式式的風格進行處理。

Stream API能夠使程式碼更加簡潔、清晰，並且在一些情況下可以提供更高效的並行處理。

程式碼示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.stream()
                .filter(n -> n % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();

27. 什麼是Lambda表示式？它在集合操作中的作用是什麼？

回答：
Lambda表示式是Java 8引入的一種輕量級函式語言程式設計特性，它允許你以更緊湊的方式傳遞匿名函式。在集合操作中，Lambda表示式可以用於傳遞操作的邏輯，如過濾、對映、排序等，使程式碼更加簡潔、易讀。

Lambda表示式能夠幫助你將操作的焦點從“如何實現”轉移到“要實現什麼”，從而提高程式碼的可讀性和可維護性。

程式碼示例：

List<String> names = Arrays.asList("Alice", "Bob", "Charlie");

names.stream()
     .filter(name -> name.length() <= 4)
     .forEach(System.out::println);

28. 什麼是Collectors類？

回答：
java.util.stream.Collectors是Stream API中的一個工具類，提供了一組靜態方法，用於將Stream中的元素收集到集合或其他資料結構中。它在Stream的最終操作中非常有用，可以用於彙總、分組、分割槽等操作。

Collectors類的方法可以幫助你以更簡潔的方式對Stream的結果進行收集。

程式碼示例：

List<Person> people = // ... 獲得一組人員資料

Map<String, List<Person>> peopleByCity = people.stream()
    .collect(Collectors.groupingBy(Person::getCity));

29. 什麼是並行Stream？

回答：
並行Stream是指在多個執行緒中同時處理Stream中的元素的方式。Java 8引入的Stream API允許你透過呼叫parallel()方法將一個普通Stream轉換為並行Stream。這在處理大量資料時，可以提高處理效率。

然而，要注意在使用並行Stream時，需要考慮到執行緒安全問題，以及在某些情況下可能的效能開銷。

程式碼示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

int sum = numbers.parallelStream()
                .filter(n -> n % 2 == 0)
                .mapToInt(Integer::intValue)
                .sum();

30. 什麼是ConcurrentSkipListMap？

回答：
ConcurrentSkipListMap是一個java.util.concurrent包中提供的併發對映實現，它是基於跳錶（Skip List）資料結構的。ConcurrentSkipListMap提供了高併發效能，適用於多執行緒環境下的併發訪問。

跳錶是一種有序資料結構，類似於平衡樹，但具有更好的併發效能。

程式碼示例：

ConcurrentSkipListMap<String, Integer> skipListMap = new ConcurrentSkipListMap<>();
skipListMap.put("one", 1);
skipListMap.put("two", 2);

int value = skipListMap.get("two");

31. 什麼是EnumSet和EnumMap？

回答：

• EnumSet： 是java.util包中為列舉型別設計的高效集合類，它基於位向量實現，適用於對列舉型別的元素進行儲存和操作。因為列舉的取值是有限的，所以使用位向量可以提供高效的儲存和訪問。
• EnumMap： 是java.util包中為列舉型別設計的高效對映類，它的鍵必須是同一個列舉類的列舉值。EnumMap在內部使用陣列來儲存對映的鍵值對，因此具有高效的訪問效能。

這兩個類都是針對列舉型別資料的特定最佳化，可以提供高效的儲存和操作。

程式碼示例：

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

EnumSet<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);

EnumMap<Day, String> activities = new EnumMap<>(Day.class);
activities.put(Day.MONDAY, "Working");
activities.put(Day.FRIDAY, "Partying");

32. 什麼是WeakReference、SoftReference和PhantomReference？

回答：
這些是Java中的引用型別，用於在記憶體管理中控制物件的垃圾回收：

• WeakReference（弱引用）： 弱引用物件在垃圾回收時只有在記憶體不足時才會被回收。常用於構建快取，當快取中的物件不再被強引用時，可以被垃圾回收。
• SoftReference（軟引用）： 軟引用物件在記憶體不足時會被回收。用於實現快取，但比弱引用更“持久”，有利於利用剩餘記憶體。
• PhantomReference（虛引用）： 虛引用用於在物件被垃圾回收之前獲得通知。虛引用物件在任何時候都可能被垃圾回收。

這些引用型別在一些特殊場景下，如記憶體敏感的快取和資源釋放，非常有用。

33. 什麼是Comparator介面的自然排序和定製排序？

回答：
Comparator介面定義了用於物件排序的比較器。它有兩種排序方式：

• 自然排序（Natural Ordering）： 對於實現了Comparable介面的類，可以透過自然順序進行排序。例如，整數和字串已經實現了Comparable介面，所以它們可以使用自然排序進行排序。
• 定製排序（Custom Ordering）： 當你需要對沒有實現Comparable介面的類進行排序時，可以透過提供自定義的Comparator來指定排序規則。這樣你可以在不修改類本身的情況下定義多種排序方式。

程式碼示例：

class Student {
    private String name;
    private int age;

    // Constructors, getters, setters
}

List<Student> students = // ... 獲得一組學生資料

// 自然排序
Collections.sort(students);

// 定製排序
Comparator<Student> ageComparator = Comparator.comparingInt(Student::getAge);
Collections.sort(students, ageComparator);

34. 什麼是IdentityHashMap？

回答：
IdentityHashMap是java.util包中提供的一個實現Map介面的類，它使用引用的身份（記憶體地址）而不是equals方法來判斷鍵的相等性。這意味著只有當兩個鍵的引用是同一個物件時，它們才被認為是相等的。

這在某些情況下很有用，例如需要精確地根據物件的身份進行鍵值儲存。

程式碼示例：

IdentityHashMap<String, Integer> identityMap = new IdentityHashMap<>();
String key1 = new String("key");
String key2 = new String("key");
identityMap.put(key1, 1);

// key2不等於key1，所以不會被視為相等的鍵
identityMap.get(key2); // 輸出null

35. 什麼是Collections類的checkedXXX方法？

回答：
java.util.Collections類提供了一系列用於建立型別安全（typed-safe）的集合的方法，它們稱為checkedXXX方法。這些方法可以幫助你確保向集合中新增的元素型別是

正確的，從而在執行時避免型別轉換錯誤。

程式碼示例：

List<String> stringList = new ArrayList<>();
List checkedList = Collections.checkedList(stringList, String.class);

// 現在只能新增String型別的元素到checkedList

36. 什麼是CopyOnWriteArrayList和CopyOnWriteArraySet？

回答：
CopyOnWriteArrayList和CopyOnWriteArraySet都是併發集合，屬於java.util.concurrent包。它們透過使用一種特殊的寫時複製（Copy-On-Write）策略來實現高併發的讀操作。

• CopyOnWriteArrayList： 是執行緒安全的List實現，適用於讀多寫少的場景。在修改操作（新增、刪除元素）時，它會複製一份原始陣列，並進行修改，從而保證讀取操作的執行緒安全性。
• CopyOnWriteArraySet： 是執行緒安全的Set實現，它基於CopyOnWriteArrayList實現，擁有類似的特性。

這些集合對於讀多寫少的情況提供了一種高效的解決方案。

程式碼示例：

CopyOnWriteArrayList<String> copyOnWriteList = new CopyOnWriteArrayList<>();
CopyOnWriteArraySet<Integer> copyOnWriteSet = new CopyOnWriteArraySet<>();

// 在多執行緒環境中使用copyOnWriteList和copyOnWriteSet

37. 什麼是Collections類的disjoint()方法？

回答：
Collections.disjoint()方法是用於檢查兩個集合是否沒有共同元素的。如果兩個集合沒有交集，即它們之間沒有共同的元素，該方法返回true，否則返回false。

程式碼示例：

List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(4, 5, 6);

boolean noCommonElements = Collections.disjoint(list1, list2);
System.out.println(noCommonElements); // 輸出 true

38. 什麼是Collections類的reverseOrder()方法？

回答：
Collections.reverseOrder()方法返回一個逆序的比較器，用於對元素進行逆序排序。通常與Collections.sort()方法一起使用，可以實現對集合中元素的逆序排列。

程式碼示例：

List<Integer> numbers = Arrays.asList(5, 2, 8, 1);

Collections.sort(numbers, Collections.reverseOrder());

39. 什麼是Collections類的singletonXXX()方法？

回答：
Collections.singletonXXX()方法用於建立只包含一個元素的不可修改集合。這種集合在內部實現上更加緊湊，適用於只包含單個元素的場景。

程式碼示例：

Set<String> singletonSet = Collections.singleton("Hello");

List<Integer> singletonList = Collections.singletonList(42);

40. 什麼是Collections類的emptyXXX()方法？

回答：
Collections.emptyXXX()方法用於建立一個空的不可修改集合，如emptyList()、emptySet()和emptyMap()。這些集合在不需要儲存元素時很有用，可以避免建立不必要的例項。

程式碼示例：

List<String> emptyList = Collections.emptyList();
Set<Integer> emptySet = Collections.emptySet();
Map<String, Integer> emptyMap = Collections.emptyMap();

41. 什麼是ConcurrentHashMap？

回答：
ConcurrentHashMap是java.util.concurrent包中提供的併發雜湊對映實現，它允許多個執行緒同時讀取和寫入對映，而不會引發併發衝突。ConcurrentHashMap的設計使得它在高併發情況下表現優異。

它透過將對映分成一些段（Segments），每個段相當於一個小的雜湊表，從而實現了併發的寫操作。不同的段可以由不同的執行緒同時操作，從而減少了鎖的爭用。

程式碼示例：

ConcurrentHashMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put("one", 1);
concurrentMap.put("two", 2);

int value = concurrentMap.get("one");

42. 什麼是Spliterator？

回答：
Spliterator是Java 8引入的一個用於遍歷和拆分元素序列的介面，它是“分割迭代器”（Split Iterator）的縮寫。Spliterator可以用於支援並行迭代操作，將資料來源拆分為多個部分，以便多個執行緒並行處理。

Spliterator被廣泛應用於支援新的Stream API和並行流。

程式碼示例：

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

Spliterator<Integer> spliterator = numbers.spliterator();

// 並行迭代
spliterator.forEachRemaining(System.out::println);

43. 什麼是Set介面的特點？

回答：
Set介面是java.util包中的一個介面，表示不允許包含重複元素的集合。Set的主要特點包括：

• 不允許重複元素：集合中的元素是唯一的，不能有重複。
• 無序性：Set通常不保證元素的特定順序。實際的順序可能會隨著時間的推移發生變化。
• 沒有索引：Set不支援透過索引訪問元素，因為它沒有定義特定的順序。

常用的Set實現包括HashSet、LinkedHashSet和TreeSet。

44. 什麼是NavigableSet介面？

回答：
NavigableSet介面是java.util包中的一個擴充套件自SortedSet介面的子介面，它提供了一系列用於導航和搜尋元素的方法。NavigableSet的主要特點包括：

• 提供了用於搜尋最小和最大元素的方法。
• 提供了用於搜尋給定元素的方法，或搜尋大於或小於給定元素的元素。
• 可以獲取前一個和後一個元素。

TreeSet是NavigableSet介面的一個常見實現。

45. 什麼是BlockingQueue？

回答：
BlockingQueue是java.util.concurrent包中的一個介面，它是一個支援執行緒安全的生產者-消費者模式的佇列。BlockingQueue提供了阻塞操作，當佇列為空或滿時，讀取和寫入操作會被阻塞，直到滿足條件。

BlockingQueue在多執行緒應用中很有用，用於實現併發的生產者和消費者執行緒。

程式碼示例：

BlockingQueue<Integer> blockingQueue = new LinkedBlockingQueue<>();

// 生產者執行緒
blockingQueue.put(1);

// 消費者執行緒
int value = blockingQueue.take();

46. 什麼是Deque介面？

回答：
Deque介面（Double Ended Queue的縮寫）是java.util包中的一個介面，代表雙向佇列。Deque允許你在佇列的兩端插入和刪除元素，可以作為佇列和棧的混合使用。

Deque提供了一系列用於在佇列的頭部和尾部進行操作的方法，如addFirst()、addLast()、removeFirst()、removeLast()等。

程式碼示例：

Deque<String> deque = new LinkedList<>();
deque.addLast("Alice");
deque.addLast("Bob");
deque.addFirst("Charlie");

String first = deque.removeFirst(); // 輸出 Charlie

47. 什麼是BlockingDeque介面？

回答：
BlockingDeque介面是java.util.concurrent包中的一個介面，是Deque的擴充套件，它結合了Deque的雙向佇列特性和BlockingQueue的阻塞特性。BlockingDeque允許在佇列兩端插入和刪除元素，並且在佇列為空或滿時提供阻塞操作。

BlockingDeque適用於需要高併發的雙向佇列場景，例如生產者-消費者模式。

48. 什麼是EnumMap和EnumSet？

回答：

• EnumMap： EnumMap是java.util包中的一個實現了Map介面的類，專門用於列舉型別作為鍵的情況。它的鍵必須來自同一個列舉類，這使得它在具有列舉鍵的情況下效率更高。
• EnumSet： EnumSet是java.util包中的一個實現了Set介面的類，專門用於列舉型別的集合。EnumSet中的元素必須來自同一個列舉類，它使用位向量來實現高效的儲存和操作。

這兩個類都是針對列舉型別資料的高效實現。

程式碼示例：

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

EnumMap<Day, String> activities = new EnumMap<>(Day.class);
activities.put(Day.MONDAY, "Working");
activities.put(Day.FRIDAY, "Partying");

EnumSet<Day> weekend = EnumSet.of(Day.SATURDAY, Day.SUNDAY);

49. 什麼是IdentityHashMap？

回答：
IdentityHashMap是java.util包中的一個實現了Map介面的類，與普通的HashMap不同，它使用引用的身份（記憶體地址）而不是equals方法來判斷鍵的相等性。這意味著只有當兩個鍵的引用是同一個物件時，它們才被認為是相等的。

IdentityHashMap在需要精確比較物件引用時很有用，它不考慮物件的內容，只關注物件的記憶體地址。

程式碼示例：

IdentityHashMap<String, Integer> identityMap = new IdentityHashMap<>();
String key1 = new String("key");
String key2 = new String("key");
identityMap.put(key1, 1);

// key2不等於key1，所以不會被視為相等的鍵
identityMap.get(key2); // 輸出 null

50. 什麼是Queue介面？

回答：
Queue介面是java.util包中的一個介面，代表佇列資料結構。佇列通常按照“先進先出”（FIFO，First-In-First-Out）的原則，也就是最早進入佇列的元素最先被移出。

Queue介面提供了一系列用於在佇列的尾部新增元素、在佇列的頭部移除元素的方法，以及一些用於檢查佇列狀態的方法。

常用的Queue實現包括LinkedList、ArrayDeque和PriorityQueue。

51. 什麼是Map介面的特點？

回答：
Map介面是java.util包中的一個介面，用於表示鍵值對的對映。Map的主要特點包括：

• 鍵唯一：每個鍵只能對應一個值，不允許重複的鍵。
• 可以透過鍵來獲取值：透過鍵可以找到對應的值。
• 無序性：Map通常不保證元素的特定順序。實際的順序可能會隨著時間的推移發生變化。

Map介面的常見實現包括HashMap、LinkedHashMap、TreeMap等。

52. 什麼是NavigableMap介面？

回答：
NavigableMap介面是java.util包中的一個擴充套件自SortedMap介面的子介面，它提供了一系列用於導航和搜尋鍵的方法。NavigableMap的主要特點包括：

• 提供了用於搜尋最小和最大鍵的方法。
• 提供了用於搜尋給定鍵的方法，或搜尋大於或小於給定鍵的鍵。
• 可以獲取前一個和後一個鍵。

TreeMap是NavigableMap介面的一個常見實現。

53. 什麼是EnumMap？

回答：
EnumMap是java.util包中的一個實現了Map介面的類，專門用於列舉型別作為鍵的情況。EnumMap的鍵必須來自同一個列舉類，這使得它在具有列舉鍵的情況下效率更高。

EnumMap內部使用陣列來表示

對映，因此具有較高的訪問速度。

程式碼示例：

enum Day {
    MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}

EnumMap<Day, String> activities = new EnumMap<>(Day.class);
activities.put(Day.MONDAY, "Working");
activities.put(Day.FRIDAY, "Partying");

54. 什麼是WeakHashMap？

回答：
WeakHashMap是java.util包中的一個實現了Map介面的類，它是一種特殊的Map，其中的鍵是“弱鍵”（Weak Key）。這意味著如果某個鍵不再被其他部分引用，它會被垃圾回收器回收，即使它還存在於WeakHashMap中。

WeakHashMap常用於在沒有其他強引用時臨時儲存物件的對映。

程式碼示例：

WeakHashMap<Key, Value> weakHashMap = new WeakHashMap<>();
Key key = new Key();
Value value = new Value();
weakHashMap.put(key, value);

// 當key不再被強引用時，它會被垃圾回收，對應的對映也會被移除

55. 什麼是PriorityQueue？

回答：
PriorityQueue是java.util包中的一個實現了Queue介面的類，它是一個優先順序佇列，根據元素的優先順序進行排列。預設情況下，PriorityQueue使用元素的自然順序或提供的比較器來確定元素的優先順序。

PriorityQueue的實現基於堆資料結構，它保證了佇列中最高優先順序的元素總是位於佇列的頭部。

程式碼示例：

PriorityQueue<Integer> priorityQueue = new PriorityQueue<>();
priorityQueue.add(5);
priorityQueue.add(3);
priorityQueue.add(7);

int highestPriority = priorityQueue.poll(); // 輸出 3

56. 什麼是Hashtable？

回答：
Hashtable是java.util包中的一個古老的實現了Map介面的類，它提供了一種使用鍵-值對儲存資料的方式。Hashtable在功能上與HashMap類似，但是它是執行緒安全的，即多個執行緒可以同時操作一個Hashtable例項而不會引發併發問題。

然而，由於它是基於同步方法實現的，因此在多執行緒環境下效能相對較差。在Java 5之後，更推薦使用ConcurrentHashMap來獲得更好的併發效能。

程式碼示例：

Hashtable<String, Integer> hashtable = new Hashtable<>();
hashtable.put("one", 1);
hashtable.put("two", 2);

int value = hashtable.get("one");

57. 什麼是WeakReference、SoftReference和PhantomReference？

回答：
這些是Java中用於記憶體管理的引用型別：

• WeakReference（弱引用）： 弱引用物件只有在垃圾回收時，當沒有強引用指向它時，才會被回收。常用於實現快取，以便在記憶體不足時釋放一些不再需要的物件。
• SoftReference（軟引用）： 軟引用物件在記憶體不足時可能會被回收，但只有在記憶體真正緊張的情況下才會被回收。用於構建記憶體敏感的快取記憶體。
• PhantomReference（虛引用）： 虛引用物件在任何時候都可能被垃圾回收。虛引用主要用於跟蹤物件是否已經從記憶體中刪除，但不能透過虛引用來獲取物件本身。

這些引用型別有助於在特定場景下進行精細的記憶體管理。

58. 什麼是Arrays類的asList()方法？

回答：
Arrays.asList()方法是java.util包中的一個靜態方法，它可以將傳遞的一組元素轉換為一個固定大小的List。這個List是一個檢視，不支援增加或刪除元素，但可以使用set方法修改元素的值。

程式碼示例：

List<String> list = Arrays.asList("one", "two", "three");
list.set(0, "modified"); // 修改第一個元素為 "modified"

59. 什麼是Collections類的unmodifiableXXX()方法？

回答：
Collections.unmodifiableXXX()方法用於建立不可修改的集合，其中XXX可以是List、Set或Map。這些方法返回一個不可修改的檢視，即原始集合不能被修改，但可以讀取。

程式碼示例：

List<String> originalList = new ArrayList<>();
originalList.add("one");
originalList.add("two");

List<String> unmodifiableList = Collections.unmodifiableList(originalList);

// 嘗試修改unmodifiableList會引發 UnsupportedOperationException

60. 什麼是Collections類的singletonXXX()方法？

回答：
Collections.singletonXXX()方法用於建立只包含一個元素的不可修改集合，其中XXX可以是Set、List或Map。這種集合在內部實現上更加緊湊，適用於只包含單個元素的場景。

程式碼示例：

Set<String> singletonSet = Collections.singleton("Hello");
List<Integer> singletonList = Collections.singletonList(42);

61. 什麼是Collections類的checkedXXX()方法？

回答：
Collections.checkedXXX()方法用於建立型別安全的集合，其中XXX可以是List、Set或Map。這些方法可以幫助你確保向集合中新增的元素型別是正確的，從而在執行時避免型別轉換錯誤。

程式碼示例：

List<String> stringList = new ArrayList<>();
List checkedList = Collections.checkedList(stringList, String.class);

// 現在只能新增String型別的元素到checkedList

62. 什麼是Arrays類的sort()方法？

回答：
Arrays.sort()方法是java.util包中的一個靜態方法，用於對陣列元素進行排序。它提供了多個過載方法，可以根據不同的排序規則進行排序。對於基本型別陣列，使用Arrays.sort()可以實現快速的排序。

程式碼示例：

int[] numbers = {5, 2, 8, 1};
Arrays.sort(numbers); // 對陣列進行排序

63. 什麼是Arrays類的binarySearch()方法？

回答：
Arrays.binarySearch()方法是java.util包中的一個靜態方法，用於在已排序的陣列中執行二分查詢。如果陣列包含目標元素，則返回該元素的索引；否則返回一個負數值，表示目標元素應該插入的位置。

程式碼示例：

int[] numbers = {1, 2, 3, 5, 8};
int index = Arrays.binarySearch(numbers, 5); // 返回 3

64. 什麼是Arrays類的copyOf()方法？

回答：
Arrays.copyOf()方法是java.util包中的一個靜態方法，用於建立一個新陣列，包含指定陣列的一部分或全部元素。新陣列的長度可以比原陣列長或短。

程式碼示例：

int[] original = {1, 2, 3, 4, 5};
int[] copy = Arrays.copyOf(original, 3); // 新陣列為 {1, 2, 3}

65. 什麼是Arrays類的equals()方法？

回答：
Arrays.equals()方法是java.util包中的一個靜態方法，用於比較兩個陣列是否相等。陣列中的元素會逐個比較，如果陣列長度相等且對應位置的元素也相等，則返回true，否則返回false。

程式碼示例：

int[] array1 = {1, 2, 3};
int[] array2 = {1, 2, 3};

boolean areEqual = Arrays.equals(array1, array2); // 返回 true

66. 什麼是Arrays類的hashCode()方法？

回答：
Arrays.hashCode()方法是java.util包中的一個靜態方法，用於計算陣列的雜湊碼。陣列的雜湊碼是基於陣列的內容計算的，如果兩個陣列內容相同，它們的雜湊碼也會相同。

程式碼示例：

int[] array = {1, 2, 3};
int hashCode = Arrays.hashCode(array); // 返回陣列的雜湊碼

67. 什麼是Arrays類的toString()方法？

回答：
Arrays.toString()方法是java.util包中的一個靜態方法，用於將陣列轉換為字串表示形式。該方法會按照陣列的順序將元素轉換為字串，並用逗號分隔，然後放在方括號內。

程式碼示例：

int[] array = {1, 2, 3};
String arrayString = Arrays.toString(array); // 返回 "[1, 2, 3]"

68. 什麼是Arrays類的deepEquals()方法？

回答：
Arrays.deepEquals()方法是java.util包中的一個靜態方法，用於比較多維陣列的內容是否相等。它會遞迴比較陣列的元素，如果多維陣列的內容完全相同，則返回true，否則返回false。

程式碼示例：

int[][] array1 = {{1, 2}, {3, 4}};
int[][] array2 = {{1, 2}, {3, 4}};

boolean areEqual = Arrays.deepEquals(array1, array2); // 返回 true

69. 什麼是System.arraycopy()方法？

回答：
System.arraycopy()方法是Java中的一個靜態方法，用於在陣列之間進行元素的複製。它可以將一個陣列的一部分或全部元素複製到另一個陣列中，並且可以在目標陣列的指定位置開始放置複製的元素。

程式碼示例：

int[] source = {1, 2, 3, 4, 5};
int[] target = new int[5];

System.arraycopy(source, 1, target, 2, 3); // 將 source[1] 到 source[3] 複製到 target[2] 到 target[4]

70. 什麼是Arrays類的fill()方法？

回答：
Arrays.fill()方法是java.util包中的一個靜態方法，用於將指定的值填充到陣列的所有元素中。這可以在初始化陣列或清除陣列內容時很有用。

程式碼示例：

int[] array = new int[5];
Arrays.fill(array, 42); // 將陣列的所有元素填充為 42

71. 什麼是Arrays類的stream()方法？

回答：
Arrays.stream()方法是java.util包中的一個靜態方法，用於將陣列轉換為一個流（Stream）物件。透過將陣列轉換為流，你可以利用流的各種操作來處理陣列中的元素。

程式碼示例：

int[] array = {1, 2, 3, 4, 5};
IntStream stream = Arrays.stream(array); // 將陣列轉換為 IntStream 流

72. 什麼是Arrays類的parallelSort()方法？

回答：
Arrays.parallelSort()方法是java.util包中的一個靜態方法，用於對陣列元素進行並行排序。與普通的Arrays.sort()方法相比，parallelSort()方法會在多個執行緒上並行執行排序操作，從而加快排序速度。

程式碼示例：

int[] array = {5, 2, 8, 1, 3};
Arrays.parallelSort(array); // 並行排序陣列

73. 什麼是Arrays類的mismatch()方法？

回答：
Arrays.mismatch()方法是java.util包中的一個靜態方法，用於查詢兩個陣列中第一個不匹配的元素的索引。如果陣列完全相等，則返回-1。

程式碼示例：

int[] array1 = {1, 2, 3, 4, 5};
int[] array2 = {1, 2, 3, 6, 7};

int mismatchIndex = Arrays.mismatch(array1, array2); // 返回 3

74. 什麼是Collections類的frequency()方法？

回答：
Collections.frequency()方法是java.util包中的一個靜態方法，用於計算集合中指定元素出現的次數。

程式碼示例：

List<String> list = Arrays.asList("apple", "banana", "apple", "orange");
int frequency = Collections.frequency(list, "apple"); // 返回 2

75. 什麼是Collections類的disjoint()方法？

回答：
Collections.disjoint()方法是java.util包中的一個靜態方法，用於判斷兩個集合是否沒有共同的元素。如果兩個集合沒有共同的元素，則返回true，否則返回false。

程式碼示例：

List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(4, 5, 6);

boolean areDisjoint = Collections.disjoint(list1, list2); // 返回 true

76. 什麼是Collections類的reverse()方法？

回答：
Collections.reverse()方法是java.util包中的一個靜態方法，用於反轉集合中的元素順序。

程式碼示例：

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.reverse(list); // 將集合元素的順序反轉

77. 什麼是Collections類的shuffle()方法？

回答：
Collections.shuffle()方法是java.util包中的一個靜態方法，用於隨機打亂集合中的元素順序。

程式碼示例：

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.shuffle(list); // 隨機打亂集合元素的順序

78. 什麼是Collections類的min()和max()方法？

回答：
Collections.min()和Collections.max()方法是java.util包中的兩個靜態方法，用於找到集合中的最小和最大元素。

程式碼示例：

List<Integer> list = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
int minValue = Collections.min(list); // 返回 1
int maxValue = Collections.max(list); // 返回 9

79. 什麼是Collections類的addAll()方法？

回答：
Collections.addAll()方法是java.util包中的一個靜態方法，用於將一組元素新增到集合中。這個方法接受一個目標集合和一組元素作為引數，並將這些元素新增到目標集合中。

程式碼示例：

List<String> list = new ArrayList<>();
Collections.addAll(list, "apple", "banana", "orange");

80. 什麼是Collections類的synchronizedXXX()方法？

回答：
Collections.synchronizedXXX()方法是java.util包中的一系列靜態方法，用於建立執行緒安全的集合，其中XXX可以是List、Set或Map。這些方法返回一個包裝後的集合，可以在多執行緒環境下安全使用。

程式碼示例：

List<String> list = new ArrayList<>();
List<String> synchronizedList = Collections.synchronizedList(list);

// synchronizedList 可以在多執行緒環境下安全操作

81. 什麼是Arrays類的spliterator()方法？

回答：
Arrays.spliterator()方法是java.util包中的一個靜態方法，用於建立陣列的分割迭代器（Spliterator）。分割迭代器可以將陣列的元素劃分為多個部分，以便進行並行處理。

程式碼示例：

int[] array = {1, 2, 3, 4, 5};
Spliterator.OfInt spliterator = Arrays.spliterator(array);

// 使用 spliterator 進行並行處理

82. 什麼是Collections類的newSetFromMap()方法？

回答：
Collections.newSetFromMap()方法是java.util包中的一個靜態方法，用於從現有的Map例項建立一個Set例項。這個Set例項的元素將與Map的鍵關聯，因此只能包含唯一的元素。

程式碼示例：

Map<String, Boolean> map = new HashMap<>();
Set<String> set = Collections.newSetFromMap(map);

// set 中的元素將與 map 的鍵關聯

83. 什麼是Collections類的checkedMap()方法？

回答：
Collections.checkedMap()方法是java.util包中的一個靜態方法，用於建立一個型別安全的Map，其中的鍵和值都需要符合特定的型別。這可以幫助你在編譯時捕獲型別錯誤。

程式碼示例：

Map<String, Integer> map = new HashMap<>();
Map checkedMap = Collections.checkedMap(map, String.class, Integer.class);

// 只能將符合型別的鍵值對新增到 checkedMap

84. 什麼是Collections類的emptyXXX()方法？

回答：
Collections.emptyXXX()方法是java.util包中的一系列靜態方法，用於建立空的集合，其中XXX可以是List、Set或Map。

程式碼示例：

List<String> emptyList = Collections.emptyList();
Set<Integer> emptySet = Collections.emptySet();
Map<String, Integer> emptyMap = Collections.emptyMap();

85. 什麼是Collections類的singletonMap()方法？

回答：
Collections.singletonMap()方法是java.util包中的一個靜態方法，用於建立只包含一個鍵值對的不可修改Map例項。

程式碼示例：

Map<String, Integer> singletonMap = Collections.singletonMap("key", 42);

86. 什麼是Collections類的nCopies()方法？

回答：
Collections.nCopies()方法是java.util包中的一個靜態方法，用於建立一個包含指定元素重複多次的不可修改的List例項。

程式碼示例：

List<String> copies = Collections.nCopies(3, "Hello");
// 建立一個包含 3 個 "Hello" 的 List

87. 什麼是Collections類的reverseOrder()方法？

回答：
Collections.reverseOrder()方法是java.util包中的一個靜態方法，用於獲取一個比較器，該比較器按照元素的逆自然順序進行比較。

程式碼示例：

List<Integer> list = Arrays.asList(5, 2, 8, 1, 3);
Collections.sort(list, Collections.reverseOrder()); // 按逆序排序

88. 什麼是Collections類的rotate()方法？

回答：
Collections.rotate()方法是java.util包中的一個靜態方法，用於迴圈移動集合中的元素。這個方法接受一個集合和一個距離引數，將集合中的元素迴圈移動指定的距離。

程式碼示例：

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.rotate(list, 2); // 迴圈移動 2 個位置

89. 什麼是Collections類的replaceAll()方法？

回答：
Collections.replaceAll()方法是java.util包中的一個靜態方法，用於將集合中的所有舊值替換為新值。

程式碼示例：

List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "apple", "orange"));
Collections.replaceAll(list, "apple", "fruit");

// 將所有 "apple" 替換為 "fruit"

90. 什麼是Collections類的singleton()方法？

回答：
Collections.singleton()方法是java.util包中的一個靜態方法，用於建立一個只包含一個元素的不可修改Set例項。

程式碼示例：

Set<String> singletonSet = Collections.singleton("Hello");

91. 什麼是Collections類的enumeration()方法？

回答：
Collections.enumeration()方法是java.util包中的一個靜態方法，用於將指定集合轉換為一個列舉（Enumeration）物件。列舉是一種舊的迭代方式，通常在遺留程式碼中使用。

程式碼示例：

List<String> list = Arrays.asList("apple", "banana", "orange");
Enumeration<String> enumeration = Collections.enumeration(list);

92. 什麼是Collections類的indexOfSubList()和lastIndexOfSubList()方法？

回答：
Collections.indexOfSubList()和Collections.lastIndexOfSubList()方法是java.util包中的兩個靜態方法，用於在一個集合中查詢另一個集合子列表的第一個和最後一個索引。

程式碼示例：

List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 2, 3);
List<Integer> sublist = Arrays.asList(2, 3);

int firstIndex = Collections.indexOfSubList(list, sublist); // 返回 1
int lastIndex = Collections.lastIndexOfSubList(list, sublist); // 返回 5

93. 什麼是Collections類的newXXX()方法？

回答：
Collections.newXXX()方法是java.util包中的一系列靜態方法，用於建立可修改的空集合，其中XXX可以是List、Set或Map。

程式碼示例：

List<String> newList = Collections.newLinkedList();
Set<Integer> newSet = Collections.newSetFromMap(new HashMap<>());
Map<String, Integer> newMap = Collections.newHashMap();

94. 什麼是Collections類的checkedSortedMap()方法？

回答：
Collections.checkedSortedMap()方法是java.util包中的一個靜態方法，用於建立一個型別安全的有序Map，其中的鍵和值都需要符合特定的型別。這可以幫助你在編譯時捕獲型別錯誤。

程式碼示例：

SortedMap<String, Integer> sortedMap = new TreeMap<>();
SortedMap checkedSortedMap = Collections.checkedSortedMap(sortedMap, String.class, Integer.class);

// 只能將符合型別的鍵值對新增到 checkedSortedMap

95. 什麼是Collections類的emptyIterator()和emptyListIterator()方法？

回答：
Collections.emptyIterator()和Collections.emptyListIterator()方法是java.util包中的兩個靜態方法，用於建立空的迭代器（Iterator）和空的列表迭代器（ListIterator）例項。

程式碼示例：

Iterator<String> emptyIterator = Collections.emptyIterator();
ListIterator<Integer> emptyListIterator = Collections.emptyListIterator();

96. 什麼是Collections類的fill()方法？

回答：
Collections.fill()方法是java.util包中的一個靜態方法，用於將指定的值填充到列表中的所有元素。

程式碼示例：

List<Integer> list = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5));
Collections.fill(list, 0); // 將列表的所有元素填充為 0

97. 什麼是Collections類的unmodifiableCollection()方法？

回答：
Collections.unmodifiableCollection()方法是java.util包中的一個靜態方法，用於建立不可修改的集合檢視，其中的元素與原始集合相同，但不能進行增加、刪除或修改操作。

程式碼示例：

List<String> list = new ArrayList<>(Arrays.asList("apple", "banana", "orange"));
Collection<String> unmodifiableCollection = Collections.unmodifiableCollection(list);

// 嘗試修改 unmodifiableCollection 會引發 UnsupportedOperationException

98. 什麼是Collections類的disjoint()方法？

回答：
Collections.disjoint()方法是java.util包中的一個靜態方法，用於判斷兩個集合是否沒有共同的元素。如果兩個集合沒有共同的元素，則返回true，否則返回false。

程式碼示例：

List<Integer> list1 = Arrays.asList(1, 2, 3);
List<Integer> list2 = Arrays.asList(4, 5, 6);

boolean areDisjoint = Collections.disjoint(list1, list2); // 返回 true

99. 什麼是Collections類的singleton()方法？

回答：
Collections.singleton()方法是java.util包中的一個靜態方法，用於建立只包含一個元素的不可修改Set例項。

程式碼示例：

Set<String> singletonSet = Collections.singleton("Hello");

100. 什麼是Collections類的synchronizedCollection()方法？

回答：
Collections.synchronizedCollection()方法是java.util包中的一個靜態方法，用於建立一個執行緒安全的集合，其中的元素與原始集合相同，但可以在多執行緒環境中安全操作。

程式碼示例：

List<String> list = new ArrayList<>();
Collection<String> synchronizedCollection = Collections.synchronizedCollection(list);

// synchronizedCollection 可以在多執行緒環境下安全操作