JAVA集合操作优化

JAVA集合操作优化

本文主要针对集合操作中，常常会对List这种集合做一些判空之类的操作，符合条件后才会进入下一步处理。编程中这样的使用场景比较多。本人针对这一情况，编写集合优化类进行操作。主代码如下：

package com.huawei.iot.pki.common.util;

import com.huawei.iot.common.util.CollectionUtil;

import com.google.common.collect.Queues;

import lombok.Getter;
import lombok.Setter;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;

/**
 * CollectionSyntaxOptimizer Tools that are more suitable for business
 *
 */
public class CollectionOptimizer {
    /**
     * list按照key分组
     *
     * @param lists lists
     * @param keyGetter supplier
     * @param <T> T
     * @param <R> R
     * @return Map<String, List<T>>
     */
    public static <T, R> Map<R, List<T>> groupLists(List<T> lists, Function<T, R> keyGetter) {
        if (CollectionUtil.isEmpty(lists)) {
            return Collections.emptyMap();
        }
        return lists.stream().collect(Collectors.groupingBy(keyGetter));
    }

    /**
     * applyAll
     *
     * @param lists lists
     * @param consumer consumer
     * @param <T> T
     */
    public static <T> void applyAll(List<T> lists, Consumer<T> consumer) {
        if (CollectionUtil.isEmpty(lists)) {
            return;
        }
        lists.forEach(consumer);
    }

    /**
     * getItemStr
     *
     * @param lists lists
     * @param getItem func
     * @param <T> T src
     * @return "a,a,a"
     */
    public static <T> String getItemStr(List<T> lists, Function<T, String> getItem) {
        return lists.stream().filter(Objects::nonNull).map(getItem).collect(Collectors.joining(","));
    }

    /**
     * actsOn
     *
     * @param lists lists
     * @param <T> <T></T>
     * @return FollowUpProcedure
     */
    public static <T> FollowUpProcedure<T> actsOn(List<T> lists) {
        FollowUpProcedure<T> procedure = new FollowUpProcedure<>();
        procedure.setItems(lists);
        return procedure;
    }

    /**
     * FollowUpProcedure
     *
     * @param <T> T
     */
    public static class FollowUpProcedure<T> {
        @Setter
        private List<T> items;

        private Queue<Predicate<List<T>>> predicates;

        @Getter
        private boolean end = false;

        /**
         * add predicates
         *
         * @param predicate pred
         * @return FollowUpProcedure
         */
        public FollowUpProcedure<T> match(Predicate<List<T>> predicate) {
            if (Objects.isNull(predicates)) {
                predicates = Queues.newArrayDeque();
            }
            predicates.add(predicate);
            return this;
        }

        /**
         * Predicates 不影响后续执行
         *
         * @param consumer consumer for list
         * @return FollowUpProcedure
         */
        public FollowUpProcedure<T> then(Consumer<List<T>> consumer) {
            if (allPredicates(items)) {
                consumer.accept(items);
            }
            return this;
        }

        /**
         * Predicates 影响后续执行
         *
         * @param consumer consumer for list
         * @return FollowUpProcedure
         */
        public FollowUpProcedure<T> thenE(Consumer<List<T>> consumer) {
            if (allPredicates(items)) {
                consumer.accept(items);
            }
            return this.end();
        }

        /**
         * thenM
         *
         * @param function function for list
         * @return FollowUpProcedure
         */
        public <R> FollowUpProcedure<R> thenM(Function<T, R> function) {
            if (!allPredicates(items)) {
                return this.end();
            }
            FollowUpProcedure<R> convert = new FollowUpProcedure<>();
            convert.setItems(items.stream().map(function).collect(Collectors.toList()));
            return convert;
        }

        private boolean allPredicates(List<T> items) {
            if (CollectionUtil.isEmpty(items) || end) {
                return false;
            }
            while (CollectionUtil.isNotEmpty(predicates)) {
                Predicate<List<T>> predicate = predicates.poll();
                if (Objects.isNull(predicate)) {
                    continue;
                }
                if (!predicate.test(items)) {
                    return false;
                }
            }
            return true;
        }

        private <N> FollowUpProcedure<N> end() {
            FollowUpProcedure<N> procedure = new FollowUpProcedure<>();
            procedure.end = true;
            return procedure;
        }
    }
}

调用方可以直接进行链式调用。