java8中的函数式数据处理

1、在流中只能遍历一次，否则会提示流已经操作或者关闭的错误

List<String> title = Arrays.asList("Java8", "In", "Action");

        Stream<String> stream = title.stream();

        stream.forEach(System.out::println);

     stream.forEach(System.out::println);

2、操作类型分为中间操作和终端操作

中间操作有

操作	类型	返回类型	操作参数	函数描述符
filter	中间	Stream<T>	Predicate<T>	T -> boolean
map	中间	Stream<R>	Function<T,R>	T -> R
sorted	中间	Stream<T>	Comparator<T>	(T,T) -> int
limit	中间	Stream<T>
distinct	中间	Stream<T>
skip	中间	Stream<T>

终端操作有

操作	类型	返回类型	操作参数	函数描述符
forEach	终端	void	Consumer<T>	T -> void
count	终端	long
collect	终端	R	Collector<T,A,R>
allMatch	终端	boolean	Predicate<T>	T -> boolean
anyMatch	终端	boolean	Predicate<T>	T -> boolean
noneMatch	终端	boolean	Predicate<T>	T -> boolean
findAny	终端	Optional<T>
findFirst	终端	Optional<T>
reduce	终端	Optinal<T>	BinaryOperator<T>	(T,T)->T

3、原始类型流特例化

IntStream, DoubleStream, LongStream

映射到数值流，使用mapToInt,mapToDouble, mapToLong

转换为对象流使用boxed或者mapToObj

生成范围使用range和rangeClosed，第一个参数表示起始值，第二个参数表示结束值，range不包含结束值，rangeClosed包含

4、创建流

（1）通过值创建流，使用静态方法Stream.of,使用Stream.empty()创建空流

（2）数组创建流，使用静态方法Arrays.stream

（3）由文件创建流，Files.lines

（4）函数创建流，使用静态方法Stream.iterate和Stream.generate

5、收集器

toList

toSet

joining

joining(CharSequence delimiter)

joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix)

counting

minBy(Comparator<T> comparator)

maxBy(Comparator<T> comparator)

summingInt(ToIntFunction<T> mapper)

summingLong(ToLongFunction<T> mapper)

summingDouble(ToDoubleFunction<T> mapper)

averagingInt(ToIntFunction<T> mapper)

averagingLong(ToLongFunction<T> mapper)

averagingDouble(ToDoubleFunction<T> mapper)

reducing(T identity, BinaryOperator<T>op)

reducing(BinaryOperator<T> op)

reducing(U identity, Function<T, U> mapper, BinaryOperator<U> op)

groupingBy(Function<T, K> classifier)

groupingBy(Function<T, K> classifier, Collector<T, A, D> downstream)

groupingBy(Function<T, K> classifier, Supplier<M> mapFactory, Collector<T, A, D> downstream)

groupingByConcurrent(Function<T, K> classifier)

groupingByConcurrent(Function<T, K> classifier, Collector<T, A,D> downstream)

groupingByConcurrent(Function<T,K>classifier, Supplier<M>mapFactory, Collector<T,A,D> downstream)

partitioningBy(Predicate<T>predicate)

partitioningBy(Predicate<T>predicate, Collector<T,A,D> downstream)

collectingAndThen(Collector<T,A,R> downstream, Function<R,RR> finisher)

toMap(Function<T, K> keyMapper, Function<T, U> valueMapper)

toMap(Function<T, K> keyMapper, Function<T, U> valueMapper, BinaryOperation<U> mergeFunction)

toMap(Function<T, K>keyMapper, Function<T, U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M>mapSupplier)

toConcurrentMap(Function<T, K> keyMapper, Function<T, U> valueMapper)

toConcurrentMap(Function<T,K> keyMapper, Function<T, U> valueMapper, BinaryOperation<U>mergeFunction)

toConcurrentMap(Function<T,K>keyMapper, Function<T,U> valueMapper, BinaryOperator<U> mergeFunction, Supplier<M>mapSupplier)

summarizingInt(ToIntFunction<T>mapper)

summarizingLong(ToLongFunction<T>mapper)

summarizingDouble(ToDoubleFunction<T>mapper)