引入依赖

 <!-- https://mvnrepository.com/artifact/org.apache.commons/commons-collections4 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-collections4</artifactId>
            <version>4.4</version>
        </dependency>

方法代码示例

defaultIfNull(List list, List defaultList)

/**
     * defaultIfNull(List<T> list, List<T> defaultList)
     * Returns either the passed in list, or if the list is {@code null},
     * the value of {@code defaultList}.
     * 如果是null，则返回默认列表
     */
    @Test
    void test1() {

        // result1 = []
        List<String> list = new ArrayList<>();
        List<String> defaultList = Arrays.asList("ben", "ben", "xiong");
        List<String> result = ListUtils.defaultIfNull(list, defaultList);
        System.out.println("result1 = " + result);

        // result2 = [ben, ben, xiong]
        list = null;
        result = ListUtils.defaultIfNull(list, defaultList);
        System.out.println("result2 = " + result);
    }

emptyIfNull(List list)

/**
     * emptyIfNull(List<T> list)
     * Returns an immutable empty list if the argument is null, or the argument itself otherwise.
     * 返回一个不可改变的空列表
     */
    @Test
    void test2() {

        //result3 =[ben, ben, xiong]
        List<String> list = Arrays.asList("ben", "ben", "xiong");
        List<String> result = ListUtils.emptyIfNull(list);
        System.out.println("result3 = " + result);

        //result4 = []
        result = ListUtils.emptyIfNull(null);
        System.out.println("result4 = " + result);

        //result5 = []
        list = null;
        result = ListUtils.emptyIfNull(list);
        System.out.println("result5 = " + result);

        //异常：java.lang.UnsupportedOperationException
        result.add("name");
        System.out.println("result6 = " + result);
    }

fixedSizeList(List list)

/**
     * fixedSizeList(List<E> list)
     * Returns a fixed-sized list backed by the given list.
     * 返回一个固定大小的列表，返回的列表不可增加或删除元素，但是可以修改元素
     */
    @Test
    public void test3() {
        // result7 = [ben, ben, xiong]
        List<String> list = Arrays.asList("ben", "ben", "xiong");
        List<String> result = ListUtils.fixedSizeList(list);
        System.out.println("result7 = " + result);

        // 异常: java.lang.UnsupportedOperationException: List is fixed size
        //result.add("newEle");
        // System.out.println("result = " + result);[视频号]Happiness5307的动态

        // 异常: java.lang.UnsupportedOperationException: List is fixed size
        //result.remove(0);
        //System.out.println("result = " + result);

        // result7 = [ben, ben, xiong2]
        result.set(2, "xiong2");
        System.out.println("result = " + result);
    }

hashCodeForList(Collection<?> list)

/**
     * hashCodeForList(Collection<?> list)
     * Generates a hash code using the algorithm specified in List.hashCode().
     * 使用List.hashCode()中指定的算法生成一个哈希代码。
     */
    @Test
    public void test4() {
        //hashCode = 210730198
        List<String> list = Arrays.asList("ben", "ben", "xiong");
        int hashCode = ListUtils.hashCodeForList(list);
        System.out.println("hashCode = " + hashCode);
    }

indexOf(List list, Predicate predicate)

/**
     * indexOf(List<E> list, Predicate<E> predicate)
     * Finds the first index in the given List which matches the given predicate.
     * 返回第一个根据predicate找到的索引
     * predicate是collections4包中自带的
     */

    @Test
    public void test5() {
        // index = 0
        List<String> list = Arrays.asList("ben", "ben", "xiong");
        list.add("fei");
        System.out.println(list);
        Predicate<String> p = e -> e.length() == 3;
        int index = ListUtils.indexOf(list, p);
        System.out.println("index = " + index);
    }

intersection(List<? extends E> list1, List<? extends E> list2)

/**
     * intersection(List<? extends E> list1, List<? extends E> list2)
     * Returns a new list containing all elements that are contained in both given lists.
     * 返回两个列表的交集，如果找不到交集，则返回空集，而不是null
     */
    @Test
    public void Test6() {
        //result1 = [3, 4, 5, 6]
        //result2 = []
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> list2 = Arrays.asList(3, 4, 5, 6, 7, 8);
        List<Integer> list3 = Arrays.asList(7, 8, 9, 10);
        List<Integer> res_list1 = ListUtils.intersection(list1, list2);
        List<Integer> res_list2 = ListUtils.intersection(list1, list3);
        System.out.println("result1 = " + res_list1);
        System.out.println("result2 = " + res_list2);
    }

isEqualList(Collection<?> list1, Collection<?> list2)

/**
     * isEqualList(Collection<?> list1, Collection<?> list2)
     * Tests two lists for value-equality as per the equality contract in List.equals(java.lang.Object).
     * 比较两个列表的所有对应元素是否都相等，如果都相等返回true，如果有不相等或者元素个数不一致则返回false
     */
    @Test
    public void test7() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        boolean equalList = ListUtils.isEqualList(list, list1);
        System.out.println(equalList);

        List<String> list2 = Arrays.asList("A", "B", "C");
        List<String> list3 = Arrays.asList("A", "B", "C");
        List<String> list4 = Arrays.asList("A", "C", "B");
        System.out.println(ListUtils.isEqualList(list2, list3));
        System.out.println(ListUtils.isEqualList(list2, list4));
    }

