20200110 java.util.Collections

Collections简介

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

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

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

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

此类是Java Collections Framework 的成员。

Collections类的使用

emptyXXX()

静态属性

• EMPTY_LIST：空的列表（不可变的）。
• EMPTY_MAP：空的映射（不可变的）。
• EMPTY_SET：空的 set（不可变的）。

List list = Collections.EMPTY_LIST;
System.out.println(list); // []
Set set = Collections.EMPTY_SET;
System.out.println(set); // []
Map map = Collections.EMPTY_MAP;
System.out.println(map); // {}

静态方法

用于构造空集合。

所有emptyXXX()方法均不可修改。

List<Object> emptyList = Collections.emptyList();
System.out.println(emptyList); // []
Set<Object> emptySet = Collections.emptySet();
System.out.println(emptySet); // []
Map<Object, Object> emptyMap = Collections.emptyMap();
System.out.println(emptyMap); // {}

Enumeration<Object> enumeration = Collections.emptyEnumeration();
Iterator<Object> iterator = Collections.emptyIterator();
ListIterator<Object> listIterator = Collections.emptyListIterator();

singletonXXX()

用于构造只包含一个元素的集合。

所有singletonXXX()方法不可修改

Set<Integer> set = Collections.singleton(1);
System.out.println(set); // [1]
List<Integer> list = Collections.singletonList(1);
System.out.println(list); // [1]
Map<Integer, String> map = Collections.singletonMap(1, "a");
System.out.println(map); // {1=a}

unmodifiableXXX()

用于构造不可修改的集合。

List list = Collections.unmodifiableList(Collections.EMPTY_LIST);
Set set = Collections.unmodifiableSet(Collections.EMPTY_SET);
Map map = Collections.unmodifiableMap(Collections.EMPTY_MAP);

SortedSet sortedSet = Collections.unmodifiableSortedSet(new TreeSet<>());
SortedMap sortedMap = Collections.unmodifiableSortedMap(new TreeMap<>());

NavigableSet<Object> navigableSet = Collections.unmodifiableNavigableSet(new TreeSet<>());
NavigableMap<Object, Object> navigableMap = Collections.unmodifiableNavigableMap(new TreeMap<>());

checkedXXX()

用于构造动态类型安全的集合。如果向集合中添加非指定类型的元素，会快速失败，抛出ClassCastException异常

Collection collection = Collections.checkedCollection(Collections.EMPTY_LIST, Object.class);
List list = Collections.checkedList(Collections.EMPTY_LIST, Object.class);
Set set = Collections.checkedSet(Collections.EMPTY_SET, Object.class);
Map map = Collections.checkedMap(Collections.EMPTY_MAP, Object.class, Object.class);

SortedSet sortedSet = Collections.checkedSortedSet(new TreeSet<>(), Object.class);
SortedMap sortedMap = Collections.checkedSortedMap(new TreeMap<>(), Object.class, Object.class);

NavigableSet<Object> navigableSet = Collections.checkedNavigableSet(new TreeSet<>(), Object.class);
NavigableMap<Object, Object> navigableMap = Collections.checkedNavigableMap(new TreeMap<>(), Object.class, Object.class);

Queue<Object> es = Collections.checkedQueue(new PriorityQueue<Object>(), Object.class);

synchronizedXXX()

用于构造线程安全的集合。

Collection<Integer> collection = Collections.synchronizedCollection(Collections.EMPTY_LIST);
List<Integer> list = Collections.synchronizedList(Collections.EMPTY_LIST);
Set<Integer> set = Collections.synchronizedSet(Collections.EMPTY_SET);
Map map = Collections.synchronizedMap(Collections.EMPTY_MAP);

SortedSet sortedSet = Collections.synchronizedSortedSet(new TreeSet<>());
SortedMap sortedMap = Collections.synchronizedSortedMap(new TreeMap<>());

