List工具类详解

最新推荐文章于 2025-03-31 08:15:00 发布

参果

最新推荐文章于 2025-03-31 08:15:00 发布

阅读量1.8k

点赞数 1

分类专栏： Java 文章标签： java

本文链接：https://blog.csdn.net/guodong_99/article/details/130422495

版权

Java 专栏收录该内容

5 篇文章

订阅专栏

本文详细介绍了Java中的List工具类，包括Collections、Arrays、Guava和Apache Commons Collections等，提供了各种方法的示例，如排序、查找、筛选等操作，帮助开发者更高效地操作List。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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(destIntegers); // [1, 2, 3, 4]

        // max(Collection<? extends T> coll)
        List<Integer> maxIntegers = new ArrayList<>(Arrays.asList(1, 2, 3, 4));
        Integer max = Collections.max(maxIntegers);
        System.out.println(max); // 4

        // min(Collection<? extends T> coll)
        List<Integer> numbers = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6);
        Integer min = Collections.min(maxIntegers);
        System.out.println(max);

        // frequency(Collection<?> c, Object o)
        List<Integer> freqnum = Arrays.asList(3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5);
        int freq = Collections.frequency(numbers, 5);
        System.out.println(freq); // Output: 3

        // disjoint(Collection<?> c1, Collection<?> c2)
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list2 = Arrays.asList(6, 7, 8, 9, 10);
        boolean disjoint1 = Collections.disjoint(list1, list2);
        System.out.println(disjoint1); // Output: true

        List<String> list3 = Arrays.asList("apple", "banana", "cat");
        List<String> list4 = Arrays.asList("dog", "elephant", "fish");
        boolean disjoint2 = Collections.disjoint(list3, list4);
        System.out.println(disjoint2); // Output: true
    }
}

使用不可变的列表示例代码

import java.util.*;

public class CollectionsExample {
    public static void main(String[] args) {
        // 创建一个包含若干元素的不可变列表
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        // 使用 Collections.unmodifiableList() 方法包装该列表，返回不可修改的列表视图
        List<Integer> unmodifiableList = Collections.unmodifiableList(numbers);
        System.out.println("不可修改的列表视图：");
        System.out.println(unmodifiableList);

        // 尝试修改该列表，会抛出 UnsupportedOperationException 异常
        try {
            unmodifiableList.set(0, 0);
        } catch (UnsupportedOperationException e) {
            System.out.println("修改不可修改的列表视图会抛出 UnsupportedOperationException 异常");
        }

        // 创建一个线程安全的列表
        List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());
        // 对该列表进行操作时，会获得锁，保证线程安全
        synchronized (synchronizedList) {
            synchronizedList.add(1);
            synchronizedList.add(2);
            synchronizedList.add(3);
        }

        // 使用 Collections.newSetFromMap() 方法创建一个线程安全的集合
        Set<Integer> synchronizedSet = Collections.newSetFromMap(new ConcurrentHashMap<>());
        // 对该集合进行操作时，会获得锁，保证线程安全
        synchronized (synchronizedSet) {
            synchronizedSet.add(1);
            synchronizedSet.add(2);
            synchronizedSet.add(3);
        }

        // 创建一个只读的空列表
        List<Integer> emptyList = Collections.emptyList();
        System.out.println("只读的空列表：");
        System.out.println(emptyList);

        // 创建一个只读的空集合
        Set<Integer> emptySet = Collections.emptySet();
        System.out.println("只读的空集合：");
        System.out.println(emptySet);

        // 创建一个只读的空映射
        Map<Integer, String> emptyMap = Collections.emptyMap();
        System.out.println("只读的空映射：");
        System.out.println(emptyMap);
    }
}

定义了一个名为 result 的变量，并用 Collections.emptyList() 方法将其初始化为一个空的不可变的列表。Collections.emptyList() 方法返回一个空列表的不可变视图，该视图不允许进行添加或删除操作，但可以进行读取操作。此处使用不可变的空列表可以减少内存使用和提高性能，因为它们不需要分配额外的内存来存储元素。

Arrays工具类

