排序 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