Java 集合算法

集合框架定义了可以应用于集合和映射的几个算法。

这些算法是在Collections类中定义的静态方法。其中几个方法可能会抛出 ClassCastException ，当尝试比较不兼容的类型时，或者抛出 UnsupportedOperationException ，当尝试修改一个不可修改的集合时发生。

集合框架算法中定义的方法总结如下表所示−

序号	方法与描述
1	static int binarySearch(List list, Object value, Comparator c) 根据 c 按顺序在列表中搜索值。如果找到该值，则返回其位置；如果未找到该值，则返回-1。
2	static int binarySearch(List list, Object value) 在列表中搜索值。列表必须是有序的。如果找到该值，则返回其位置；如果未找到该值，则返回-1。
3	static void copy(List list1, List list2) 将list2的元素复制到list1中。
4	static Enumeration enumeration(Collection c) 返回一个枚举 c 的枚举。
5	static void fill（List list，Object obj） 将obj分配给列表的每个元素。
6	static int indexOfSubList（List list，List subList） 在列表中搜索subList的第一次出现。返回第一个匹配项的索引，如果没有找到匹配项，则返回1。
7	static int lastIndexOfSubList（List list，List subList） 在列表中搜索subList的最后一次出现。返回最后一个匹配项的索引，如果没有找到匹配项，则返回1。
8	static ArrayList list（Enumeration enum） 返回一个包含enum元素的ArrayList。
9	static Object max(Collection c, Comparator comp) 根据 comp 决定，返回集合 c 中的最大元素。
10	static Object max(Collection c) 根据自然排序，返回集合 c 中的最大元素。集合不需要排序。
11	static Object min(Collection c, Comparator comp) 根据 comp 决定，返回集合 c 中的最小元素。集合不需要排序。
12	static Object min(Collection c) 根据自然排序，返回集合 c 中的最小元素。
13	static List nCopies(int num, Object obj) 返回一个包含 num 个 obj 副本的不可变列表。num 必须大于或等于零。
14	static boolean replaceAll(List list, Object old, Object new) 将列表中所有的 old 替换为 new。如果至少有一个替换发生，则返回 true。否则返回 false。
15	static void reverse(List list) 反转列表中的顺序。
16	static Comparator reverseOrder( ) 返回一个逆向比较器。
17	static void rotate(List list, int n) 将列表按照 n 进行旋转右边的地方。要向左旋转，请给n设置一个负值.
18	static void shuffle(List list, Random r) 使用 r 作为随机数源，对列表中的元素进行洗牌（即随机排序）。
19	static void shuffle(List list) 对列表中的元素进行洗牌（即随机排序）。
20	static Set singleton(Object obj) 将obj作为不可变的set返回。这是将单个对象转换为set的简便方法。
21	static List singletonList(Object obj) 将obj作为不可变的列表返回。这是将单个对象转换为列表的简便方法。
22	static Map singletonMap(Object k, Object v) 将键/值对k/v作为不可变映射返回。这是将单个键/值对转换为映射的简单方法。
23	static void sort(List list, Comparator comp) 根据comp确定的顺序对list的元素进行排序。
24	static void sort(List list) 根据元素的自然顺序对list的元素进行排序。
25	static void swap(List list, int idx1, int idx2) 交换列表中由idx1和idx2指定的索引处的元素。
26	static Collection synchronizedCollection(Collection c) 返回一个同步的集合，该集合是由c支持的。返回一个由 c 支持的线程安全集合。
27	static List synchronizedList(List list) 返回一个由list支持的线程安全列表。
28	static Map synchronizedMap(Map m) 返回一个由 m 支持的线程安全映射。
29	static Set synchronizedSet(Set s) 返回一个由 s 支持的线程安全集合。
30	static SortedMap synchronizedSortedMap(SortedMap sm) 返回一个由 sm 支持的线程安全的排序映射。
31	static SortedSet synchronizedSortedSet(SortedSet ss) 返回一个由 ss 支持的线程安全的集合。
32	static Collection unmodifiableCollection(Collection c) 返回由 c 支持的不可修改的集合。
33	static List unmodifiableList(List list) 返回由列表支持的不可修改的列表。
34	static Map unmodifiableMap(Map m) 返回由 m 支持的不可修改的映射。
35	static Set unmodifiableSet(Set s) 返回由 s 支持的不可修改的集合。
36	static SortedMap unmodifiableSortedMap(SortedMap sm) 返回由 sm 支持的不可修改的排序映射。
37	static SortedSet unmodifiableSortedSet(SortedSet ss) 返回由 ss 支持的不可修改的排序集合。

示例

以下是一个示例，演示了各种算法。

import java.util.*;
public class AlgorithmsDemo {

   public static void main(String args[]) {

      // Create and initialize linked list
      LinkedList ll = new LinkedList();
      ll.add(new Integer(-8));
      ll.add(new Integer(20));
      ll.add(new Integer(-20));
      ll.add(new Integer(8));

      // Create a reverse order comparator
      Comparator r = Collections.reverseOrder();

      // Sort list by using the comparator
      Collections.sort(ll, r);

      // Get iterator
      Iterator li = ll.iterator();
      System.out.print("List sorted in reverse: ");

      while(li.hasNext()) {
         System.out.print(li.next() + " ");
      }
      System.out.println();
      Collections.shuffle(ll);

      // display randomized list
      li = ll.iterator();
      System.out.print("List shuffled: ");

      while(li.hasNext()) {
         System.out.print(li.next() + " ");
      }

      System.out.println();
      System.out.println("Minimum: " + Collections.min(ll));
      System.out.println("Maximum: " + Collections.max(ll));
   }
}

这将产生以下结果 −

输出

List sorted in reverse: 20 8 -8 -20
List shuffled: 20 -20 8 -8
Minimum: -20
Maximum: 20