longestCommonSubsequence(CharSequence a, CharSequence b)

/**
     * longestCommonSubsequence(CharSequence a, CharSequence b)
     * Returns the longest common subsequence (LCS) of two CharSequence objects.
     * 返回两个字符串中公共字符并组成新串
     */
    @Test
    public void test10() {
        CharSequence cs = "hello";
        CharSequence cs1 = "llogu";
        System.out.println(ListUtils.longestCommonSubsequence(cs, cs1));
    }

longestCommonSubsequence(List a, List b)

/**
     * longestCommonSubsequence(List<E> a, List<E> b)
     * Returns the longest common subsequence (LCS) of two sequences (lists).
     * 返回两个列表中的公共元素，并组成新列表
     */
    @Test
    public void test11() {
        List<String> list = Arrays.asList("A", "B", "C", "D");
        List<String> list1 = Arrays.asList("B", "C");
        List<String> res_list = ListUtils.longestCommonSubsequence(list, list1);
        System.out.println("result = " + res_list);
    }

longestCommonSubsequence(List a, List b, Equator<? super E> equator)

/**
     * longestCommonSubsequence(List<E> a, List<E> b, Equator<? super E> equator)
     * Returns the longest common subsequence (LCS) of two sequences (lists).
     * 返回两个序列(列表)的最长公共子序列(LCS)。
     */
    @Test
    public void test12() {
        Equator<String> equator = new Equator<String>() {
            @Override
            public boolean equate(String o1, String o2) {
                return o1.equals(o2);
            }

            @Override
            public int hash(String o) {
                return o.hashCode();
            }
        };

        List<String> list1 = Arrays.asList("2", "1", "4", "3", "5", "6", "3");
        List<String> list2 = Arrays.asList("1", "3", "7");

        List<String> result = ListUtils.longestCommonSubsequence(list1, list2, equator);
        System.out.println("result = " + result); // result = [1, 3]
    }

partition(List list, int size)

/**
     * partition(List<T> list, int size)
     * Returns consecutive sublists of a list, each of the same size (the final list may be smaller).
     * 返回列表的连续子列表，每个子列表的大小相同(最终列表可能更小)。
     */
    @Test
    public void test13() {
        List<String> list = new ArrayList<>();
        String[] arr = {"1", "2", "3", "4", "5"};
        CollectionUtils.addAll(list, arr);

        List<List<String>> result = ListUtils.partition(list, 3);
        System.out.println("result = " + result); // result = [[1, 2, 3], [4, 5]]
    }

predicatedList(List list, Predicate predicate)

/**
     * predicatedList(List<E> list, Predicate<E> predicate)
     * Returns a predicated (validating) list backed by the given list.
     * 校验整个列表元素是否都满足指定的规则
     */
    @Test
    public void test14() {
        List<Integer> list = new ArrayList<>();
        Integer[] arr = {3, 4, 5};
        /*for (Integer a : arr) {
            list.add(a);
        }*/
        CollectionUtils.addAll(list,arr);

        Predicate<Integer> predicate = e -> e.intValue() >= 3;
        List<Integer> result = ListUtils.predicatedList(list, predicate);
        System.out.println("result = " + result); // result = [3, 4, 5]
        predicate = e -> e.intValue() >= 4;
        result = ListUtils.predicatedList(list, predicate);
        System.out.println("result = " + result); // java.lang.IllegalArgumentException: Cannot add Object '3'
    }

removeAll(Collection collection, Collection<?> remove)

/**
     * removeAll(Collection<E> collection, Collection<?> remove)
     * Removes the elements in remove from collection.
     * 两个列表相减，返回差集，原两个列表保持不变
     */
    @Test
    public void test15() {
        List<String> list1 = Arrays.asList("1", "2", "3", "4", "5");
        List<String> list2 = Arrays.asList("2", "3", "4");
        List<String> result = ListUtils.removeAll(list1, list2);
        System.out.println("list1 = " + list1); // list1 = [1, 2, 3, 4, 5]
        System.out.println("list2 = " + list2); // list2 = [2, 3, 4]
        System.out.println("result = " + result); // result = [1, 5]
    }

retainAll(Collection collection, Collection<?> retain)

/**
     * 	retainAll(Collection<E> collection, Collection<?> retain)
     * Returns a List containing all the elements in collection that are also in retain.
     * 取交集，和intersection比较
     */
    @Test
    public void test16() {
        List<String> list1 = Arrays.asList("1", "2", "3", "4", "5");
        List<String> list2 = Arrays.asList("2", "3", "41");
        List<String> result = ListUtils.retainAll(list1, list2);
        System.out.println("list1 = " + list1); // list1 = [1, 2, 3, 4, 5]
        System.out.println("list2 = " + list2); // list2 = [2, 3, 41]
        System.out.println("result = " + result); // result = [2, 3]

        result = ListUtils.intersection(list1, list2);
        System.out.println("result = " + result); // result = [2, 3]
    }

