StreamUtils工具类

导包：

        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>20.0</version>
        </dependency>
        <dependency>
            <groupId>commons-collections</groupId>
            <artifactId>commons-collections</artifactId>
            <version>3.2.2</version>
        </dependency>

工具类：

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import org.apache.commons.collections.CollectionUtils;

import com.google.common.collect.Lists;
import com.google.common.collect.Sets;

/**
 * @author ycs
 */
public class StreamUtils {

    /**
     * 提取对象中的某一个属性
     * @param srcList 对象list
     * @param mapper 对象::get属性名
     * @param <T> 对象类型
     * @param <R> 属性类型
     * @return 属性list
     */
    public static <T, R> List<R> toList(List<T> srcList, Function<? super T, ? extends R> mapper) {
        if (CollectionUtils.isEmpty(srcList)) {
            return Lists.newArrayList();
        }
        return srcList.stream().map(mapper).collect(Collectors.toList());
    }

    /**
     * 提取对象中的某一个属性，去重
     * @param srcList 对象list
     * @param mapper 对象::get属性名
     * @param <T> 对象类型
     * @param <R> 属性类型
     * @return 属性set
     */
    public static <T, R> Set<R> toSet(List<T> srcList, Function<? super T, ? extends R> mapper) {
        if (CollectionUtils.isEmpty(srcList)) {
            return Sets.newHashSet();
        }
        return srcList.stream().map(mapper).collect(Collectors.toSet());
    }

    /**
     * 构建 属性:对象  map
     * @param srcList 对象list
     * @param mapper 对象::get属性名
     * @param <T> 对象类型
     * @param <K> 属性类型
     * @return 属性:对象 map
     */
    public static <T, K> Map<K, T> toMap(List<T> srcList, Function<? super T, ? extends K> mapper) {
        if (CollectionUtils.isEmpty(srcList)) {
            return new HashMap<>();
        }
        return srcList.stream().collect(Collectors.toMap(mapper, v -> v));
    }

    /**
     * 构建 属性:属性  map
     * @param srcList 对象list
     * @param mapper1 对象::get属性名
     * @param mapper2 对象::get属性名
     * @param <T> 对象类型
     * @param <K> 属性类型
     * @param <U> 属性类型
     * @return 属性:属性 map
     */
    public static <T, K, U> Map<K, U> toMap(List<T> srcList,
                                         Function<? super T, ? extends K> mapper1,
                                         Function<? super T, ? extends U> mapper2) {
        if (CollectionUtils.isEmpty(srcList)) {
            return new HashMap<>();
        }
        return srcList.stream().collect(Collectors.toMap(mapper1, mapper2));
    }

    /**
     * list分组
     * @param srcList 对象list
     * @param keyMapper 分组属性
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> Map<R, List<T>> groupBy(List<T> srcList, Function<? super T, ? extends R> keyMapper) {
        if (CollectionUtils.isEmpty(srcList)) {
            return new HashMap<>();
        }

        return srcList.stream().collect(Collectors.groupingBy(keyMapper));
    }

    /**
     * 切割 -> 操作 -> 归并
     * @param source
     * @param maxSize
     * @param mapper
     * @param <T>
     * @param <R>
     * @return
     */
    public static <T, R> List<T> splitListConvert(final Collection<R> source, final int maxSize,
                                           Function<List<R>, List<T>> mapper) {
        if (CollectionUtils.isEmpty(source)) {
            return new ArrayList<>(0);
        }
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize must be positive");
        }

        final int size = source.size();
        if (size <= maxSize) {
            if (source instanceof List) {
                return mapper.apply((List<R>) source);
            }
            return mapper.apply(new ArrayList<>(source));
        }

        final int step = (size + maxSize - 1) / maxSize;

        List<T> list = IntStream.range(0, step)
                .mapToObj(i -> source.stream().skip(i * maxSize).limit(maxSize).collect(Collectors.toList())).map(mapper)
                .filter(a -> a != null).flatMap(x -> x.stream()).collect(Collectors.toList());
        return list;
    }
}

演示demo：

public class Main {
    public static void main(String[] args) {
        Employee e1 = new Employee("张三", 23, 8000.0);
        Employee e2 = new Employee("李四", 24, 9000.0);
        Employee e3 = new Employee("王五", 25, 10000.0);
        Employee e4 = new Employee("赵六", 26, 11000.0);
        Employee e5 = new Employee("柠七", 18, 8000.0);
        List<Employee> es = Lists.newArrayList(e1, e2, e3, e4, e5);

        List<Double> afterTax = StreamUtils.toList(es, e -> e.getSalary() * 0.9);
        Set<Integer> ageSet = StreamUtils.toSet(es, Employee::getAge);
        Map<String, Employee> nameMap = StreamUtils.toMap(es, Employee::getName);
        Map<String, Integer> map = StreamUtils.toMap(es, Employee::getName, Employee::getAge);
        // indexName必须返回List<T>
        List<Employee> employees = StreamUtils.splitListConvert(es, 3, sub -> indexName(sub));
        Map<Double, List<Employee>> sameSalary = StreamUtils.groupBy(es, Employee::getSalary);
    }

    public static List<Employee> indexName(List<Employee> es) {
        for (int i = 0; i < es.size(); i++) {
            Employee employee = es.get(i);
            employee.setName(employee.getName() + i);
        }
        return es;
    }
}

@Data
@AllArgsConstructor
class Employee {
    private String name;

    private Integer age;

    private Double salary;
}