Collections 工具类
针对 List 集合的方法
排序 sort
如果集合元素为基本数据类型，采用快排；对于集合元素为引用类型，采用归并排序。
//对指定 List 集合的元素按照自然排序
void sort(List<?> list);
//对 List 集合元素根据 Comparator 进行排序
void sort(List<T> list, Comparator<? super T> c);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
System.out.println(nums); //[10, -5, 20, 0]
//自然排序
Collections.sort(nums);
System.out.println(nums); //[-5, 0, 10, 20]
//自定义排序，降序排列
Collections.sort(nums, (o1, o2) -> o1 < o2 ? 1 : (o1 == o2 ? 0 : -1));
System.out.println(nums); //[20, 10, 0, -5]
}
二分查找 binarySearch
//List 必须是有序的，且按照自然顺序排序
int binarySearch(List<? extends Comparable<? super T>> list, T key);
//List 必须有序，且根据 Comparator 排序
int binarySearch(List<? extends T> list, T key, Comparator<? super T> c);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
//自然排序
Collections.sort(nums);
System.out.println(nums); //[-5, 0, 10, 20]
//找到元素，直接返回索引
System.out.println(Collections.binarySearch(nums, 10)); //2
//未找到元素，返回 -(最后一次查找位置 + 1)
//最后一次查找位置是元素 10 位置（就是插入位置），索引为 2 ，所以返回 -3
System.out.println(Collections.binarySearch(nums, 1)); //-3
//自定义排序，降序排列
Comparator<Integer> c = (o1, o2) -> o1 < o2 ? 1 : (o1 == o2 ? 0 : -1);
Collections.sort(nums, c);
System.out.println(nums); //[20, 10, 0, -5]
System.out.println(Collections.binarySearch(nums, 10, c)); //1
System.out.println(Collections.binarySearch(nums, 1, c)); //-3
}
反转 reverse
//将 list 集合中元素反转
void reverse(List<?> list);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
System.out.println(nums); //[10, -5, 20, 0]
//列表反转
Collections.reverse(nums);
System.out.println(nums); //[0, 20, -5, 10]
}
打乱顺序 shuffle
//按照系统自动生成的随机数对 List 顺序打乱（洗牌操作）
void shuffle(List<?> list);
//按照指定的随机数将 List 顺序打乱
void shuffle(List<?> list, Random rnd);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
System.out.println(nums); //[10, -5, 20, 0]
Collections.shuffle(nums);
System.out.println(nums); //[10, 0, 20, -5]
Collections.shuffle(nums, new Random());
System.out.println(nums); //[0, -5, 10, 20]
}
交换顺序 swap
//将指定 List 集合中的 i 处元素和 j 处元素进行交换
void swap(List<?> list, int i, int j);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
System.out.println(nums); //[10, -5, 20, 0]
//交换索引 1 和 2 位置的元素
Collections.swap(nums, 1, 2);
System.out.println(nums); //[10, 20, -5, 0]
}
移位 rotate
//当 distance 为正数时，循环右移
//当 distance 为负数时，循环左移
void rotate(List<?> list, int distance);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
System.out.println(nums); //[10, -5, 20, 0]
//循环右移
Collections.rotate(nums, 1);
System.out.println(nums); //[0, 10, -5, 20]
//循环左移
Collections.rotate(nums, -1);
System.out.println(nums); //[10, -5, 20, 0]
}
填充 fill
//将 list 中的全部元素填充为 obj
void fill(List<? super T> list, T obj);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
System.out.println(nums); //[10, -5, 20, 0]
Collections.fill(nums, -1);
System.out.println(nums); //[-1, -1, -1, -1]
}
查找子集位置 indexOfSubList/lastIndexOfSubList
//返回指定源列表中第一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
int indexOfSubList(List<?> source, List<?> target);
//返回指定源列表中最后一次出现指定目标列表的起始位置；如果没有出现这样的列表，则返回 -1。
int lastIndexOfSubList(List<?> source, List<?> target);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(1,2,2,3,3).stream().collect(Collectors.toList());
System.out.println(nums); //[1, 2, 2, 3, 3]
List subList = Arrays.asList(2);
System.out.println(Collections.indexOfSubList(nums, subList)); //1
System.out.println(Collections.lastIndexOfSubList(nums, subList)); //2
}
替换 replaceAll
//使用一个新值替换 List 对象的所有旧值 oldVal。
boolean replaceAll(List<T> list, T oldVal, T newVal);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(1,2,2,3,3).stream().collect(Collectors.toList());
System.out.println(nums); //[1, 2, 2, 3, 3]
Collections.replaceAll(nums, 2 ,4);
System.out.println(nums); //[1, 4, 4, 3, 3]
}
针对 Collection 集合的方法
求极值 min/max
//自然排序中的最小值和最大值
T min(Collection<? extends T> coll);
T max(Collection<? extends T> coll);
//自定义排序中的最小值和最大值
T min(Collection<? extends T> coll, Comparator<? super T> comp);
T max(Collection<? extends T> coll, Comparator<? super T> comp);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,20,0).stream().collect(Collectors.toList());
System.out.println(Collections.max(nums)); //20
System.out.println(Collections.min(nums)); //-5
//自定义大小
Comparator<Integer> c = (o1, o2) -> o1 < o2 ? 1 : (o1 == o2 ? 0 : -1);
System.out.println(Collections.max(nums, c)); //-5
System.out.println(Collections.min(nums, c)); //20
}
求频率 frequency
//返回指定 collection 中等于指定对象的出现次数。
int frequency(Collection<?> c, Object o);
public static void main(String[] args) {
List<Integer> nums = Arrays.asList(10,-5,-5,0).stream().collect(Collectors.toList());
System.out.println(Collections.frequency(nums, -5)); //2
}
线程同步控制
HashSet，TreeSet，arrayList，LinkedList，HashMap，TreeMap 等集合都是线程不安全的。如果有多个线程访问它们，而且有超过一个的线程试图修改它们，则存在线程安全的问题。Collections 提供了多个静态方法可以把他们包装成线程同步的集合。
//返回指定 collection 支持的同步（线程安全的）collection。
Collection<T> synchronizedCollection(Collection<T> c);
//返回指定列表支持的同步（线程安全的）列表。
List<T> synchronizedList(List<T> list);
//返回由指定映射支持的同步（线程安全的）映射。
Map<K,V> synchronizedMap(Map<K,V> m);
//返回指定 set 支持的同步（线程安全的）set。
Set<T> synchronizedSet(Set<T> s);
public static void main(String[] args) {
//直接将新创建的集合对象传给synchronizedXxx方法
//下面程序创建了4个线程安全的集合对象
Collection c = Collections.synchronizedCollection(new ArrayList());
List list = Collections.synchronizedList(new ArrayList());
Set s = Collections.synchronizedSet(new HashSet());
Map m = Collections.synchronizedMap(new HashMap());
}
设置不可变集合
Collections 提供了上述三种方法来返回一个不可变的集合。上述三类方法的参数是原有的集合对象，返回值是该集合的 "只读" 版本。
//返回一个空的、不可变的集合对象。
Set<T> emptySet()
List<T> emptyList();
Map<K,V> emptyMap();
//返回一个只包含指定对象（只有一个或一个元素）的不可变的集合对象，
Set<T> singleton(T o)
List<T> singletonList(T o);
Map<K,V> singletonMap(K key, V value);
//返回指定集合对象的不可变视图，此处的集合可以是：List，Set，Map。
Set<T> unmodifiableSet(Set<? extends T> s);
List<T> unmodifiableList(List<? extends T> list);
Map<K,V> unmodifiableMap(Map<? extends K, ? extends V> m);
public static void main(String[] args) {
//创建一个空的、不可改变的List对象
List<String> unmodifiableList = Collections.emptyList();
//创建一个只有一个元素，且不可改变的Set对象
Set unmodifiableSet = Collections.singleton("疯狂Java讲义");
//创建一个普通的Map对象
Map scores = new HashMap();
scores.put("语文" , 80);
scores.put("Java" , 82);
//返回普通Map对象对应的不可变版本
Map unmodifiableMap = Collections.unmodifiableMap(scores);
//下面任意一行代码都将引发UnsupportedOperationException异常
unmodifiableList.add("测试元素");
unmodifiableSet.add("测试元素");
unmodifiableMap.put("语文",90);
}
