Collections

排序 List：sort

// 以自然顺序排序，元素必须实现 Comparable 接口
public static <T extends Comparable<? super T>> void sort(List<T> list);
// 使用传入的 Comparator 进行比较
public static <T> void sort(List<T> list, Comparator<? super T> c);

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(6, 5, 2, 1, 7);
    List<Integer> list2 = Arrays.asList(6, 5, 2, 1, 7);
    Collections.sort(list1);
    Collections.sort(list2, Comparator.reverseOrder());
    System.out.println(list1);
    System.out.println(list2);
}

[1, 2, 5, 6, 7]
[7, 6, 5, 2, 1]

二分搜索 List：binarySearch

使用二分搜索算法在 List 中查找指定对象，调用前 List 必须是排好序的，否则结果是未定义的。

• 若包含指定对象，则返回其索引值；
• 若不包含，则返回 -(insertion point) - 1。

// 以自然顺序排序，元素必须实现 Comparable 接口
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key);
// 使用传入的 Comparator 进行比较
public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c);

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(6, 5, 2, 1, 7);
    List<Integer> list2 = Arrays.asList(6, 5, 2, 1, 7);
    Collections.sort(list1);
    Collections.sort(list2, Comparator.reverseOrder());
    System.out.println(list1);
    System.out.println(list2);

    System.out.println(Collections.binarySearch(list1, 2));
    System.out.println(Collections.binarySearch(list2, 2, Comparator.reverseOrder()));

    // 插入点为 2，返回值为 -(2) - 1 = -3 
    System.out.println(Collections.binarySearch(list1, 3));
    // 插入点为 3，返回值为 -(3) - 1 = -4
    System.out.println(Collections.binarySearch(list2, 3, Comparator.reverseOrder()));
}

[1, 2, 5, 6, 7]
[7, 6, 5, 2, 1]
1
3
-3
-4

反转 List：reverse

将 List 的元素颠倒顺序。

public static void reverse(List<?> list);

public class Reverse {
    public static void main(String[] args) {
        List<Integer> list = Arrays.asList(6, 5, 2, 1, 7);
        System.out.println(list);
        Collections.reverse(list);
        System.out.println(list);
    }
}

[6, 5, 2, 1, 7]
[7, 1, 2, 5, 6]

洗牌、打乱 List：shuffle

将 List 的元素打乱。

// 使用全局的 Random
public static void shuffle(List<?> list);
// 使用给定的 Random
public static void shuffle(List<?> list, Random rnd);

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(6, 5, 2, 1, 7);
    System.out.println(list);
    Collections.shuffle(list);
    System.out.println(list);
    Collections.shuffle(list, new Random());
    System.out.println(list);
}

[6, 5, 2, 1, 7]
[1, 2, 6, 5, 7]
[7, 6, 2, 5, 1]

交换 List 的元素：swap

public static void swap(List<?> list, int i, int j)

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(6, 5, 2, 1, 7);
    System.out.println(list);
    Collections.swap(list, 1, 3);
    System.out.println(list);
}

[6, 5, 2, 1, 7]
[6, 1, 2, 5, 7]

替换 List 的所有元素：fill

将 List 中的所有元素替换为指定元素。

public static <T> void fill(List<? super T> list, T obj)

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(6, 5, 2, 1, 7);
    System.out.println(list);
    Collections.fill(list, 0);
    System.out.println(list);
}

[6, 5, 2, 1, 7]
[0, 0, 0, 0, 0]

复制 List：copy

将 src 中的所有元素复制到 dest 中，注意参数的顺序，前面是目标列表，后面是源列表。操作完成后，目标列表中每个被复制元素的索引将与其在源列表中的索引相同。目标列表的长度必须大于等于源列表。如果目标更长，则目标列表中的其余元素不受影响。

public static <T> void copy(List<? super T> dest, List<? extends T> src)

public static void main(String[] args) {
    List<Integer> src = Arrays.asList(6, 5, 2);
    List<Integer> dest1 = Arrays.asList(3, 3, 3, 3, 3);
    List<Integer> dest2 = Arrays.asList(3, 3);
    System.out.println(src);
    System.out.println(dest1);
    System.out.println(dest2);
    // dest1.size() > src.size()，正常否则
    Collections.copy(src, dest1);
    System.out.println(dest1);
    // dest2.size() < src.size()，会报错
    Collections.copy(src, dest2);
    System.out.println(dest2);
}

