类集算法

集合框架定义了几种能用于类集合映射的算法。 在 Collection 类中，这些算法被定义为静态方法。这些算法 当试图比较不兼容的类型时，其中的一些算法引发一个 ClassCastExcepion 异常；而当试图改变一个不可改变的类集时，则引发一个 UnsupportedOperationException 异常。
JDK 5.0 以后的Collection 支持泛型。

方法	描述
static int binarySearch(List list, Object value, Comparator c)	按照 c 的确定顺序对 list 进行排序，在 list 中搜寻 value。 如果 value 在 list 内，则返回 value 在 list 的位置。如果在 list 中没有发现 value,则返回 -1
static int binarySearch(LIst list, Object value)	在 list 中搜寻 value，列表（list）必须被排序。 如果 value 在 list 内，则返回 value 在 list 的位置。如果在 list 中没有发现 value,则返回 -1
static void copy(List list1,List list2)	将 list2 中的元素复制给 list1
static Enumeration enumeration(Collection c)	返回 c 的一个枚举
static void fill(List list, Object obj)	将 obj 赋给 list 中的每一个元素
Static Object max(Collection c, Comparator comp)	返回由 comp 确定的 c 中的最大元素
Static Object max(Collection c)	返回按自然顺序确定的 c 中的最大的元素。类集不必被排序
static Object min(Collection c, Comparator comp)	返回由 comp 确定的 c 中的最小元素
static Object min(Collection c)	返回按自然顺序确定的 c 中的最小的元素。类集不必被排序
static List nCopies(int num, Object obj)	在返回包含在列表中的 Obj 的 num 个副本。 num 必须大于等于 0
static void reverse(List list)	将 list 中的元素逆向排序
static Comparator reverseOrder()	返回一个逆向比较函数（即将两个元素比较的结果进行逆向的比较函数）
static void shuffle(List list, Random r)	用 r 作为随机数的源，对 list 中的元素进行混淆（也即随机化）
static void shuffle(List list)	对 list 中的元素进行混淆（也即随机化）
static Set singleton(Object obj)	返回一个包含 obj 的Set 对象。 这是一个实现将单个对象变成集合的简单方法
static List singletonList(Object obj)	返回一个包含 obj 的 List 的对象。这是一个实现将单个对象变成列表的简单方法
static Map singletonMap(Object k, Object v)	返回一个包含 k/v 的 Map 的对象。这是一个实现将单个关键字/值对变成映射的简单方法
static void sort(List list, Comparator comp)	按 comp 对 list 中的元素进行排序
static void sort(List list)	按自然顺序对 list 中的元素进行排序
static Collection synchronizedCollection(Collection c)	返回一个被 c 支持的线程安全的（支持同步）类集）
static List synchronizedList(List list)	返回一个被 list 支持的线程安全的 列表
static Map synchronizedMap(Map m)	返回一个被 m 支持的线程安全的映射
static Set synchronizedSet(Set s)	返回一个被 s 支持的线程安全的集合
static SortedMap synchronizedSortedMap(SortedMap sm)	返回一个 被 sm 支持的线程安全的排序映射
static SortedSet synchronizedSortedSet(Sorted ss)	返回一个 被 ss 支持的线程安全的有序集合
static Collection unmodifiableCollection(Collection c)	返回一个被 c 支持的不可变类集
static List unmodifiableList(List list)	返回一个 被 list 支持的不可变列表
static Map unmodifiableMap(Map m)	返回一个被 m 支持的不可变映射
static Set unmodifiableSet(Set s)	返回一个被 s 支持的不可变集合
static SortedMap unmodifiableSortedMap(SortedMap sm)	返回一个被 sm 支持的 不可变排序映射
static SortedSet unmodifiableSortedSet(SortedSet ss)	返回一个被 ss 支持的 不可变排序集合
static void swap(List list,int i, int j)	交换列表中 i,j 两个位置的值

注意其中的 几种方法。如 synchronizedList() 和 synchronizedSet() 被用来获得各种类集的同步（线程安全的）副本。 正如前面解释的那样，没有任何一个标准类集的实现是同步的。必须使用同步算法来为其提供同步。另一种观点：同步类集的迭代函数必须在 synchronized 块内使用。

以 unmodifiable 开头的一组方法返回不能被改变的种类集“视图”。在写方法在异乡进程对类集设为只读形式时很有用的。

import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.ArrayList;
import java.util.List;
import java.util.Iterator;

public class CollectionsDemo {
    public static void main(String[] args) {
            LinkedList ll = new LinkedList();
            ll.add(new Integer(-9));
            ll.add(new Integer(25));
            ll.add(new Integer(-25));
            ll.add(new Integer(5));
            ll.add(new Integer(1));
            ll.add(new Integer(6));
            ll.add(new Integer(-5));
            ll.add(new Integer(19));
            System.out.println("original List:");
            System.out.println(ll);

            Collections.sort(ll);
            System.out.println("Sorted List:");
            System.out.println(ll);

            System.out.println("the position of -5 in list:"
                 + Collections.binarySearch(ll, new Integer(-5)));

            Comparator r = Collections.reverseOrder();
            Collections.sort(ll, r);
            Iterator i = ll.iterator();
            System.out.println(" List sorted in reverse:");
            while(i.hasNext()){
                System.out.print( i.next() +" ");
            }
            System.out.println("");
            System.out.println("the position of -5 in list:" 
                + Collections.binarySearch(ll, new Integer(-5),r));

            Collections.shuffle(ll);
            Iterator li = ll.iterator();
            System.out.println("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));
            System.out.println("the position of -5 in list:" 
                + Collections.binarySearch(ll, new Integer(-5),r));

    }  
}
// original List:
// [-9, 25, -25, 5, 1, 6, -5, 19]
// Sorted List:
// [-25, -9, -5, 1, 5, 6, 19, 25]
// the position of -5 in list:2
// List sorted in reverse:
// 25 19 6 5 1 -5 -9 -25 
// the position of -5 in list:5
// List Shuffled: 
// -9 5 19 1 25 -25 6 -5 
// Minimum: -25
// Maximum: 25
// the position of -5 in list:-6