java集合工具类Collections小记

同步集合 synchronizedXXX

通过Collections的synchronizedXXX方法可以返回同步的线程安全的List、Set、Map，synchronizedXXX方法的内部实现方式也都比较简单粗暴，是将所有的方法调用以同步块包裹，比如SynchronizedCollection的部分源码如图。

图片失效请点击

public static <T> Collection<T> synchronizedCollection(Collection<T> c) {
	return new SynchronizedCollection<>(c);
}

public static <T> List<T> synchronizedList(List<T> list) {
return (list instanceof RandomAccess ?
		new SynchronizedRandomAccessList<>(list) :
		new SynchronizedList<>(list));
}

public static <T> List<T> synchronizedList(List<T> list) {
	return (list instanceof RandomAccess ?
			new SynchronizedRandomAccessList<>(list) :
			new SynchronizedList<>(list));
}

public static <T> List<T> synchronizedList(List<T> list) {
	return (list instanceof RandomAccess ?
			new SynchronizedRandomAccessList<>(list) :
			new SynchronizedList<>(list));
}

public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s) {
	return new SynchronizedNavigableSet<>(s);
}

public static <T> Set<T> synchronizedSet(Set<T> s) {
	return new SynchronizedSet<>(s);
}

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m) {
	return new SynchronizedSortedMap<>(m);
}

public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s) {
	return new SynchronizedSortedSet<>(s);
}

不可变集合 unmodifiableXXX

通过Collections的unmodifiableXXX方法可以同步的线程安全的List、Set、Map，unmodifiableXXX方法的内部实现方式与synchronizedXXX相似，让所有修改集合的方法调用都会抛出UnsupportedOperationException异常，比如UnmodifiableCollection的部分源码如图。

图片失效请点击

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c) {
	return new UnmodifiableCollection<>(c);
}

public static <T> List<T> unmodifiableList(List<? extends T> list) {
	return (list instanceof RandomAccess ?
			new UnmodifiableRandomAccessList<>(list) :
			new UnmodifiableList<>(list));
}

public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m) {
	return new UnmodifiableMap<>(m);
}

public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> m) {
	return new UnmodifiableNavigableMap<>(m);
}

public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s) {
	return new UnmodifiableNavigableSet<>(s);
}

public static <T> Set<T> unmodifiableSet(Set<? extends T> s) {
	return new UnmodifiableSet<>(s);
}

public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m) {
	return new UnmodifiableSortedMap<>(m);
}

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s) {
	return new UnmodifiableSortedSet<>(s);
}

空的集合、迭代器 emptyXXX

emptyXXX方法可以返回空的、不可修改的List、Set、Map，还有没有元素Enumeration、Iterator、ListIterator。

/**
 * 返回一个没有元素的Enumeration
 * hasMoreElements方法总是返回false
 * nextElement方法总是抛出NoSuchElementException
 */
<T> Enumeration<T> emptyEnumeration()

/**
 * 返回一个没有元素的Iterator
 * hasNext方法总是返回false
 * next方法总是抛出NoSuchElementException
 * remove方法总是抛出IllegalStateException
 */
<T> Iterator<T> emptyIterator()

/**
 * 返回一个没有元素的list iterator
 * hasNext方法总是返回false
 * next方法总是抛出NoSuchElementException
 * remove方法总是抛出IllegalStateException
 * add方法总是抛出UnsupportedOperationException
 * nextIndex方法总是返回0
 * previousIndex方法总是返回-1
 */
<T> ListIterator<T> emptyListIterator()

/**
 * 返回一个空的、不可修改的List
 * 修改时总是抛出UnsupportedOperationException
 */
public static final <T> List<T> emptyList() {
	return (List<T>) EMPTY_LIST;
}

/**
 * 返回一个空的、不可修改的Map
 * 修改时总是抛出UnsupportedOperationException
 */
public static final <K,V> Map<K,V> emptyMap() {
	return (Map<K,V>) EMPTY_MAP;
}