Java提供的一个数组工具类，包含了许多静态方法，可以将数组转换成List、将List转换成数组、排序等操作。

Arrays工具类常用方法

方法	描述
Arrays.sort(array)	对数组进行排序。
Arrays.binarySearch(array, key)	在有序数组中查找指定元素。
Arrays.copyOf(array, length)	复制指定数组，截取或填充空缺部分。
Arrays.fill(array, value)	将指定值填充到数组中的每个元素。
Arrays.equals(array1, array2)	比较两个数组是否相等。
Arrays.toString(array)	将数组转换为字符串输出。

示例代码

常用方法的示例代码

import java.util.Arrays;

public class ArraysExample {
    public static void main(String[] args) {
        int[] numbers = {5, 1, 3, 2, 4};

        // 排序
        Arrays.sort(numbers);
        System.out.println("排序后的数组：" + Arrays.toString(numbers));

        // 查找元素
        int index = Arrays.binarySearch(numbers, 3);
        System.out.println("元素 3 的索引为：" + index);

        // 复制数组
        int[] copyNumbers = Arrays.copyOf(numbers, 3);
        System.out.println("截取前三个元素后的数组：" + Arrays.toString(copyNumbers));

        // 填充数组
        Arrays.fill(numbers, 0);
        System.out.println("填充后的数组：" + Arrays.toString(numbers));

        // 比较数组
        int[] anotherNumbers = {5, 1, 3, 2, 4};
        boolean isEqual = Arrays.equals(numbers, anotherNumbers);
        System.out.println("两个数组是否相等：" + isEqual);

        // 数组转字符串
        String numbersStr = Arrays.toString(numbers);
        System.out.println("数组转换为字符串：" + numbersStr);
    }
}

使用Arrays工具类进行数组操作

import java.util.Arrays;

public class ArraysExample {
    public static void main(String[] args) {
        // 创建一个长度为10的随机整数数组
        int[] array = new int[10];
        for (int i = 0; i < array.length; i++) {
            array[i] = (int) (Math.random() * 100);
        }
        System.out.println("随机数组：" + Arrays.toString(array));

        // 对数组进行排序
        Arrays.sort(array);
        System.out.println("排序后的数组：" + Arrays.toString(array));

        // 查找指定元素在数组中的索引
        int key = 50;
        int index = Arrays.binarySearch(array, key);
        if (index < 0) {
            System.out.println(key + "不在数组中");
        } else {
            System.out.println(key + "在数组中的索引为：" + index);
        }

        // 复制数组，截取或填充空缺部分
        int[] copy1 = Arrays.copyOf(array, 5);
        System.out.println("复制数组前5个元素：" + Arrays.toString(copy1));
        int[] copy2 = Arrays.copyOf(array, 15);
        System.out.println("复制数组并填充空缺部分：" + Arrays.toString(copy2));

        // 填充数组中的每个元素
        int[] filled = new int[5];
        Arrays.fill(filled, 10);
        System.out.println("填充后的数组：" + Arrays.toString(filled));

        // 比较两个数组是否相等
        int[] array1 = {1, 2, 3};
        int[] array2 = {1, 2, 3};
        int[] array3 = {1, 3, 2};
        System.out.println("数组1和数组2是否相等：" + Arrays.equals(array1, array2));
        System.out.println("数组1和数组3是否相等：" + Arrays.equals(array1, array3));

        // 将数组转换成字符串输出
        System.out.println("数组转换成字符串：" + Arrays.toString(array));
    }
}

Guava工具类

Java工具库，提供了许多实用的工具类和数据类型，包括集合、缓存、并发、字符串处理、IO等等

Guava工具类常用方法

方法	描述
`Joiner`	提供了各种方式将字符串拼接起来。
`Splitter`	用于将字符串拆分成不同的部分。
`CharMatcher`	提供了各种字符匹配器，用于在字符串中查找或过滤字符。
`CaseFormat`	用于格式化不同大小写的字符串。
`Ordering`	提供了各种排序器，用于对集合中的元素进行排序。
`Iterables`	提供了各种操作集合的方法，如过滤、转换等。
`Lists`	提供了各种操作列表的方法，如反转、分区等。
`Maps`	提供了各种操作映射的方法，如过滤、转换等。
`Sets`	提供了各种操作集合的方法，如交集、差集等。
`Multisets`	提供了各种操作可重复集合的方法，如计数、去重等。
`Cache`	提供了缓存实现的类。
`EventBus`	提供了事件总线的实现。

