Collections简介

public class Collections extends Object，此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。它包含在collection 上操作的多态算法，即“包装器”，包装器返回由指定collection 支持的新 collection，以及少数其他内容。

如果为此类的方法所提供的collection 或类对象为 null，则这些方法都将抛出NullPointerException。

此类中所含多态算法的文档通常包括对实现的简短描述。应该将这类描述视为实现注意事项，而不是规范的一部分。实现者应该可以随意使用其他算法替代，只要遵循规范本身即可。（例如，sort使用的算法不一定是合并排序算法，但它必须是稳定的。）

此类中包含的“破坏性”算法，即可修改其所操作的 collection 的算法，该算法被指定在collection 不支持适当的可变基元（比如 set 方法）时抛出UnsupportedOperationException。如果调用不会对collection 产生任何影响，那么这些算法可能（但不要求）抛出此异常。例如，在已经排序的、不可修改列表上调用sort 方法可能会（也可能不会）抛出 UnsupportedOperationException。

此类是Java Collections Framework 的成员。

Collections类的使用

字段摘要

1、static List EMPTY_LIST：空的列表（不可变的）。

2、static Map EMPTY_MAP：空的映射（不可变的）。

3、static Set EMPTY_SET：空的 set（不可变的）。

排序操作

Collections提供以下方法对List进行排序操作

1、static void reverse(List<?> list)：反转指定列表中元素的顺序。

2、static void shuffle(List<?> list)：使用默认随机源对指定列表进行置换。即随机排序。

3、static void shuffle(List<?> list, Random rnd)：使用指定的随机源对指定列表进行置换。

4、static<T extends Comparable<? super T>> void sort(List<T> list)：根据元素的自然顺序对指定列表按升序进行排序。

5、static<T> void sort(List<T> list, Comparator<? super T> c)：根据指定比较器产生的顺序对指定列表进行排序。

6、static void swap(List<?> list, int i, int j)：在指定列表的指定位置处交换元素。

7、static void rotate(List<?> list, int distance)：根据指定的距离轮换指定列表中的元素。即旋转，当distance为正数时，将list后distance个元素整体移到前面；当distance为负数时，将list的前distance个元素整体移到后面。

8、static<T> Comparator<T> reverseOrder()：返回一个比较器，它强行逆转实现了Comparable 接口的对象 collection 的自然顺序。

9、static<T> Comparator<T> reverseOrder(Comparator<T> cmp)：返回一个比较器，它强行逆转指定比较器的顺序。

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

/**
 * 
 * @Description: Collections工具类的使用（关于排序）
 *
 * @author： zxt
 *
 * @time: 2018年5月13日 下午10:00:08
 *
 */
public class CollectionsSortTest {

	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		list.add(12);
		list.add(-15);
		list.add(7);
		list.add(4);
		list.add(35);
		list.add(9);
		
		System.out.println("源列表：" + list);
		
		// 逆序
		Collections.reverse(list);
		System.out.println("逆序：" + list);
		
		// 排序（自然顺序）
		Collections.sort(list);
		System.out.println("自然序：" + list);
		
		// 随机排序
		Collections.shuffle(list);
		System.out.println("随机序：" + list);
		
		// 定制排序的用法，将int类型转成string进行比较
		Collections.sort(list, new Comparator<Object>() {
			@Override
			public int compare(Object o1, Object o2) {
				String str1 = String.valueOf(o1);
				String str2 = String.valueOf(o2);
				
				return str1.compareTo(str2);
			}
		});
		System.out.println("定制序：" + list);
		
		// 旋转
		Collections.rotate(list, 3);
		System.out.println("旋转3：" + list);
		
		Collections.rotate(list, -3);
		System.out.println("旋转-3：" + list);
	}
}

查找及替换操作

1、static<T> int binarySearch(List<? extends Comparable<? super T>>list, T key)：使用二分搜索法搜索指定列表，以获得指定对象。注意，返回的是查找对象的索引，List必须是有序的。

2、static<T> int binarySearch(List<? extends T> list, T key, Comparator<?super T> c)：使用二分搜索法搜索指定列表，以获得指定对象。

3、static<T extends Object & Comparable<? super T>> T max(Collection<?extends T> coll)：根据元素的自然顺序，返回给定collection 的最大元素。

4、static<T> T max(Collection<? extends T> coll, Comparator<? super T>comp)：根据指定比较器产生的顺序，返回给定 collection 的最大元素。

5、static<T extends Object & Comparable<? super T>> T min(Collection<?extends T> coll)：根据元素的自然顺序返回给定collection 的最小元素。

6、static<T> T min(Collection<? extends T> coll, Comparator<? super T>comp)：根据指定比较器产生的顺序，返回给定 collection 的最小元素。

7、static<T> void fill(List<? super T> list, T obj)：使用指定元素替换指定列表中的所有元素。

8、static int frequency(Collection<?> c, Object o)：返回指定collection 中等于指定对象的元素数。

9、static int indexOfSubList(List<?> source, List<?> target)：返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回-1。

10、static int lastIndexOfSubList(List<?> source, List<?> target)：返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回-1。