[6, 5, 2]
[3, 3, 3, 3, 3]
[3, 3]
Exception in thread "main" java.lang.IndexOutOfBoundsException: Source does not fit in dest
	at java.util.Collections.copy(Collections.java:558)
	at com.example.heima.collections.Copy.main(Copy.java:21)

最大、最小值：max、min

// 以自然顺序排序，元素必须实现 Comparable 接口
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);

// 以自然顺序排序，元素必须实现 Comparable 接口
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 void main(String[] args) {
    List<String> list = Arrays.asList("Java SE Development Kit 8u291".split(" "));
    System.out.println(Collections.min(list));
    System.out.println(Collections.min(list, Comparator.comparingInt(String::length)));
    System.out.println(Collections.max(list));
    System.out.println(Collections.max(list, Comparator.comparingInt(String::length)));
}

8u291
SE
SE
Development

旋转 List：rotate

按指定的距离旋转指定列表中的元素。distance 为正数代表右移，为负数代表左移。

public static void rotate(List<?> list, int distance)

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    List<Integer> list2 = Arrays.asList(1, 2, 3, 4, 5, 6, 7);
    System.out.println(list1);
    Collections.rotate(list1, 2);
    System.out.println(list1);

    System.out.println(list2);
    Collections.rotate(list2, -2);
    System.out.println(list2);
}

[1, 2, 3, 4, 5, 6, 7]
[6, 7, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6, 7]
[3, 4, 5, 6, 7, 1, 2]

替换 List 的指定对象：replaceAll

使用新值替换所有旧值，若成功替换元素，则返回 true，否则返回 false。

public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(1, 2, null, 2, 5, 2, null);
    System.out.println(list);
    Collections.replaceAll(list, 2, 0);
    System.out.println(list);
    Collections.replaceAll(list, null, 9);
    System.out.println(list);
}

[1, 2, null, 2, 5, 2, null]
[1, 0, null, 0, 5, 0, null]
[1, 0, 9, 0, 5, 0, 9]

子列表的位置：indexOfSubList、lastIndexOfSubList

返回目标列表第一次或最后一次出现的起始位置，若没有，则返回 -1.

// 第一次出现的起始位置
public static int indexOfSubList(List<?> source, List<?> target);
// 最后一次出现的起始位置
public static int lastIndexOfSubList(List<?> source, List<?> target);

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(0, 1, 1, 7, 1, 1,  0, 1, 1, 7);
    List<Integer> target = Arrays.asList(1, 1);

    System.out.println(Collections.indexOfSubList(list, target));
    System.out.println(Collections.lastIndexOfSubList(list, target));
}

1
7

不可修改的、只读的：unmodifiableXXX

返回不可修改的、只读的视图，若尝试修改，会抛异常 UnsupportedOperationException。

public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c);

public static <T> Set<T> unmodifiableSet(Set<? extends T> s);

public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s);

public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s);

public static <T> List<T> unmodifiableList(List<? extends T> list);

public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m);

public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K, ? extends V> m);

public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K, ? extends V> m);

public static void main(String[] args) {
	List<Integer> list = new ArrayList<>();
    list.add(1);
    System.out.println(list);
    list = Collections.unmodifiableList(list);
    list.add(2);
}

[1]
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.Collections$UnmodifiableCollection.add(Collections.java:1057)
	at com.example.heima.collections.Unmodifiable.main(Unmodifiable.java:20)

同步的、线程安全的：synchronizedXXX

public static <T> Collection<T> synchronizedCollection(Collection<T> c);

public static <T> Set<T> synchronizedSet(Set<T> s);

public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s);

public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s);

public static <T> List<T> synchronizedList(List<T> list);

public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m);

public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m);

public static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m);

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    list.add(1);
    System.out.println(list);
    list = Collections.synchronizedList(list);
    list.add(2);
    System.out.println(list);
}

[1]
[1, 2]

类型安全的：checkedXXX