Lists工具类

Lists.newArrayList(E… elements)：创建一个包含指定元素的ArrayList实例。

mathematicaCopy code
List<String> list = Lists.newArrayList("apple", "banana", "orange");

Lists.partition(List list, int size)：将一个列表分成指定大小的多个子列表。

luaCopy codeList<Integer> list = Lists.newArrayList(1, 2, 3, 4, 5, 6, 7);
List<List<Integer>> partitionedList = Lists.partition(list, 3);
System.out.println(partitionedList); // [[1, 2, 3], [4, 5, 6], [7]]

Maps工具类

Maps.newHashMap()：创建一个HashMap实例。

arduinoCopy codeMap<String, Integer> map = Maps.newHashMap();
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
System.out.println(map); // {apple=1, banana=2, orange=3}

Maps.uniqueIndex(Iterable values, Function<? super T,K> keyFunction)：将一个集合转换为Map，key为指定的属性，value为集合中的元素。

perlCopy codeList<Student> students = Lists.newArrayList(
        new Student("Tom", "Male"),
        new Student("Jerry", "Male"),
        new Student("Lucy", "Female")
);
Map<String, Student> map = Maps.uniqueIndex(students, Student::getName);
System.out.println(map); // {Tom=Student{name='Tom', gender='Male'}, Jerry=Student{name='Jerry', gender='Male'}, Lucy=Student{name='Lucy', gender='Female'}}

Strings工具类

Strings.isNullOrEmpty(String str)：判断一个字符串是否为空或null。

csharpCopy codeString str1 = "";
String str2 = null;
System.out.println(Strings.isNullOrEmpty(str1)); // true
System.out.println(Strings.isNullOrEmpty(str2)); // true

Strings.padStart(String str, int minLength, char padChar)：将一个字符串填充到指定长度，如果不足则在前面填充指定字符。

rustCopy codeString str = "123";
String paddedStr = Strings.padStart(str, 5, '0');
System.out.println(paddedStr); // 00123

Files工具类

Files.write(byte[] bytes, File file)：将字节数组写入文件中。

arduinoCopy codebyte[] data = "Hello, world!".getBytes();
File file = new File("hello.txt");
Files.write(data, file);

Files.readLines(File file, Charset charset)：读取文件中的所有行，返回一个List。

arduinoCopy codeFile file = new File("hello.txt");
List<String> lines = Files.readLines(file, Charsets.UTF_8);
System.out.println(lines); // [Hello, world!]

以上只是Guava工具类的一部分，Guava提供了许多其他实用的工具类和数据类型，可以根据具体需求查阅Guava官方文档。

Apache Commons Collections工具类

一个集合工具类，包含了许多静态方法，可以对List进行排序、查找、替换、反转、打乱等操作。

Apache Commons Collections工具类常用方法

工具类	方法	描述
CollectionUtils	union(collection1, collection2)	返回两个集合的并集
CollectionUtils	intersection(collection1, collection2)	返回两个集合的交集
CollectionUtils	subtract(collection1, collection2)	返回集合1中有，但集合2中没有的元素集合
CollectionUtils	isEmpty(collection)	判断集合是否为空
CollectionUtils	isNotEmpty(collection)	判断集合是否非空
CollectionUtils	select(collection, predicate)	返回符合条件的元素集合
CollectionUtils	transform(collection, transformer)	对集合中的元素进行转换
ListUtils	partition(list, size)	将列表按指定大小分割成多个子列表
MapUtils	isEmpty(map)	判断映射是否为空
MapUtils	isNotEmpty(map)	判断映射是否非空
MapUtils	invertMap(map)	返回键值对中键和值互换的映射
SetUtils	union(set1, set2)	返回两个集合的并集
SetUtils	intersection(set1, set2)	返回两个集合的交集
SetUtils	subtract(set1, set2)	返回集合1中有，但集合2中没有的元素集合
SetUtils	isEqualSet(set1, set2)	判断两个集合是否相等
ArrayUtils	contains(array, valueToFind)	判断数组中是否包含指定元素
ArrayUtils	indexOf(array, valueToFind)	返回指定元素在数组中的位置
ArrayUtils	add(array, element)	向数组中添加元素
ArrayUtils	remove(array, index)	删除数组中指定位置的元素
ArrayUtils	clone(array)	克隆一个数组
ArrayUtils	isEmpty(array)	判断数组是否为空
ArrayUtils	isNotEmpty(array)	判断数组是否非空