select(Collection<? extends E> inputCollection, Predicate<? super E> predicate)

/**
     * select(Collection<? extends E> inputCollection, Predicate<? super E> predicate)
     * Selects all elements from input collection which match the given predicate into an output list.
     * 相当于stream的filter + toList功能
     */
    @Test
    public void test17() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> result = ListUtils.select(list, e -> e > 2);
        System.out.println("result = " + result); // result = [3, 4, 5]
        System.out.println("list = " + list); // list = [1, 2, 3, 4, 5]
    }

selectRejected(Collection<? extends E> inputCollection, Predicate<? super E> predicate)

/**
     * selectRejected(Collection<? extends E> inputCollection, Predicate<? super E> predicate)
     * Selects all elements from inputCollection which don't match the given predicate into an output collection.
     * 相当于ListUtils.select的补集
     */
    @Test
    public void test18() {
        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> result = ListUtils.selectRejected(list, e -> e > 2);
        System.out.println("result = " + result); // result = [1, 2]
    }

subtract(List list1, List<? extends E> list2)

/**
     * subtract(List<E> list1, List<? extends E> list2)
     * Subtracts all elements in the second list from the first list, placing the results in a new list.
     * 第一个list减去第二个list；原来两个list保持不变
     */
    @Test
    public void test19() {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list2 = Arrays.asList(2, 3, 4);
        List<Integer> result = ListUtils.subtract(list1, list2);
        System.out.println("list1 = " + list1); // list1 = [1, 2, 3, 4, 5]
        System.out.println("list2 = " + list2); // list2 = [2, 3, 4]
        System.out.println("result = " + result); // result = [1, 5]
    }

sum(List<? extends E> list1, List<? extends E> list2)

/**
     * 	sum(List<? extends E> list1, List<? extends E> list2)
     * Returns the sum of the given lists.
     * 返回一个不重复的列表
     */
    @Test
    public void test20() {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5, 3);
        List<Integer> list2 = Arrays.asList(2, 3, 4);
        List<Integer> result = ListUtils.sum(list1, list2);
        System.out.println("result = " + result); // result = [1, 5, 3, 2, 3, 4]
    }

synchronizedList(List list)

/**
     * synchronizedList(List<E> list)
     * Returns a synchronized list backed by the given list.
     * 返回由给定列表支持的同步列表
     */
    @Test
    public void test21() {
        List<String> list = Arrays.asList("ben", "ben", "xiong");
        List<String> result = ListUtils.synchronizedList(list);
        System.out.println("result = " + result); // result = [ben, ben, xiang]
        //修改list,result也会改变
        list.set(0,"ben1");
        System.out.println("result = " + result);
    }

transformedList(List list, Transformer<? super E,? extends E> transformer)

/**
     * transformedList(List<E> list, Transformer<? super E,? extends E> transformer)
     * Returns a transformed list backed by the given list.
     * 注意：Transformer<? super E,? extends E>
     */
    @Test
    public void test22() {
        List<String> list = new ArrayList<>();
        String[] arr = {"ben", "ben", "xiong"};
        CollectionUtils.addAll(list, arr);

        List<String> result = ListUtils.transformedList(list, CharSequence::toString);
        System.out.println("result = " + result); // result = [ben, ben, xiong]
    }

union(List<? extends E> list1, List<? extends E> list2)

/**
     * union(List<? extends E> list1, List<? extends E> list2)
     * Returns a new list containing the second list appended to the first list.
     * 真正的相加，第二个list追加到第一个list的后面，不会去重
     */
    @Test
    public void test23() {
        List<Integer> list1 = Arrays.asList(1, 2, 3, 4, 5);
        List<Integer> list2 = Arrays.asList(2, 3, 4);
        List<Integer> result = ListUtils.union(list1, list2);
        System.out.println("result = " + result); // result = [1, 2, 3, 4, 5, 2, 3, 4]
    }

unmodifiableList(List<? extends E> list)

/**
     * unmodifiableList(List<? extends E> list)
     * Returns an unmodifiable list backed by the given list.
     * 不可添加，但可以删除和修改值
     */
    @Test
    public void test24() {
        List<Integer> list = new ArrayList<>();
        Integer[] arr = {1, 2, 3, 4, 5};
        CollectionUtils.addAll(list, arr);
        System.out.println("list = " + list); // list = [1, 2, 3, 4, 5]
        List<Integer> result = ListUtils.unmodifiableList(list);
        list.remove(new Integer(5));
        list.set(0, 2);
        System.out.println("result = " + result); // result = [2, 2, 3, 4]
        result.add(6); // java.lang.UnsupportedOperationException
    }