【java工具】自定义封装ListUtil工具类

项目背景

        实体分别为：产品、应用，关系为产品(1) -> 应用(n)

        例如需要编辑产品，提供一个接口来更新产品及其应用，如下画了一个简易图（比较粗糙，能说明问题即可）

 

那么，我们在设计的更新接口中需要考虑以下情况（其中应用以编码为唯一标识）：

设，该产品在数据库中原有的应用集合记为A，更新后的产品应用集合为B

B中含有A中也有的应用，B中有的应用在A中没有，A中有的应用在B中没有，各种情况的操作当然也不一样。

 

用数学含义表达如下：

1）对于应用a，a∈A 且 a∈B，那么对a进行update操作

2）对于应用a，a∈A 且 a≮B，那么对a进行delete操作

3）对于应用a，a≮A 且 a∈B，那么对a进行insert操作

以上即可

 

因此以下工具类即可满足所需核心的逻辑，包含：

1）对集合元素去重；

2）对集合求交集；

3）对集合求并集；

4）求仅属于前者集合的元素集合；

5）求仅属于后者集合的元素集合；

6）集合拷贝；

7）集合空判断；

8）集合非空判断；

9）类型转换。

 

package com.cheng2839.utils;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

/**
 * 集合Utils
 * @author cheng2839
 * @date 2010年8月5日
 */
public final class ListUtils {

    /**
     * copy 列表
     * @param tList
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static  <T> List<T> copyList(List<T> tList) {
        if (isEmpty(tList))
            return new ArrayList<>(0);
        List<T> copy = new ArrayList<>(tList.size() << 1);
        copy.addAll(tList);
        return copy;
    }

    /**
     * 集合去重(按顺序保留第一个)
     * @param tList
     * @param c 比较器（比较规则）
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static  <T> List<T> removeRepeatItem(List<T> tList, Comparator<T> c) {
        if (isEmpty(tList))
            return tList;

        List<T> newList = new ArrayList<>(tList.size() << 1);
        for (int i = 0; i < tList.size(); i++) {
            T t = tList.get(i);
            boolean isNotRepeat = true;
            for (T item : newList) {
                if (c.compare(t, item) == 0) {
                    isNotRepeat = false;
                    break;
                }
            }
            if (isNotRepeat) {
                newList.add(t);
            }
        }
        return newList;
    }

    /**
     * 集合求交集
     * @param m
     * @param n
     * @param c 比较器（比较规则）
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static  <T> List<T> intersect(List<T> m, List<T> n, Comparator<T> c) {
        if (isEmpty(m) || isEmpty(n))
            return new ArrayList<>(0);

        List<T> intersectList = new ArrayList<>();
        for (int i = 0; i < m.size(); i++) {
            T tm = m.get(i);
            for (int j = 0; j < n.size(); j++) {
                T tn = n.get(j);
                if (c.compare(tm, tn) == 0) {
                    intersectList.add(tm);
                }
            }
        }
        return removeRepeatItem(intersectList, c);
    }

    /**
     * 集合求并集
     * @param m
     * @param n
     * @param c 比较器（比较规则）
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static  <T> List<T> union(List<T> m, List<T> n, Comparator<T> c) {
        if (isEmpty(m))
            return n;
        if (isEmpty(n))
            return m;

        List<T> newList = copyList(m);
        newList.addAll(n);
        return removeRepeatItem(newList, c);
    }

    /**
     * 仅存在于前者集合中的元素
     * @param m
     * @param n
     * @param c 比较器（比较规则）
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static  <T> List<T> onlyInBefore(List<T> m, List<T> n, Comparator<T> c) {
        if (isEmpty(m) || isEmpty(n))
            return m;

        List<T> beforeList = new ArrayList<>();
        for (T t : m) {
            boolean hasItem = false;
            for (T u : n) {
                if (c.compare(t, u) == 0) {
                    hasItem = true;
                    break;
                }
            }
            if (!hasItem) {
                beforeList.add(t);
            }
        }
        return beforeList;
    }

    /**
     * 仅存在于后者集合中的元素
     * @param m
     * @param n
     * @param c 比较器（比较规则）
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static  <T> List<T> onlyInAfter(List<T> m, List<T> n, Comparator<T> c) {
        return onlyInBefore(n, m, c);
    }

    /**
     * 类型转化
     * @param list
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static  <T> List<T> convertList(List<? extends T> list) {
        List<T> rsList = new ArrayList<>(list.size() << 1);
        rsList.addAll(list);
        return rsList;
    }

    /**
     * 集合空检测
     * @param list
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static <T> boolean isEmpty(List<T> list) {
        return null == list || 0 == list.size();
    }

    /**
     * 集合空检测
     * @param list
     * @param <T>
     * @return
     * @author cheng2839
     * @date 2010年8月6日
     */
    public static <T> boolean isNotEmpty(List<T> list) {
        return !isEmpty(list);
    }
}

 

 

--------------------------------本文为作者原创，若对您有帮助，请多少打赏（鼠标移至右下方火箭🚀），谢谢。

-------------------------------如需转载请备注来源：https://www.cnblogs.com/cheng2839/p/13853903.html