注：上述方法并非 Apache Commons Collections 所有工具类中的所有方法，仅列举部分常用方法供参考。

示例代码

Apache Commons Collections 工具类常用方法的示例代码

import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.MapUtils;

import java.util.*;

public class CommonsCollectionsExample {
    public static void main(String[] args) {
        // 创建一个包含若干元素的列表
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list2 = Arrays.asList(4, 5, 6, 7, 8);

        // 取两个列表的交集
        Collection<Integer> intersection = CollectionUtils.intersection(list1, list2);
        System.out.println("交集：");
        System.out.println(intersection);

        // 取两个列表的并集
        Collection<Integer> union = CollectionUtils.union(list1, list2);
        System.out.println("并集：");
        System.out.println(union);

        // 取两个列表的差集
        Collection<Integer> difference = CollectionUtils.subtract(list1, list2);
        System.out.println("差集：");
        System.out.println(difference);

        // 判断一个列表是否为空或 null
        boolean emptyList = CollectionUtils.isEmpty(list1);
        System.out.println("list1 是否为空或 null：" + emptyList);

        // 创建一个包含若干元素的映射
        Map<String, Integer> map = new HashMap<>();
        map.put("A", 1);
        map.put("B", 2);
        map.put("C", 3);

        // 判断一个映射是否为空或 null
        boolean emptyMap = MapUtils.isEmpty(map);
        System.out.println("map 是否为空或 null：" + emptyMap);

        // 获取映射中指定 key 对应的 value，如果不存在则返回默认值
        int value = MapUtils.getIntValue(map, "D", 0);
        System.out.println("key D 对应的 value：" + value);
    }
}

双向映射、有序Set和固定大小的队列

import org.apache.commons.collections4.BidiMap;
import org.apache.commons.collections4.bidimap.DualHashBidiMap;
import org.apache.commons.collections4.queue.CircularFifoQueue;
import org.apache.commons.collections4.set.ListOrderedSet;

import java.util.Queue;

public class CommonsCollectionsExample {
    public static void main(String[] args) {
        // 创建一个双向映射，可以通过key获取value，也可以通过value获取key
        BidiMap<String, String> bidiMap = new DualHashBidiMap<>();
        bidiMap.put("key1", "value1");
        bidiMap.put("key2", "value2");
        bidiMap.put("key3", "value3");
        System.out.println("双向映射：");
        System.out.println(bidiMap);
        // 通过value获取key
        System.out.println("value为value2的key：" + bidiMap.getKey("value2"));

        // 创建一个有序Set
        ListOrderedSet<String> orderedSet = new ListOrderedSet<>();
        orderedSet.add("b");
        orderedSet.add("a");
        orderedSet.add("c");
        System.out.println("有序Set：");
        System.out.println(orderedSet);

        // 创建一个固定大小的队列
        Queue<Integer> fixedSizeQueue = new CircularFifoQueue<>(3);
        fixedSizeQueue.offer(1);
        fixedSizeQueue.offer(2);
        fixedSizeQueue.offer(3);
        System.out.println("固定大小的队列（添加3个元素）：");
        System.out.println(fixedSizeQueue);
        fixedSizeQueue.offer(4);
        System.out.println("固定大小的队列（再添加1个元素，将把队首的元素移除）：");
        System.out.println(fixedSizeQueue);
    }
}