11、static<T> boolean replaceAll(List<T> list, T oldVal, T newVal)：使用另一个值替换列表中出现的所有某一指定值。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * 
 * @Description: Collections工具类的使用（关于查找）
 *
 * @author： zxt
 *
 * @time: 2018年5月13日 下午10:00:08
 *
 */
public class CollectionsSearchTest {

	public static void main(String[] args) {
		List<Integer> list = new ArrayList<Integer>();
		list.add(12);
		list.add(-15);
		list.add(7);
		list.add(4);
		list.add(35);
		list.add(9);
		
		System.out.println("源列表：" + list);
		
		// 最大值
		System.out.println("最大值：" + Collections.max(list));
		
		// 最小值
		System.out.println("最小值：" + Collections.min(list));
		
		// 替换
		Collections.replaceAll(list, -15, 12);
		System.out.println("-15替换12：" + list);

		// 出现次数
		System.out.println("12出现次数：" + Collections.frequency(list, 12));
		
		// 排序
		Collections.sort(list);
		System.out.println("排序后：" + list);
		// 二分查找
		System.out.println("-15下标：" + Collections.binarySearch(list, -15));
		System.out.println("7下标：" + Collections.binarySearch(list, 7));
		System.out.println("35下标：" + Collections.binarySearch(list, 35));
	}
}

同步控制

Collections中几乎对每个集合都定义了同步控制方法，例如SynchronizedList(), SynchronizedSet()等方法，来将集合包装成线程安全的集合。

1、static<T> Collection<T> synchronizedCollection(Collection<T> c)：返回指定collection 支持的同步（线程安全的）collection。

2、static<T> List<T> synchronizedList(List<T> list)：返回指定列表支持的同步（线程安全的）列表。

3、static<K,V> Map<K,V> synchronizedMap(Map<K,V> m)：返回由指定映射支持的同步（线程安全的）映射。

4、static<T> Set<T> synchronizedSet(Set<T> s)：返回指定set 支持的同步（线程安全的）set。

5、static<K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)：返回指定有序映射支持的同步（线程安全的）有序映射。

6、static<T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)：返回指定有序set 支持的同步（线程安全的）有序 set。

此外Collections还提供了一些不可变（只读）的集合，以及几何相应的只读视图。

1、Collections提供了三类方法返回一个不可变集合，emptyXXX()，返回一个空的只读集合。

static<T> List<T> emptyList()：返回空的列表（不可变的）。

static<K,V> Map<K,V> emptyMap()：返回空的映射（不可变的）。

static<T> Set<T> emptySet()：返回空的 set（不可变的）。

2、singleXXX()，返回一个只包含指定对象，只有一个元素，只读的集合。

static<T> Set<T> singleton(T o)：返回一个只包含指定对象的不可变set。

static<T> List<T> singletonList(T o)：返回一个只包含指定对象的不可变列表。

static<K,V> Map<K,V> singletonMap(K key, V value)：返回一个不可变的映射，它只将指定键映射到指定值。

3、unmodifiablleXXX()，返回指定集合对象的只读视图。

static<T> Collection<T> unmodifiableCollection(Collection<? extendsT> c)：返回指定 collection 的不可修改视图。

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

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

static<T> Set<T> unmodifiableSet(Set<? extends T> s)：返回指定set 的不可修改视图。

static<K,V> SortedMap<K,V> nmodifiableSortedMap(SortedMap<K,? extendsV> m)：返回指定有序映射的不可修改视图。

static<T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)：返回指定有序set 的不可修改视图。

其他

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

2、static<T> void copy(List<? super T> dest, List<? extends T> src)：将所有元素从一个列表复制到另一个列表。

3、static boolean disjoint(Collection<?> c1, Collection<?> c2)：如果两个指定collection 中没有相同的元素，则返回 true。

4、static<T> Enumeration<T> enumeration(Collection<T> c)：返回一个指定collection 上的枚举。

5、static<T> ArrayList<T> list(Enumeration<T> e)：返回一个数组列表，它按返回顺序包含指定枚举返回的元素。

6、static<T> List<T> nCopies(int n, T o)：返回由指定对象的n 个副本组成的不可变列表。

7、static<E> Set<E> newSetFromMap(Map<E,Boolean> map)：返回指定映射支持的set。

8、static<T> Queue<T> asLifoQueue(Deque<T> deque)：以后进先出(Lifo) Queue 的形式返回某个 Deque 的视图。

9、static<E> Collection<E> checkedCollection(Collection<E> c,Class<E> type)：返回指定 collection 的一个动态类型安全视图。

10、static<E> List<E> checkedList(List<E> list, Class<E> type)：返回指定列表的一个动态类型安全视图。

11、static<K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType,Class<V> valueType)：返回指定映射的一个动态类型安全视图。

12、static<E> Set<E> checkedSet(Set<E> s, Class<E> type)：返回指定set 的一个动态类型安全视图。

13、static<K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m,Class<K> keyType, Class<V> valueType)：返回指定有序映射的一个动态类型安全视图。

14、static<E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E>type)：返回指定有序 set 的一个动态类型安全视图。

java.util.Collections