集合对象的一些助手工具类

小鱼儿 2022-06-05 02:18 110阅读 0赞

package com.opslab.helper;  
  
  
import com.opslab.functions.ObjectHandler;  
import com.opslab.functions.ObjectProcess;  
import com.opslab.util.valid;  
  
  
import java.util.\*;  
  
  
/\*\*  
 \* 集合对象的一些助手工具类  
 \*/  
public final class CollectionHelper \{  
    private  static org.apache.log4j.Logger logger = org.apache.log4j.Logger.getLogger(CollectionHelper.class);  
  
  
    /\*\*  
     \* 对集合中元素进行特定的处理  
     \*  
     \* @param collection 集合  
     \* @param handler    实现特定处理的方法  
     \* @param <T>        泛型  
     \*/  
    public static <T> void handler( Collection<T> collection, ObjectHandler<T> handler) \{  
        if(collection == null || collection.size() == 0)\{  
            logger.error("collection is empty or is null");  
            return;  
        \}  
        for (T t : collection) \{  
            handler.handler(t);  
        \}  
    \}  
  
  
    /\*\*  
     \* 对集合中的元素进行特定的处理，并获得处理后的结果  
     \*  
     \* @param collection 待处理的集合  
     \* @param result     接受处理后结果的集合  
     \* @param process    实现的特定处理  
     \* @param <T>        泛型  
     \* @param <E>        泛型  
     \*/  
    public static <T, E> void process( Collection<T> collection,  Collection<E> result, ObjectProcess<T, E> process) \{  
        if(collection == null || collection.size() == 0)\{  
            logger.error("collection is empty or is null");  
            return;  
        \}  
        if(result == null || result.size() == 0)\{  
            logger.error("receive collection is empty or is null");  
            return;  
        \}  
        for (T t : collection) \{  
            E next = process.process(t);  
            if (next != null) \{  
                result.add(next);  
            \}  
        \}  
    \}  
  
  
    /\*\*  
     \* 去除重复元素  
     \*  
     \* @param list 需要处理的list  
     \* @param <T>  泛型方法  
     \* @return 去重后的list  
     \*/  
    public static <T> List<T> removeDuplicate(List<T> list) \{  
        if (list == null || list.size() == 0) \{  
            logger.error("list is empty or is null");  
            return new ArrayList<>();  
        \}  
        return new ArrayList<>(new HashSet<>(list));  
  
  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的交集  
     \*/  
    public static <T> List<T> intersection(List<T> list1, List<T> list2) \{  
        if (valid.valid(list1, list2)) \{  
            Set<T> set = new HashSet<>(list1);  
            set.retainAll(list2);  
            return new ArrayList<>(set);  
        \}  
        return new ArrayList<>();  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的交集  
     \*  
     \* @param set1 集合  
     \* @param set2 集合  
     \* @param <T>  泛型  
     \* @return 交集  
     \*/  
    public static <T> Set<T> intersection(Set<T> set1, Set<T> set2) \{  
        if (valid.valid(set1, set2)) \{  
            List<T> list = new ArrayList<>(set1);  
            list.retainAll(set2);  
            return new HashSet<>(list);  
        \}  
        return new HashSet<>();  
    \}  
  
  
    /\*\*  
     \* 求队列的交集  
     \*  
     \* @param queue1 队列  
     \* @param queue2 队列  
     \* @param <T>    泛型  
     \* @return 交集  
     \*/  
    public static <T> Queue<T> intersection(Queue<T> queue1, Queue<T> queue2) \{  
        if (valid.valid(queue1, queue2)) \{  
            Set<T> set = new HashSet<>(queue1);  
            set.retainAll(queue2);  
            return new LinkedList<>(set);  
        \}  
        return new LinkedList<>();  
    \}  
  
  
    /\*\*  
     \* Map集合的交集只提供键的交集  
     \*  
     \* @param map1 map  
     \* @param map2 map  
     \* @param <K>  泛型  
     \* @param <V>  泛型  
     \* @return 交集  
     \*/  
    public static <K, V> Map<K, V> intersection(Map<K, V> map1, Map<K, V> map2) \{  
        Map<K, V> map = new HashMap<>(map1.size());  
        if (valid.valid(map1, map2)) \{  
            Set<K> setkey1 = new HashSet<>(map1.keySet());  
            Set<K> setkey2 = new HashSet<>(map2.keySet());  
            setkey1.retainAll(setkey2);  
            for (K k : setkey1) \{  
                map.put(k, map1.get(k));  
            \}  
        \}  
        return map;  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的并集  
     \*/  
    public static <T> List<T> unicon(List<T> list1, List<T> list2) \{  
        List<T> list = new ArrayList<>();  
        list.addAll(list1);  
        list.addAll(list2);  
        return list;  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的交集  
     \*  
     \* @param set1 set  
     \* @param set2 set  
     \* @param <T>  泛型  
     \* @return 交集  
     \*/  
    public static <T> Set<T> unicon(Set<T> set1, Set<T> set2) \{  
        set1.addAll(set2);  
        return set1;  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的交集  
     \*  
     \* @param queue1 队列  
     \* @param queue2 队列  
     \* @param <T>    泛型  
     \* @return 交集  
     \*/  
    public static <T> Queue<T> unicon(Queue<T> queue1, Queue<T> queue2) \{  
        queue1.addAll(queue2);  
        return queue1;  
    \}  
  
  
    /\*\*  
     \* 求俩个map的交集  
     \*  
     \* @param map1 map  
     \* @param map2 map  
     \* @param <K>  泛型  
     \* @param <V>  泛型  
     \* @return 交集  
     \*/  
    public static <K, V> Map<K, V> unicon(Map<K, V> map1, Map<K, V> map2) \{  
        Map<K, V> map = new HashMap<>(map1.size() + map2.size());  
        map.putAll(map1);  
        map.putAll(map2);  
        return map;  
    \}  
  
  
  
  
    /\*\*  
     \* 求俩个集合的差集  
     \*/  
    public static <T> List<T> subtract(List<T> list1, List<T> list2) \{  
        List<T> list = new ArrayList<>(list1.size() + list2.size());  
        if (valid.valid(list1)) \{  
            list.addAll(list1);  
            list.removeAll(list2);  
        \}  
        return list;  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的差集  
     \*  
     \* @param set1 set  
     \* @param set2 set  
     \* @param <T>  T  
     \* @return 差集  
     \*/  
    public static <T> Set<T> subtract(Set<T> set1, Set<T> set2) \{  
        Set<T> set = new HashSet<>(set1.size() + set2.size());  
        if (valid.valid(set1)) \{  
            set.addAll(set1);  
            set.removeAll(set2);  
        \}  
        return set;  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的差集  
     \*  
     \* @param queue1 队列  
     \* @param queue2 队列  
     \* @param <T>    泛型  
     \* @return 差集  
     \*/  
    public static <T> Queue<T> subtract(Queue<T> queue1, Queue<T> queue2) \{  
        Queue<T> queue = new LinkedList<>();  
        if (valid.valid(queue1)) \{  
            queue.addAll(queue1);  
            queue.removeAll(queue2);  
        \}  
        return queue;  
    \}  
  
  
    /\*\*  
     \* 求俩个集合的差集  
     \*  
     \* @param map1 map  
     \* @param map2 map  
     \* @param <K>  泛型  
     \* @param <V>  泛型  
     \* @return 差集  
     \*/  
    public static <K, V> Map<K, V> subtract(Map<K, V> map1, Map<K, V> map2) \{  
        Map<K, V> map = new HashMap<>(map1.size() + map2.size());  
        if (valid.valid(map1, map2)) \{  
            Set<K> setkey1 = new HashSet<>(map1.keySet());  
            Set<K> setkey2 = new HashSet<>(map2.keySet());  
            for (K k : setkey2) \{  
                setkey1.remove(k);  
            \}  
            for (K k : setkey1) \{  
                map.put(k, map1.get(k));  
            \}  
        \}  
        return map;  
  
  
    \}  
  
  
    /\*\*  
     \* 将List以separator链接并以字符串的形式返回  
     \*  
     \* @param collection collection  
     \* @param separator  连接符  
     \* @param <T>        泛型  
     \* @return 差集  
     \*/  
    public static <T> String join(Collection<T> collection, String separator) \{  
        StringBuilder sb = new StringBuilder();  
        for (T t : collection) \{  
            sb.append(t.toString()).append(separator);  
        \}  
        return sb.toString().substring(0, sb.toString().length() - 1);  
    \}  
  
  
  
  
    /\*\*  
     \* 将Map以separator链接并以字符串的形式返回  
     \*  
     \* @return 字符串  
     \*/  
    public static <K, V> String join(Map<K, V> map, String separator, String separator1) \{  
        if (map == null || map.size() == 0) \{  
            return "";  
        \}  
        StringBuilder sb = new StringBuilder();  
        for (Map.Entry<K, V> entry : map.entrySet()) \{  
            sb.append(String.valueOf(entry.getKey())).append(separator1)  
                    .append(String.valueOf(entry.getValue())).append(separator);  
        \}  
        return sb.toString().substring(0, sb.toString().length() - separator.length());  
    \}  
  
  
    /\*\*  
     \* 将map的key以separator链接并以字符串的形式返回  
     \*  
     \* @param map       map  
     \* @param separator 连接符  
     \* @param <K>       泛型  
     \* @param <V>       泛型  
     \* @return 字符串  
     \*/  
    public static <K, V> String keyJoin(Map<K, V> map, String separator) \{  
        StringBuilder sb = new StringBuilder();  
        for (Map.Entry<K, V> entry : map.entrySet()) \{  
            sb.append(String.valueOf(entry.getKey())).append(separator);  
        \}  
        return sb.toString().substring(0, sb.toString().length() - separator.length());  
    \}  
  
  
    /\*\*  
     \* 将map的value以separator链接并以字符串的形式返回  
     \*  
     \* @param map       map  
     \* @param separator 连接符  
     \* @param <K>       泛型  
     \* @param <V>       泛型  
     \* @return 字符串  
     \*/  
    public static <K, V> String valueJoin(Map<K, V> map, String separator) \{  
        StringBuilder sb = new StringBuilder();  
  
  
        for (Map.Entry<K, V> entry : map.entrySet()) \{  
            sb.append(String.valueOf(entry.getValue())).append(separator);  
        \}  
        return sb.toString().substring(0, sb.toString().length() - separator.length());  
    \}  
\}