/**
 * 返回一个空的、不可修改的NavigableMap
 * 修改时总是抛出UnsupportedOperationException
 */
public static final <K,V> NavigableMap<K,V> emptyNavigableMap() {
	return (NavigableMap<K,V>) UnmodifiableNavigableMap.EMPTY_NAVIGABLE_MAP;
}

/**
 * 返回一个空的、不可修改的NavigableSet
 * 修改时总是抛出UnsupportedOperationException
 */
public static <E> NavigableSet<E> emptyNavigableSet() {
	return (NavigableSet<E>) UnmodifiableNavigableSet.EMPTY_NAVIGABLE_SET;
}

/**
 * 返回一个空的、不可修改的Set
 * 修改时总是抛出UnsupportedOperationException
 */
public static final <T> Set<T> emptySet() {
	return (Set<T>) EMPTY_SET;
}

/**
 * 返回一个空的、不可修改的SortedMap
 * 修改时总是抛出UnsupportedOperationException
 */
public static final <K,V> SortedMap<K,V> emptySortedMap() {
	return (SortedMap<K,V>) UnmodifiableNavigableMap.EMPTY_NAVIGABLE_MAP;
}

/**
 * 返回一个空的、不可修改的SortedSet
 * 修改时总是抛出UnsupportedOperationException
 */
public static <E> SortedSet<E> emptySortedSet() {
	return (SortedSet<E>) UnmodifiableNavigableSet.EMPTY_NAVIGABLE_SET;
}

受检查的集合

返回特定类型元素的集合，再次添加的时候，会报类型转换错误

举个栗子

List list = new ArrayList();
list.add(new A());
list.add(new B());

List list2 = Collections.checkedList(list, A.class);
list2.add(new A());
list2.add(new B());
// 在list2.add(new B());会抛出 java.lang.ClassCastException: Attempt to insert class test.B element into collection with element type class test.A

public static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)

public static <E> List<E> checkedList(List<E> list, Class<E> type)

public static <K, V> Map<K, V> checkedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType)

public static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K, V> m, Class<K> keyType, Class<V> valueType)

public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, Class<E> type)

public static <E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type)

public static <E> Set<E> checkedSet(Set<E> s, Class<E> type)

public static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K, V> m, Class<K> keyType, Class<V> valueType)

public static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)

单个元素的不可变集合

/**
 * 返回一个不可修改的、只包含一个元素o的Set
 * 修改时总是抛出UnsupportedOperationException
 */
public static <T> Set<T> singleton(T o) {
	return new SingletonSet<>(o);
}

/**
 * 返回一个不可修改的、只包含一个元素o的List
 * 修改时总是抛出UnsupportedOperationException
 */
 public static <T> List<T> singletonList(T o) {
	return new SingletonList<>(o);
}
 
/**
 * 返回一个不可修改的、只包含一组键值对的Map
 * 修改时总是抛出UnsupportedOperationException
 */
public static <K,V> Map<K,V> singletonMap(K key, V value) {
	return new SingletonMap<>(key, value);
}

排序、打乱、交换

/**
 * 元素必须实现{@link Comparable}接口，根据元素的compareTo方法对list进行排序
 * 这种排序是稳定排序：相等的元素不会因为排序而重新排序。
 * 指定的列表必须是可修改的，但不必是可调整大小的。
 * 底层实际是调用了 List的sort(null)方法
 */
public static <T extends Comparable<? super T>> void sort(List<T> list) {
	list.sort(null);
}

/**
 * 元素不用实现{@link Comparable}接口，根据传入的Comparator对list进行排序
 * 这种排序是稳定排序：相等的元素不会因为排序而重新排序。
 * 指定的列表必须是可修改的，但不必是可调整大小的。
 * 底层实际是调用了 List的sort(null)方法
 */
public static <T> void sort(List<T> list, Comparator<? super T> c) {
	list.sort(c);
}

/**
 * 反转list中元素的顺序
 */
public static void reverse(List<?> list)