返回一个类型安全的视图，插入不兼容类型的元素时，会立即抛出异常 ClassCastException。Java 的泛型机制提供了编译时（静态）类型检查，但是可以使用未检查的类型转换来击败这种机制。

public static <E> Collection<E> checkedCollection(Collection<E> c, 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 <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type);

public static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s,  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> SortedMap<K,V> checkedSortedMap(SortedMap<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);

直接使用 ArrayList

向 List<Integer> 中添加 String 类型的元素时，不会立即报错，而是等到 get 且进行赋值（类型转换）时才会报错。

public static void main(String[] args) {
    List<Integer> list = new ArrayList<>();
    List unCheckedlist = list;
    unCheckedlist.add("a");
    System.out.println("after add");
    // 不会报错
    System.out.println(list.get(0));
    // 会报错
    Integer integer = list.get(0);
    System.out.println(integer);
}

after add
a
Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
	at com.example.heima.collections.Checked.main(Checked.java:21)

使用 Collections.checkedList

使用 Collections.checkedList 会在 add 时直接报错。

public static void main(String[] args) {
    List<Integer> list = Collections.checkedList(new ArrayList<>(), Integer.class);
    List unCheckedlist = list;
    // 直接报错
    unCheckedlist.add("a");
    System.out.println("after add");
    System.out.println(list.get(0));
    Integer integer = list.get(0);
    System.out.println(integer);
}

Exception in thread "main" java.lang.ClassCastException: Attempt to insert class java.lang.String element into collection with element type class java.lang.Integer
	at java.util.Collections$CheckedCollection.typeCheck(Collections.java:3039)
	at java.util.Collections$CheckedCollection.add(Collections.java:3082)
	at com.example.heima.collections.Checked2.main(Checked2.java:18)

空的、不可变的：emptyXXX

以下方法返回的对象都是空的，且是不可变的。

public static <T> Iterator<T> emptyIterator();

public static <T> ListIterator<T> emptyListIterator();

public static <T> Enumeration<T> emptyEnumeration();

public static final <T> Set<T> emptySet();

public static <E> SortedSet<E> emptySortedSet();

public static <E> NavigableSet<E> emptyNavigableSet();

public static final <T> List<T> emptyList()；

public static final <K,V> Map<K,V> emptyMap()；

public static final <K,V> SortedMap<K,V> emptySortedMap()；

public static final <K,V> NavigableMap<K,V> emptyNavigableMap()；

单个的、不可变的：singletonXXX

以下方法返回的对象都是包含单个元素的，且是不可变的。增删改时会抛出异常 UnsupportedOperationException。

public static <T> Set<T> singleton(T o);

public static <T> List<T> singletonList(T o);

public static <K,V> Map<K,V> singletonMap(K key, V value);

public static void main(String[] args) {
    Set<String> set = Collections.singleton("a");
    List<String> list = Collections.singletonList("a");
    Map<String, String> map = Collections.singletonMap("k", "v");
    System.out.println(set);
    System.out.println(list);
    System.out.println(map);

    set.add("b");
}

[a]
[a]
{k=v}
Exception in thread "main" java.lang.UnsupportedOperationException
	at java.util.AbstractCollection.add(AbstractCollection.java:262)
	at com.example.heima.collections.Singleton.main(Singleton.java:25)

nCopies

返回一个 size 为 n 的、不可变的列表，且列表的元素都是指定对象 o。

public static <T> List<T> nCopies(int n, T o);

public static void main(String[] args) {
    List<String> list = Collections.nCopies(3, "a");
    System.out.println(list);
}

[a, a, a]

顺序相反的比较器：reverseOrder

返回一个顺序相反的比较器。

// 与自然序相反
public static <T> Comparator<T> reverseOrder();
// 与指定的比较器顺序相反
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp);

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(6, 2, 5, 1, 7);
    List<Integer> list2 = Arrays.asList(6, 2, 5, 1, 7);
    Collections.sort(list1);
    Collections.sort(list2, Comparator.reverseOrder());
    System.out.println(list1);
    System.out.println(list2);
}

[1, 2, 5, 6, 7]
[7, 6, 5, 2, 1]

迭代 Enumeration 适配器：enumeration

返回一个 Iterator 到 Enumeration 的适配器

