Lambda 数据处理方法封装

import java.util.ArrayList;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.Stream;

/**
 * lambda 封装通用数据处理操作
 * 数据获取、修改、过滤、查找等
 */
public class DataUtil {

    /**
     * 获取数据
     * DataUtil.safeGet(() -> user.getName(), "cnbai");
     *
     * @param supplier 数据的提供者
     * @param defalutValue 默认值
     * @return 如果获取的数据为空就返回默认值
     */
    public static <T> T safeGet(Supplier<T> supplier, T defalutValue) {
        try {
            if (null != supplier) {
                T t = supplier.get();
                return null == t ? defalutValue : t;
            }
            return defalutValue;
        } catch (Exception e) {
            return defalutValue;
        }
    }


    /**
     * 数据修改 (无返回值)
     * DataUtil.safeOp(() -> user.getName(), x -> userVo.setName(x));
     * DataUtil.safeOp(() -> user.getName(), userVo::setName);
     *
     * @param supplier 数据的提供者
     * @param consumer 操作方法
     */
    public static <T> void safeOp(Supplier<T> supplier, Consumer<T> consumer) {
        T t = null;
        try {
            t = supplier.get();
        } catch (Exception ignored) {
        }

        try {
            if (null != t && null != consumer) {
                consumer.accept(t);
            }
        } catch (Exception ignored) {
        }
    }


    /**
     * 过滤数据 - 返回集合
     * List<Map<String, Object>> userMap;
     * List<Map<String, Object>> nameList = DataUtil.filterCollecion(userMap, map -> "cnbai".equals(map.get("name").toString()));
     * List<User> userList;
     * List<User> list = DataUtil.filterCollecion(userList, user -> "cnbai".equals(user.getName());
     *
     * @param collection 要过滤的数据集合
     * @param predicate 过滤条件
     * @return 过滤后的数据集合
     */
    public static <T> List<T> filterCollecion(Collection<T> collection, Predicate<? super T> predicate) {
        if (collection == null || collection.isEmpty()) {
            return new ArrayList<>();
        }
        Stream<T> stream;
        if (collection.size() > 1000) {
            stream = collection.parallelStream();
        } else {
            stream = collection.stream();
        }
        return stream.filter(predicate).collect(Collectors.toList());
    }


    /**
     * 过滤数据 - 返回个体
     * List<User> userList;
     * User user = DataUtil.filterCollecion(userList, user -> "1".equals(user.getId());
     *
     * @param collection 要过滤的数据集合
     * @param predicate 过滤条件
     * @return 过滤后的数据
     */
    public static <T> T filter(Collection<T> collection, Predicate<? super T> predicate) {
        Collection<T> ts = filterCollecion(collection, predicate);
        if (ts == null || ts.isEmpty()) {
            return null;
        }
        Iterator<T> iterator = ts.iterator();
        return iterator.hasNext() ? iterator.next() : null;
    }


    /**
     * 查找数据
     * Map<String, String> nameMap;
     * String name = DataUtil.find(nameMap.values(), name -> "cnbai".equals(name));
     * List<String> nameList;
     * String name = DataUtil.find(nameList, name -> "cnbai".equals(name));
     * List<String> nameList;
     * String name = DataUtil.find(nameList, "cnbai"::equals);
     *
     * @param collection 要搜索的数据集合
     * @param predicate 搜索条件
     * @return 结果数据
     */
    public static <T> T find(Collection<T> collection, Predicate<? super T> predicate) {
        if (collection == null || collection.isEmpty()) {
            return null;
        }
        for (T next : collection) {
            if (predicate.test(next)) {
                return next;
            }
        }
        return null;
    }
}