集合框架定义了几种能用于类集合映射的算法。 在 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