Collections 工具类

Posted zongmin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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);
}













以上是关于Collections 工具类的主要内容,如果未能解决你的问题,请参考以下文章

Java源码分析集合框架-Collections工具类-Arrays工具类

Java源码分析集合框架-Collections工具类-Arrays工具类

Java集合框架:Collections工具类

Java 中Collections工具类的使用

Java难点 | Collections集合工具类

Java集合框架--Collections工具类的使用 & Java集合框架总结