14、java.util.Collections集合工具类

一、Collections

 

1. 该类不能创建对象
2. 此类完全由在 collection 上进行操作或返回 collection 的静态方法组成。
3. 它包含在 collection 上操作的多态算法，即“包装器”，包装器返回由指定 collection 支持的新 collection，以及少数其他内容。
4. 如果为此类的方法所提供的 collection 或类对象为 null，则这些方法都将抛出 NullPointerException

二、常用方法

 

public class Collections
{
	//构造函数私有化，不能创建对象
	private Collections() {}

	//为List集合排序************************************

	//sort根据元素的自然顺序 对指定列表按升序进行排序
	public static <T extends Comparable<? super T>> void sort(List<T> list) {
		Object[] a = list.toArray();
		Arrays.sort(a);
		ListIterator<T> i = list.listIterator();
		for (int j=0; j<a.length; j++) {
			i.next();
			i.set((T)a[j]);
		}
    }
	//sort根据指定比较器产生的顺序对指定列表进行排序。
	public static <T> void sort(List<T> list, Comparator<? super T> c) {
		Object[] a = list.toArray();
		Arrays.sort(a, (Comparator)c);
		ListIterator i = list.listIterator();
		for (int j=0; j<a.length; j++) {
			i.next();
			i.set(a[j]);
		}
    }

	//求最值***********************************************

	//根据元素的自然顺序，返回给定 collection 的最大元素
	public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll) {
		Iterator<? extends T> i = coll.iterator();
		T candidate = i.next();

		while (i.hasNext()) {
			T next = i.next();
			if (next.compareTo(candidate) > 0)
			candidate = next;
		}
		return candidate;
    }
	//根据指定比较器产生的顺序，返回给定 collection 的最大元素
	public static <T> T max(Collection<? extends T> coll, 
							Comparator<? super T> comp){}

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

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

	
	
	//********************************************************************
	//对List集合进行二分查找
	
	//使用二分搜索法搜索指定列表，以获得指定对象。必须先根据列表元素的自然顺序对列表进行有序排序（通过 sort(List) 方法）。
	public static <T> int binarySearch(List<? extends Comparable<? super T>> list,
																			T key){}
	
	//使用二分搜索法搜索指定列表，以获得指定对象。必须先根据指定的比较器对列表进行升序排序（通过 sort(List, Comparator) 方法）。
	public static <T> int binarySearch(List<? extends T> list,
                                   T key,
                                   Comparator<? super T> c){}

	//***************************************************************************
	//将所有元素从一个列表复制到另一个列表。
	public static <T> void copy(List<? super T> dest,
                            List<? extends T> src){}

	//对List替换，反转****************************************************************************
	
	//使用指定元素替换指定列表中的所有元素。
	public static <T> void fill(List<? super T> list,
							 T obj){}

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

	//反转指定列表中元素的顺序
	public static void reverse(List<?> list){}

	//在指定列表的指定位置处交换元素
	public static void swap(List<?> list,
                        int i,
                        int j){}

	//获取对指定集合进行强行反转的比较器********************************************************

	//返回一个比较器，它强行逆转实现了 Comparable 接口的对象 collection 的自然顺序
	public static <T> Comparator<T> reverseOrder(){}
	//如：假设 a 是一个字符串数组。那么：Arrays.sort(a, Collections.reverseOrder());将按照逆字典（字母）顺序对数组进行排序。

	//返回一个比较器，它强行逆转指定比较器的顺序。如果指定比较器为 null，则此方法等同于 reverseOrder()
	public static <T> Comparator<T> reverseOrder(Comparator<T> cmp){}

	//将非同步集合转成同步集合***********************************************************
	//原理：定义一个类，将集合所有的方法加同一把锁后返回。
	
	//返回指定列表支持的同步（线程安全的）列表。
	public static <T> List<T> synchronizedList(List<T> list){}

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

	//返回指定 set 支持的同步（线程安全的）set
	public static <T> Set<T> synchronizedSet(Set<T> s){}


	//*******************************
	//使用默认随机源对指定列表进行置换。所有置换发生的可能性都是大致相等的。
	public static void shuffle(List<?> list){}
}