【java8 stream 工具】

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
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 StreamUtil {
    private StreamUtil() {
        throw new IllegalArgumentException("Utility class");
    }
        
public static <T> void consumerList(List<T> list, Consumer<T> consumer) {
        if (!CollectionUtils.isEmpty(list)) {
            list.stream().forEach(consumer);
        }
    }

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

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

    public static <T> List<T> multiFilterList(List<T> list, Predicate<T>... predicates) {
        if (CollectionUtils.isEmpty(list)) {
            return Collections.emptyList();
        } else {
            Stream<T> stream = list.stream();
            Predicate[] var3 = predicates;
            int var4 = predicates.length;

            for(int var5 = 0; var5 < var4; ++var5) {
                Predicate<T> predicate = var3[var5];
                stream = stream.filter(predicate);
            }

            return (List)stream.collect(Collectors.toList());
        }
    }

    public static <T, R> Map<R, T> listToMap(List<T> list, Function<T, R> function) {
        return CollectionUtils.isEmpty(list) ? Collections.emptyMap() : (Map)list.stream().collect(Collectors.toMap(function, Function.identity()));
    }

    public static <T, R> List<R> filterAndMapList(List<T> list, Predicate<T> predicate, Function<T, R> function) {
        return CollectionUtils.isEmpty(list) ? Collections.emptyList() : (List)list.stream().filter(predicate).map(function).collect(Collectors.toList());
    }

    public static <T, K, V> Map<K, V> filter2Map(Set<T> list, Predicate<T> predicate, Function<T, K> keyFunction, Function<T, V> valueFunction) {
        return CollectionUtils.isEmpty(list) ? Collections.emptyMap() : (Map)list.stream().filter(predicate).collect(Collectors.toMap(keyFunction, valueFunction));
    }

    public static <T, K, R> Map<K, R> mapCollect2Map(List<T> list, Function<T, R> mapFunction, Function<R, K> keyFunction) {
        return CollectionUtils.isEmpty(list) ? Collections.emptyMap() : (Map)list.stream().map(mapFunction).collect(Collectors.toMap(keyFunction, Function.identity()));
    }

    public static <T, K, R> Map<K, R> collect2Map(List<T> list, Function<T, K> keyFunction, Function<T, R> valueFunction) {
        return CollectionUtils.isEmpty(list) ? Collections.emptyMap() : (Map)list.stream().collect(Collectors.toMap(keyFunction, valueFunction));
    }

    public static <T, K> Map<K, List<T>> list2GroupMap(List<T> list, Function<T, K> keyFunction) {
        return CollectionUtils.isEmpty(list) ? Collections.emptyMap() : (Map)list.stream().collect(Collectors.groupingBy(keyFunction));
    }

    public static <T> List<T> listDistinct(List<T> list) {
        return (List)list.stream().distinct().collect(Collectors.toList());
    }

    public static <T, R> List<R> list2MapAndDistinct(List<T> list, Function<T, R> function) {
        return (List)list.stream().map(function).distinct().collect(Collectors.toList());
    }
}