JAVA Collections类主要应用API

Collections 类是 Java 集合框架（Java Collections Framework）的一部分，它位于 java.util 包中。这个类提供了对集合（Collection）操作或返回集合的视图的各种静态方法，但不能实例化 Collections 类（因为它所有的方法都是静态的）。这些静态方法主要用于操作或查询集合，而不是提供新的集合实现。下面是一些 Collections 类中最常用的 API 方法：

排序和查找

1. sort(List<T> list)：对指定列表进行排序。列表必须实现 Comparable 接口，或者提供一个 Comparator。

2. sort(List<T> list, Comparator<? super T> c)：根据指定的比较器对列表进行排序。

3. binarySearch(List<? extends Comparable<? super T>> list, T key)：使用二分查找算法在指定列表中查找指定对象的索引。列表必须是有序的。

4. binarySearch(List<? extends T> list, T key, Comparator<? super T> c)：使用二分查找算法在指定列表中查找指定对象的索引，使用提供的比较器进行排序。

   import java.util.ArrayList;  
   import java.util.Collections;  
   import java.util.List;  
     
   public class CollectionsExample {  
       public static void main(String[] args) {  
           List<String> names = new ArrayList<>();  
           names.add("Alice");  
           names.add("Bob");  
           names.add("Charlie");  
     
           // 使用自然排序  
           Collections.sort(names);  
           System.out.println(names); // 输出：[Alice, Bob, Charlie]  
     
           // 使用自定义比较器（假设我们想根据字符串长度排序）  
           Collections.sort(names, (s1, s2) -> s1.length() - s2.length());  
           System.out.println(names); // 输出可能会根据长度变化，如：[Bob, Alice, Charlie]  
       }  
   }
   
   
   
   import java.util.Arrays;  
   import java.util.Collections;  
   import java.util.List;  
     
   public class CollectionsSearchExample {  
       public static void main(String[] args) {  
           List<String> names = Arrays.asList("Alice", "Bob", "Charlie", "David");  
     
           // 使用二分查找（注意：列表需要预先排序）  
           int index = Collections.binarySearch(names, "Bob");  
           if (index >= 0) {  
               System.out.println("Found 'Bob' at index: " + index);  
           } else {  
               System.out.println("'Bob' not found.");  
           }  
     
           // 使用自定义比较器进行二分查找  
           index = Collections.binarySearch(names, "Alice", (s1, s2) -> s1.compareToIgnoreCase(s2));  
           if (index >= 0) {  
               System.out.println("Found 'Alice' (case insensitive) at index: " + index);  
           }  
       }  
   }

不可修改集合

1. unmodifiableCollection(Collection<? extends T> c)：返回指定集合的不可修改视图。

2. unmodifiableList(List<? extends T> list)：返回指定列表的不可修改视图。

3. unmodifiableMap(Map<? extends K, ? extends V> m)：返回指定映射的不可修改视图。

4. unmodifiableSet(Set<? extends T> s)：返回指定集合的不可修改视图。

   import java.util.ArrayList;  
   import java.util.Collection;  
   import java.util.Collections;  
     
   public class UnmodifiableCollectionsExample {  
       public static void main(String[] args) {  
           Collection<String> original = new ArrayList<>();  
           original.add("One");  
           original.add("Two");  
     
           // 创建一个不可修改的集合视图  
           Collection<String> unmodifiable = Collections.unmodifiableCollection(original);  
     
           // 尝试修改不可修改集合将抛出UnsupportedOperationException  
           // unmodifiable.add("Three"); // Uncomment to see the exception  
     
           System.out.println(unmodifiable); // 输出：[One, Two]  
       }  
   }

同步控制

1. synchronizedCollection(Collection<T> c)：返回指定集合的同步（线程安全）视图。

2. synchronizedList(List<T> list)：返回指定列表的同步（线程安全）视图。

3. synchronizedMap(Map<K,V> m)：返回指定映射的同步（线程安全）视图。

4. synchronizedSet(Set<T> s)：返回指定集合的同步（线程安全）视图。

import java.util.ArrayList;  
import java.util.Collection;  
import java.util.Collections;  
import java.util.List;  
  
public class SynchronizedCollectionsExample {  
    public static void main(String[] args) {  
        List<String> list = new ArrayList<>();  
        list.add("Apple");  
        list.add("Banana");  
  
        // 创建一个同步的列表视图  
        List<String> synchronizedList = Collections.synchronizedList(list);  
  
        // 注意：迭代器和分割器也是同步的，但最好是在外部同步块中使用它们  
        // synchronized (synchronizedList) {  
        //     for (String fruit : synchronizedList) {  
        //         System.out.println(fruit);  
        //     }  
        // }  
  
        System.out.println(synchronizedList); // 输出：[Apple, Banana]  
    }  
}

其他实用方法

1. addAll(Collection<? super T> c, T... elements)：将所有指定元素添加到指定集合中。

2. disjoint(Collection<?> c1, Collection<?> c2)：如果两个指定集合没有交集，则返回 true。

3. emptyIterator()：返回一个空的迭代器。

4. emptyList()：返回一个空的不可修改列表。

5. emptyMap()：返回一个空的不可修改映射。

6. emptySet()：返回一个空的不可修改集合。

7. fill(List<? super T> list, T obj)：使用指定的对象填充指定列表的所有位置。

8. frequency(Collection<?> c, Object o)：返回指定集合中指定元素的出现次数。

9. max(Collection<? extends T> coll, Comparator<? super T> comp)：根据指定的比较器，返回集合中的最大元素。

10. min(Collection<? extends T> coll, Comparator<? super T> comp)：根据指定的比较器，返回集合中的最小元素。

11. nCopies(int n, T o)：返回一个不可修改的列表，该列表包含指定对象的 n 个副本。

12. reverse(List<?> list)：反转指定列表中元素的顺序。

13. rotate(List<?> list, int distance)：将指定列表中的元素按指定距离进行循环移位。

14. shuffle(List<?> list)：使用默认随机源对指定列表进行随机排序。

15. shuffle(List<?> list, Random rnd)：使用指定的随机源对指定列表进行随机排序。

16. swap(List<?> list, int i, int j)：在指定列表中交换指定位置的元素。