NavigableSet<Object> navigableSet = Collections.synchronizedNavigableSet(new TreeSet<>());
NavigableMap<Object, Object> navigableMap = Collections.synchronizedNavigableMap(new TreeMap<>());

排序操作

• sort：根据指定比较器产生的顺序对指定列表进行排序。如果未指定比较器，使用自然顺序升序排序。
• reverse：反转指定列表中元素的顺序。
• shuffle：使用随机源对指定列表进行置换。即随机排序。随机源可指定。
• swap：在指定列表的指定位置处交换元素。
• rotate：根据指定的距离轮换指定列表中的元素。即旋转，当distance为正数时，将list后distance个元素整体移到前面；当distance为负数时，将list的前distance个元素整体移到后面。
• reverseOrder：返回一个比较器，它反转指定比较器的顺序。比较器默认为自然顺序升序排序。

List<Integer> list = new ArrayList<Integer>();
list.add(12);
list.add(-15);
list.add(7);
list.add(4);
list.add(35);
System.out.println(list); // [12, -15, 7, 4, 35]

Collections.sort(list);
System.out.println(list); // [-15, 4, 7, 12, 35]

Collections.sort(list, Comparator.comparingInt(Math::abs));
System.out.println(list); // [4, 7, 12, -15, 35]

Collections.sort(list, Collections.reverseOrder());
System.out.println(list); // [35, 12, 7, 4, -15]

Collections.sort(list, Collections.reverseOrder(Comparator.comparing(Math::abs)));
System.out.println(list); // [35, -15, 12, 7, 4]

Collections.reverse(list);
System.out.println(list); // [4, 7, 12, -15, 35]

Collections.shuffle(list, new Random(31));
System.out.println(list); // [35, -15, 4, 7, 12]

Collections.swap(list, 0, list.size() - 1);
System.out.println(list); // [12, -15, 4, 7, 35]


// rotate
// 将第0位元素向右推到第i位元素，然后其他元素依次向右平移，超出list大小后从最开始重头推进
for (int i = -5; i < list.size(); i++) {
    List<Integer> list2 = Arrays.asList(0, 1, 2, 3, 4);
    Collections.rotate(list2, i);
    System.out.println(i + " : " + list2);
    // -5 : [0, 1, 2, 3, 4]
    // -4 : [4, 0, 1, 2, 3]
    // -3 : [3, 4, 0, 1, 2]
    // -2 : [2, 3, 4, 0, 1]
    // -1 : [1, 2, 3, 4, 0]
    // 0 : [0, 1, 2, 3, 4]
    // 1 : [4, 0, 1, 2, 3]
    // 2 : [3, 4, 0, 1, 2]
    // 3 : [2, 3, 4, 0, 1]
    // 4 : [1, 2, 3, 4, 0]
}

查找及替换操作

• binarySearch：使用二分搜索法搜索指定列表，以获得指定对象。注意，返回的是查找对象的索引，List必须是有序的。
• max：根据指定比较器产生的顺序，返回给定 collection 的最大元素。比较器默认为自然顺序升序排序。
• min：根据指定比较器产生的顺序，返回给定 collection 的最小元素。比较器默认为自然顺序升序排序。
• fill：使用指定元素替换指定列表中的所有元素。
• replaceAll：替换列表中的某一指定值。
• frequency：返回指定 collection 中等于指定元素的个数。
• indexOfSubList：返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回-1。
• lastIndexOfSubList：返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回-1。

List<Integer> list = new ArrayList<Integer>();
list.add(12);
list.add(-15);
list.add(7);
list.add(4);
list.add(35);
System.out.println(list); // [12, -15, 7, 4, 35]


int index1 = Collections.binarySearch(list, 4);
System.out.println(index1); // -1 这里是错误的索引结果
// 二分查找要求集合必须以自然顺序升序排列
Collections.sort(list);
System.out.println(list); // [-15, 4, 7, 12, 35]
int index2 = Collections.binarySearch(list, 4);
System.out.println(index2); // 1

