基于java8的ListUtil

package com.huayong.workflow.base.utils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.collections4.CollectionUtils;

public class ListUtil {

    public static <T, R> List<R> mapToList(List<T> list, Function<T, R> function) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        return list.stream().map(function).collect(Collectors.toList());
    }

    public static <T, R> List<R> flatMapToList(List<T> list, Function<T, ? extends Stream<R>> function) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        return list.stream().flatMap(function).collect(Collectors.toList());
    }

    public static <T, S, R> List<R> listSubFieldByList(List<T> list, Function<T, ? extends Stream<S>> streamFunction,
            Function<S, R> fieldFunction) {
        List<S> flatList = flatMapToList(list, streamFunction);
        if (isEmpty(flatList)) {
            return new ArrayList<>();
        }
        return mapToList(flatList, fieldFunction);
    }

    public static List<String> flatMapToList(Collection<? extends Collection<String>> list) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        return list.stream().flatMap(Collection::stream).collect(Collectors.toList());
    }

    public static <T, R> Map<R, List<T>> group(List<T> list, Function<T, R> function) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyMap();
        }
        return list.stream().collect(Collectors.groupingBy(function));
    }

    public static <T, R, M> Map<R, List<M>> groupMapping(List<T> list, Function<T, R> function,
            Function<T, M> mapping) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyMap();
        }
        return list.stream().collect(Collectors.groupingBy(function, Collectors.mapping(mapping, Collectors.toList())));
    }

    public static <T, K, V> Map<K, V> toMap(List<T> list, Function<T, K> key, Function<T, V> value) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyMap();
        }
        return list.stream().collect(Collectors.toMap(key, value, (k1, k2) -> k1));
    }

    public static <T> List<T> filter(List<T> list, Predicate<T> predicate) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        return streamFilter(list, predicate).collect(Collectors.toList());
    }

    public static <T> T filterOne(List<T> list, Predicate<T> predicate) {
        if (CollectionUtils.isEmpty(list)) {
            return null;
        }
        List<T> results = streamFilter(list, predicate).collect(Collectors.toList());
        return getFirst(results);
    }

    private static <T> Stream<T> streamFilter(List<T> list, Predicate<T> predicate) {
        return list.stream().filter(predicate);
    }

    public static <T, R> List<R> filterMapToList(List<T> list, Predicate<T> predicate, Function<T, R> function) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        return streamFilter(list, predicate).map(function).collect(Collectors.toList());
    }

    public static <T, R> List<R> parallelMapToList(List<T> list, Function<T, R> function) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        }
        return list.parallelStream().map(function).collect(Collectors.toList());
    }

    public static <T> T getFirst(List<T> list) {
        return CollectionUtils.isNotEmpty(list) ? list.get(0) : null;
    }

    public static boolean isEmpty(Collection<?> coll) {
        return CollectionUtils.isEmpty(coll);
    }

    public static boolean isNotEmpty(Collection<?> coll) {
        return CollectionUtils.isNotEmpty(coll);
    }

    public static boolean isAllNull(Collection<?> coll) {
        if (isEmpty(coll)) {
            return true;
        }
        return coll.stream().allMatch(Objects::isNull);
    }

    public static <T> List<T> of(T... t) {
        return Arrays.asList(t);
    }
}