【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