// 按照比较器进行二分查找前，需要保证集合以此比较器顺序排序
Collections.sort(list, Comparator.comparing(Math::abs));
System.out.println(list); // [4, 7, 12, -15, 35]
int index3 = Collections.binarySearch(list, 4, Comparator.comparing(Math::abs));
System.out.println(index3); // 0

// max，min 方法不需要集合事先排序，如果未指定比较器，默认为自然排序，如果指定比较器，以比较器顺序排序
// Collections.sort(list);
// System.out.println(list); // [-15, 4, 7, 12, 35]
Integer max = Collections.max(list);
Integer min = Collections.min(list);
System.out.println(max); // 35
System.out.println(min); // -15
System.out.println(Collections.max(list, Comparator.comparing(Math::abs))); // 35
System.out.println(Collections.min(list, Comparator.comparing(Math::abs))); // 4

Collections.fill(list, 11);
System.out.println(list); // [11, 11, 11, 11, 11]

int frequency = Collections.frequency(list, 11);
System.out.println(frequency); // 5

Collections.replaceAll(list, 11, 22);
System.out.println(list); // [22, 22, 22, 22, 22]

List<Integer> source = Arrays.asList(0, 1, 2, 3, 2, 3);
List<Integer> target = Arrays.asList(2, 3);
int indexOfSubList = Collections.indexOfSubList(source, target);
System.out.println(indexOfSubList); // 2
int lastIndexOfSubList = Collections.lastIndexOfSubList(source, target);
System.out.println(lastIndexOfSubList); // 4

其他操作

• addAll：将所有指定元素添加到指定集合中。
• copy：将所有元素从一个列表复制到另一个列表。要求目标集合size大于源集合。
• disjoint：如果两个指定集合中没有相同的元素，则返回 true。
• enumeration：返回一个指定集合上的枚举。
• list：返回一个数组列表，它按返回顺序包含指定枚举返回的元素。
• nCopies：返回由指定对象的 n 个副本组成的不可变列表。
• newSetFromMap：返回指定映射支持的 Set。
• asLifoQueue：以后进先出(Lifo) Queue 的形式返回某个 Deque 的视图。

ArrayList list = new ArrayList<Integer>(Arrays.asList(0, 1, 2));
System.out.println(list); // [0, 1, 2]
// Collections.addAll(list, new int[]{0, 3, 4});
// System.out.println(list); // [0, 1, 2, [I@4554617c]
Collections.addAll(list, new Integer[]{0, 3, 4});
System.out.println(list); // [0, 1, 2, 0, 3, 4]

// copy 要求目标集合size大于源集合
ArrayList<Integer> copyList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    copyList.add(i);
}
Collections.copy(copyList, list);
System.out.println(copyList); // [0, 1, 2, 0, 3, 4, 6, 7, 8, 9]

boolean disjoint = Collections.disjoint(list, copyList);
System.out.println(disjoint); // false
copyList.removeAll(list);
System.out.println(copyList); // [6, 7, 8, 9]
System.out.println(Collections.disjoint(list, copyList)); // true

Enumeration<Integer> enumeration = Collections.enumeration(copyList);
// while (enumeration.hasMoreElements()){
//     System.out.print(enumeration.nextElement());
// }
// System.out.println(); // 6789

ArrayList<Integer> list1 = Collections.list(enumeration);
System.out.println(list1); // [6, 7, 8, 9]

List<Integer> list2 = Collections.nCopies(3, 11);
System.out.println(list2); // [11, 11, 11]

// 如果入参Map不为空，抛出 IllegalArgumentException
Set<Object> objects = Collections.newSetFromMap(Collections.emptyMap());

Deque<Integer> deque = new ArrayDeque<>();
deque.addAll(list);
System.out.println(deque); // [0, 1, 2, 0, 3, 4]
Queue<Integer> queue = Collections.asLifoQueue(deque);
System.out.println(queue); // [0, 1, 2, 0, 3, 4]

参考资料

• java.util.Collections