简单的集合工具类

简单的集合工具类

/**
 * @author yong.liu
 * @date 2020/7/27
 */
public class CollectionAidsUtils {


    /**
     * 遍历处理方法
     * @param list
     * @param action
     * @param <T>
     */
    public static <T> void handle(List<T> list, ComsumerAction<T> action) {
        for (T t : list) {
           if(!ObjectUtils.isEmpty(t)){
               action.handle(t);
           }
        }
    }
    /**
     * 分组工具类
     *
     * @param list
     * @return
     */
    public static <K, T> Map<K, List<T>> groupByCondition(List<T> list, GroupCondition<K, T> condition) {
        Map<K, List<T>> orgSummaryMap = new HashMap<K, List<T>>();
        for (T t : list) {
            K groupId = condition.getGroupKey(t);
            if (null == orgSummaryMap.get(groupId)) {
                orgSummaryMap.put(groupId, new ArrayList<T>());
            }
            orgSummaryMap.get(groupId).add(t);
        }
        return orgSummaryMap;
    }

    /**
     * 分组工具类 并且数据可以去重
     * 但是T需要实现hashCode 和 equals方法
     *
     * @param sets
     * @param condition
     * @param <K>
     * @param <T>
     * @return
     */
    public static <K, T> Map<K, Set<T>> groupByCondition(Set<T> sets, GroupCondition<K, T> condition) {
        Map<K, Set<T>> orgSummaryMap = new HashMap<K, Set<T>>();
        for (T t : sets) {
            K groupId = condition.getGroupKey(t);
            if (null == orgSummaryMap.get(groupId)) {
                orgSummaryMap.put(groupId, new HashSet<T>());
            }
            orgSummaryMap.get(groupId).add(t);
        }
        return orgSummaryMap;
    }

    /**
     * 过滤
     *
     * @param filter
     * @param <T>
     * @return
     */
    public static <T> List<T> collect(Collection<T> collection, FilterCondition<T> filter) {
        List<T> result = new ArrayList<T>();
        collect(collection, filter, result);
        return result;
    }

    /**
     * 过滤并且去重
     *
     * @param collection
     * @param filter
     * @param <T>
     * @return
     */
    public static <T> Set<T> collectUnique(Collection<T> collection, FilterCondition<T> filter) {
        Set<T> result = new HashSet<T>();
        collect(collection, filter, result);
        return result;
    }

    /**
     * @param list
     * @param filter
     * @param result
     * @param <T>
     */
    private static <T> void collect(Collection<T> list, FilterCondition<T> filter, Collection<T> result) {
        for (T t : list) {
            if (filter.isSupport(t)) {
                result.add(t);
            }
        }
    }

    /**
     *
     * @param collection
     * @param sum
     * @param result
     * @param <K>
     * @param <T>
     * @return
     */
    public static <K, T> K calulate(Collection<T> collection, K result , CalulateStrategy<T, K> sum) {
        for (T t : collection) {
            result = sum.calulate(t,result);
        }
        return result;
    }

    /**
     * 统计
     * @param collection
     * @param sum
     * @param <K>
     * @param <T>
     */
    public static <K, T> K calulate(Collection<T> collection, CalulateStrategy<T, K> sum){

        ResolvableType resolvableType = ResolvableType.forClass(sum.getClass());
        Class<K> clazz = (Class<K>) resolvableType.getInterfaces()[0].getGeneric(1).resolve();
        K result = BeanUtils.instantiateClass(clazz);
        return calulate(collection, result, sum);
    }

    /**
     * @param collection
     * @param condition
     * @param <T>
     * @param <K>
     * @param <V>
     * @return
     */
    public static <T, K, V> Map<K, V> mapping(Collection<T> collection, MappingCondition<T> condition) {
        Map<K, V> result = new HashMap<K, V>();
        for (T t : collection) {
            Map<K, V> groupId = condition.mapping(t);
            if (result.containsKey(groupId.keySet().iterator().next())) {
                throw new BusinessException("对象映射错误...存在相同key的元素");
            }

            result.putAll(groupId);
        }
        return result;
    }

    /**
     * 根据对象内容获取分组key
     *
     * @param <T>
     */
    public interface GroupCondition<K, T> {
        /**
         * 根据T获取key
         *
         * @param t
         * @return
         */
        K getGroupKey(T t);
    }

    /**
     * 过滤方法
     *
     * @param <T>
     */
    public interface FilterCondition<T> {

        /**
         * 过滤条件
         *
         * @param t
         * @return
         */
        boolean isSupport(T t);
    }

    /**
     * 实例映射方法
     *
     * @param <T>
     */
    public interface MappingCondition<T> {
        /**
         * 实例映射
         *
         * @param t
         * @param <K>
         * @return
         */
        <K, V> Map<K, V> mapping(T t);
    }


    /**
     * 统计策略
     *
     * @param <T>
     */
    public interface CalulateStrategy<T, K> {

        K calulate(T t,K k);
    }

    /**
     * 消费接口
     * @param <T>
     */
    public interface ComsumerAction<T>{

        void handle(T t);
    }
}