/**
 * 根据一个自动生成的随机源，将list打乱顺序
 */
public static void shuffle(List<?> list) {
	Random rnd = r;
	if (rnd == null)
		r = rnd = new Random(); // harmless race.
	shuffle(list, rnd);
}

/**
 * 根据一个传入的随机源，将list打乱顺序
 */
public static void shuffle(List<?> list, Random rnd) {

/**
 * 交换两个元素的位置
 */
public static void swap(List<?> list, int i, int j)

/**
 * 将list的元素整体左移或者右移distance个单位
 * distance为正时右移，为负时左移
 */
public static void rotate(List<?> list, int distance)

/**
 * 返回一个反序的Comparator，当用调用xx.sort(Collection<T> c, Comparator)时会以T的自然排序的相反顺序排序
 */
public static <T> Comparator<T> reverseOrder()

/**
 * 返回一个指定Comparator<T> cmp反序的Comparator，当用调用xx.sort(Collection<T> c, Comparator)时会以cmp相反顺序排序
 */
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)

最大、最小值

/**
 * 返回集合的最大值，以自然排序
 */
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)

/**
 * 返回集合的最大值，以传入的Comparator排序
 */
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)

/**
 * 返回集合的最小值，以自然排序
 */
public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)

/**
 * 返回集合的最小值，以传入的Comparator排序
 */
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)

查找元素、子集合

/**
 * 利用二分法查找元素，list必须是已经按照自然排序升序排列的
 * 找到则返回下标，否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引
 */
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)

/**
 * 利用二分法查找元素，list必须是已经按照指定的Comparator升序排列的
 * 找到则返回下标，否则返回 (-(插入点) - 1)。插入点 被定义为将键插入列表的那一点：即第一个大于此键的元素索引
 */
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
/**
 * 返回一个target列表第一次在source中出现的下标
 * 没有的话返回-1
 */
public static int indexOfSubList(List<?> source, List<?> target)

/**
 * 返回一个target列表最后一次在source中出现的下标
 * 没有的话返回-1
 */
public static int lastIndexOfSubList(List<?> source, List<?> target)

集合、Enumeration互转

/**
 * 返回一个list，list的顺序和Enumeration的顺序一样
 */
public static <T> ArrayList<T> list(Enumeration<T> e)

/**
 * 返回一个集合的Enumeration
 */
public static <T> Enumeration<T> enumeration(final Collection<T> c)

其他

/**
 * 返回元素o在集合c中出现的次数
 */
public static int frequency(Collection<?> c, Object o)

/**
 * 当两个集合中没有相同的元素的时候 返回 true 。当有相同的元素的时候返回 false.
 */
public static boolean disjoint(Collection<?> c1, Collection<?> c2)

/**
 * 用newVal替换list中所有的oldVal
 */
public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

/**
 * 返回一个Map对应的Set实现，这个Set拥有与map相同的并发特性、顺序，Set与map的KeySet相互映射
 * 已经有对应实现的Set就不需要调用此方法返回，比如（HashMap->HashSet）、（TreeMap->TreeSet）
 * 传入的map必须是空的，否则抛出IllegalArgumentException: Map is non-empty
 */
public static <E> Set<E> newSetFromMap(Map<E, Boolean> map) {
	return new SetFromMap<>(map);
}

/**
 * 将src中的元素拷贝到dest中，src中的元素会覆盖dest中同位置的元素
 */
public static <T> void copy(List<? super T> dest, List<? extends T> src)
/**
 * 返回一个由n个o填充的、不可修改的List
 * n个o是一个对象，只占一个空间
 */
public static <T> List<T> nCopies(int n, T o) {
	if (n < 0)
		throw new IllegalArgumentException("List length = " + n);
	return new CopiesList<>(n, o);
}

/**
 * 以对象obj填充list
 */
public static <T> void fill(List<? super T> list, T obj)

/**
 * 将一个或多个元素添加到集合中
 */
public static <T> boolean addAll(Collection<? super T> c, T... elements)