List工具类详解

List工具类

List 工具类是 Java 中一个常用的工具类，它提供了一系列用于操作 List 的静态方法。在开发中，经常需要对 List 进行排序、查找、筛选等操作，使用 List 工具类可以让这些操作更加方便和高效。

Collections工具类

Collections是Java提供的一个工具类，主要用于操作集合类数据，提供了一系列静态方法，方便对集合进行排序、查找、替换等操作。

Collections工具类的常用方法

方法名	功能
sort(List list)	对List进行自然排序
sort(List list, Comparator<? super T> c)	根据指定比较器对List进行排序
binarySearch(List<?> list, Object key)	在已排序的List中查找指定元素
reverse(List<?> list)	反转List中的元素顺序
shuffle(List<?> list)	随机打乱List中的元素顺序
max(Collection<? extends T> coll)	返回Collection中的最大元素
min(Collection<? extends T> coll)	返回Collection中的最小元素
addAll(Collection<? super T> c, T… elements)	将多个元素添加到指定Collection中
frequency(Collection<?> c, Object o)	返回指定元素在Collection中出现的次数
isEmpty(Collection<?> c)	判断Collection是否为空
unmodifiableCollection(Collection<? extends T> c)	返回一个不可修改的Collection
synchronizedCollection(Collection c)	返回一个线程安全的Collection
disjoint(Collection<?> c1, Collection<?> c2)	判断两个集合是否没有交集。
copy(List<? super T> dest, List<? extends T> src)	将src中的所有元素复制到dest中。
fill(List<? super T> list, T obj)	用指定元素obj替换List中的所有元素。
swap(List<?> list, int i, int j)	交换List中指定位置的两个元素。

示例代码

Collections工具类常用方法的示例

import java.util.*;

public class CollectionsExample {
   
    public static void main(String[] args) {
   
        // sort(List<T> list)
        List<String> strings = new ArrayList<>(Arrays.asList("banana", "apple", "orange", "pear"));
        Collections.sort(strings);
        System.out.println(strings); // [apple, banana, orange, pear]

        // sort(List<T> list, Comparator<? super T> c)
        List<Integer> integers = new ArrayList<>(Arrays.asList(4, 2, 3, 1));
        Comparator<Integer> reverseComparator = Collections.reverseOrder();
        Collections.sort(integers, reverseComparator);
        System.out.println(integers); // [4, 3, 2, 1]

        // binarySearch(List<? extends Comparable<? super T>> list, T key)
        List<String> sortedStrings = new ArrayList<>(Arrays.asList("apple", "banana", "orange", "pear"));
        int index = Collections.binarySearch(sortedStrings, "banana");
        System.out.println(index); // 1

        // binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
        List<Integer> sortedIntegers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        Comparator<Integer> descendingComparator = Collections.reverseOrder();
        int index2 = Collections.binarySearch(sortedIntegers, 3, descendingComparator);
        System.out.println(index2); // 1

        // shuffle(List<?> list)
        List<Character> characters = new ArrayList<>(Arrays.asList('a', 'b', 'c', 'd'));
        Collections.shuffle(characters);
        System.out.println(characters); // [b, a, c, d]

        // reverse(List<?> list)
        List<String> reverseStrings = new ArrayList<>(Arrays.asList("apple", "banana", "orange", "pear"));
        Collections.reverse(reverseStrings);
        System.out.println(reverseStrings); // [pear, orange, banana, apple]

        // swap(List<?> list, int i, int j)
        List<Integer> swapIntegers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        Collections.swap(swapIntegers, 1, 3);
        System.out.println(swapIntegers); // [1, 4, 3, 2]

        // fill(List<? super T> list, T obj)
        List<Integer> fillIntegers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        Collections.fill(fillIntegers, 0);
        System.out.println(fillIntegers); // [0, 0, 0, 0]

        // copy(List<? super T> dest, List<? extends T> src)
        List<Integer> sourceIntegers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        List<Integer> destIntegers = new ArrayList<>(Arrays.asList(0, 0, 0, 0));
        Collections.copy(destIntegers, sourceIntegers);
        System.out.println