public static <T> Enumeration<T> enumeration(final Collection<T> c) {
    return new Enumeration<T>() {
        private final Iterator<T> i = c.iterator();

        public boolean hasMoreElements() {
            return i.hasNext();
        }

        public T nextElement() {
            return i.next();
        }
    };
}

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(6, 2, 5, 1, 7);
    Enumeration<Integer> enumeration = Collections.enumeration(list);
    while (enumeration.hasMoreElements()) {
        System.out.println(enumeration.nextElement());
    }
}

6
2
5
1
7

使用 Enumeration 创建 List：list

public static <T> ArrayList<T> list(Enumeration<T> e) {
    ArrayList<T> l = new ArrayList<>();
    while (e.hasMoreElements())
        l.add(e.nextElement());
    return l;
}

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(6, 2, 5, 1, 7);
    Enumeration<Integer> enumeration = Collections.enumeration(list);
    ArrayList<Integer> list2 = Collections.list(enumeration);
    System.out.println(list2);
}

[6, 2, 5, 1, 7]

元素出现的频率：frequency

public static int frequency(Collection<?> c, Object o) {
    int result = 0;
    if (o == null) {
        for (Object e : c)
            if (e == null)
                result++;
    } else {
        for (Object e : c)
            if (o.equals(e))
                result++;
    }
    return result;
}

public static void main(String[] args) {
    List<Integer> list = Arrays.asList(0, 1, 1, 7, 1,  0, 1, 7);
    System.out.println(Collections.frequency(list, 1));
}

4

是否不相交：disjoint

如果两个集合没有共同的元素，则返回 true，否则 false。

public static boolean disjoint(Collection<?> c1, Collection<?> c2)

public static void main(String[] args) {
    List<Integer> list1 = Arrays.asList(1, 2, 3);
    List<Integer> list2 = Arrays.asList(4, 5, 6);
    List<Integer> list3 = Arrays.asList(2, 3, 4);
    System.out.println(Collections.disjoint(list1, list2));
    System.out.println(Collections.disjoint(list1, list3));
    System.out.println(Collections.disjoint(list2, list3));
}

true
false
false

批量添加：addAll

public static <T> boolean addAll(Collection<? super T> c, T... elements) {
    boolean result = false;
    for (T element : elements)
        result |= c.add(element);
    return result;
}

public static void main(String[] args) {
    List<String> list = new ArrayList<>();
    Collections.addAll(list, "a", "b", "c");
    System.out.println(list);
}

[a, b, c]

newSetFromMap

返回由指定 Map 支持的 Set。拥有与底层 Map 相同的顺序、并发性和性能特征。本质上，这个工厂方法提供了一个对应于任何 Map 实现的 Set 实现。对于已经有相应 Set 实现（如HashMap或TreeMap）的 Map 实现，不需要使用此方法。

public static <E> Set<E> newSetFromMap(Map<E, Boolean> map);

public static void main(String[] args) {
    HashMap<String, Boolean> map = new HashMap<>();
    System.out.println(map);
    Set<String> set = Collections.newSetFromMap(map);
    set.add("a");
    set.add("b");
    System.out.println(set);

    System.out.println(map);
}

{}
[a, b]
{a=true, b=true}

asLifoQueue

返回 Deque 的后进先出队列的视图。方法 add 被映射为 push, remove被映射为 pop。

public static <T> Queue<T> asLifoQueue(Deque<T> deque);

public static void main(String[] args) {
    Deque<Integer> deque1 = new LinkedList<>();
    deque1.add(1);
    deque1.add(2);
    deque1.add(3);

    Integer a1 = deque1.remove();
    Integer a2 = deque1.remove();
    Integer a3 = deque1.remove();

    System.out.println(a1);
    System.out.println(a2);
    System.out.println(a3);

    System.out.println("---");

    Deque<Integer> deque2 = new LinkedList<>();
    Queue<Integer> queue = Collections.asLifoQueue(deque2);

    queue.add(1);
    queue.add(2);
    queue.add(3);

    Integer b1 = queue.remove();
    Integer b2 = queue.remove();
    Integer b3 = queue.remove();

    System.out.println(b1);
    System.out.println(b2);
    System.out.println(b3);
}

1
2
3
---
3
2
1