Stream补充

---

最近看的项目使用Stream来操作集合，熟悉代码阶段就令人头大，来补课了

1. 常见的接口

我们常用Lambda来表达这些函数式接口，所以看着比较陌生，其实日常都有使用到。下面说明时会先给出源码，然后再给出使用事例

1.1 Consumer

传入参数，内部进行操作，没有返回值

@FunctionalInterface
public interface Consumer<T> {

    /**
     * Performs this operation on the given argument.
     *
     * @param t the input argument
     */
    void accept(T t);
}

list.stream().forEach(s -> System.out.println(s));	// forEach(Consumer<? super T> action)

1.2 Function

传入参数，内部进行转换，有返回值

@FunctionalInterface
public interface Function<T, R> {

    /**
     * Applies this function to the given argument.
     *
     * @param t the function argument
     * @return the function result
     */
    R apply(T t);
}

list.stream().map(s -> s + "-");	// Stream<R> map(Function<? super T, ? extends R> mapper);

1.3 Supplier

创建一个容器并且返回出去

@FunctionalInterface
public interface Supplier<T> {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

Collector toMap(Function keyMapper
			   ,Function valueMapper
			   ,BinaryOperator mergeFunction
			   ,Supplier<M> mapSupplier)

1.4 Predicate

传入参数，进行判断，返回boolean

@FunctionalInterface
public interface Predicate<T> {

    /**
     * Evaluates this predicate on the given argument.
     *
     * @param t the input argument
     * @return {@code true} if the input argument matches the predicate,
     * otherwise {@code false}
     */
    boolean test(T t);
}

list.stream().anyMatch(s -> s >= 10);	// anyMatch(Predicate<? super T> predicate)

2. 集合的操作

后期才知道流可以转变成的神奇之处，前来学习

先来看流的收集方法： collect(Collector<? super T, A, R> collector) ，其主要将流中元素收集成另外一个数据结构（如：集合，String，整数等），而参数是一个Collector实例（后面会说明）

2.1 Collectors

Collectors是一个工具类，其常用的方法有：

• toList()，返回一个Collector实例，这就是上面所说的Collector实例
• toSet()，返回一个Collector实例
• toMap()，返回一个Collector实例
• joining()
• collectingAndThen()
• counting()

2.2 转成集合

流转成集合十分的简单，往 collect() 方法里面传入Collector实例即可（Collectors工具类生成的Collector实例）

List list = Arrays.stream(array).collect(Collectors.toList());
Set  set  = Arrays.stream(array).collect(Collectors.toSet());
Map  map  = Arrays.stream(array).collect(Collectors.toMap());

2.2.1 toMap()规约

阿里巴巴Java开发手册规约提到：

【强制】在使用 java.util.stream.Collectors 类的 toMap() 方法转为 Map 集合时，一定要使用含有参数类型为BinaryOperator，参数名为 mergeFunction 的方法，否则当出现相同 key 值时会抛出 IllegalStateException 异常

使用toMap()方法转换成集合时，一般会遇到两个问题：

• Key重复问题
• Value空指针异常

toMap的参数：

public static Collector toMap(Function keyMapper
							 ,Function valueMapper
							 ,BinaryOperator mergeFunctio
							 ,Supplier mapSupplier) {
							 
	BiConsumer accumulator = 
	(map, element) -> map.merge(keyMapper.apply(element)
							   ,valueMapper.apply(element)
							   ,mergeFunction);
							   
    return new CollectorImpl (mapSupplier, accumulator, mapMerger(mergeFunction), CH_ID);
}

• 前两个是Function，传参内部操作并返回的，正常都是getKey()，getValue()
• 第三个是BiFunction实现类（类似于Function），但接收两参数返回一个值，进行合并操作的
• 第四个是Supplier，是提供的容器，默认是HashMap

为了避免上述的两个问题，我们可以进行如下操作：

• Key重复一般会使用后者覆盖策略

ArrayList<User> list = new ArrayList();

list.add(new User("张三", 30));
list.add(new User("张三", 80));
list.add(new User("李四", 40));
list.add(new User("王五", 50));

Map map = list.stream().collect(Collectors.toMap(User::getName,User::getAge,(v1, v2) -> v2));

map.forEach((k,v) -> System.out.println(k + "---" + v));

----------------------------------------------------------------------

李四---40
张三---80
王五---50

• 而Value的NPE问题是因为底层使用了 java.util.HashMap，其 merge 方法里会进行如下的判断：

if (value == null || remappingFunction == null)	throw new NullPointerException();

3. Reduce约简操作

以前约简不会用，现在接触才发现这就是迭代的形式啊，这次的输出值作为下次的输入值

int[] nums = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 传入前两个参数累加，返回值作为下次的第一个参数，下次往后移动一格
System.out.println(
        Arrays.stream(nums).reduce((left, right) -> left += right).getAsInt()
);

// 有个初始值，结果不为空就不用Optional类包装了，不会NPE
System.out.println(
        Arrays.stream(nums).reduce(100,(left, right) -> left += right)
);