java流式编程传对象无法更新,Java8 Stream流式编程

Stream介绍(摘抄)

Stream 使用一种类似用 SQL 语句从数据库查询数据的直观方式来提供一种对 Java 集合运算和表达的高阶抽象。JDK8新特性。

Stream API可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。

这种风格将要处理的元素集合看作一种流，流在管道中传输，并且可以在管道的节点上进行处理，比如筛选，排序，聚合等。

Stream有以下特性及优点：

无存储。Stream不是一种数据结构，它只是某种数据源的一个视图，数据源可以是一个数组，Java容器或I/O channel等。

为函数式编程而生。对Stream的任何修改都不会修改背后的数据源，比如对Stream执行过滤操作并不会删除被过滤的元素，而是会产生一个不包含被过滤元素的新Stream。

惰式执行。Stream上的操作并不会立即执行，只有等到用户真正需要结果的时候才会执行。

可消费性。Stream只能被“消费”一次，一旦遍历过就会失效，就像容器的迭代器那样，想要再次遍历必须重新生成。

流的创建

集合 Collection.stream()

静态方法 Stream.of

数组 Arrays.stream

// 流的创建

// 1.集合

List list = Arrays.asList("a", "b", "c");

Stream listStream = list.stream();

Stream listParallelStream = list.parallelStream();

// 2.数组

Integer[] numberArray = {1,2,3,4};

Stream arrayStream1 = Arrays.stream(numberArray);

Stream arrayStream2 = Stream.of(numberArray);

Stream arrayParallelStream = Stream.of(numberArray).parallel();

// 3.多个元素

Stream integerStream = Stream.of(1, 2, 3, 4);

// 4.单一元素

Student student = new Student(1, "gxzhang", BigDecimal.ZERO);

Stream studentStream = Stream.of(student);

stream为串行流，parallelStream并行流可利用机器多核并发，效率更高，默认并发数为机器cpu核数。

流的转换

// 流的转换

// 普通流转并行流

Stream parallel = listStream.parallel();

// Stream -> IntStream

IntStream intStream2 = integerStream.mapToInt(value -> value.intValue());

// IntStream -> Stream

Stream integerStream3 = intstream.boxed();

中间操作

常用

filter(Predicate) 筛选流中某些元素

map(Function f) 接收流中元素，并且将其映射成为新元素，例如从student对象中取name属性

flatMap(Function f) 将所有流中的元素并到一起连接成一个流

peek(Consumer c) 获取流中元素，操作流中元素，与foreach不同的是不会截断流，可继续操作流

distinct() 通过流所生成元素的equals和hashCode去重

limit(long val) 截断流，取流中前val个元素

sorted(Comparator) 产生一个新流，按照比较器规则排序

sorted() 产生一个新流，按照自然顺序排序

匹配

booelan allMatch(Predicate) 都符合

boolean anyMatch(Predicate) 任一元素符合

boolean noneMatch(Predicate) 都不符合

查找元素

findFirst——返回第一个元素

findAny——返回当前流中的任意元素

计数和极值

count——返回流中元素的总个数

max——返回流中最大值

min——返回流中最小值

// 中间操作

// filter：过滤值为为 "a" 的元素 filter的值为false时会被过滤

list = listStream.filter(value -> "a".equals(value)).collect(Collectors.toList());

// map 将值依次进行映射处理；将数据每个字符串后加‘-’符号

list = listStream.map(value->value+"-").collect(Collectors.toList());

// anyMatch 任意符合 返回布尔类型； 判断元素是否存在”a“

boolean b = listStream.anyMatch(value -> "a".equals(value));

// 流的扁平化

// 将 数组["hello", "world"] 转变成 ["h","e","l","o","w","r","d"] 并将元素去重

String[] strings = {"hello", "world"};

// 这样返回的结果为 String[]数组类型的集合，而我们需要将List类型的

// 原因是因为map中将一个元素生成了多个元素返回了一个String[]数组类型

List collect = Stream.of(strings)

.map(word -> word.split(""))

.distinct()

.collect(Collectors.toList());

// 采用flatmap进行流扁平化

List collect1 = Stream.of(strings).

flatMap(word -> Arrays.stream(word.split("")))

.distinct()

.collect(Collectors.toList());

终止操作

foreach(Consumer c) 遍历操作

collect(Collector) 将流转化为其他形式

max(Comparator) 返回流中最大值

min(Comparator) 返回流中最小值

count 返回流中元素综述

Collectors 具体方法

toList List 把流中元素收集到List

toSet Set 把流中元素收集到Set

toCollection Coolection 把流中元素收集到Collection中

groupingBy Map> 根据K属性对流进行分组

partitioningBy Map> 根据boolean值进行分组

// 终止操作

// 流的遍历

listStream.forEach(value-> System.out.println(value));

listStream.forEach(value-> System.out.println(value));

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

listStream.forEach(value -> {

// 多条语句用花括号

System.out.println("二哈");

System.out.println(value);

});

// 归约，计算数和；0 为identity初始值，a将被赋值为上次计算结果(初始为identity值)，b流中元素

int sum = intstream.reduce(0, (a, b) -> a + b);

// 收集 将处理后的结果返回对应的类型数据

List list1 = integerStream.collect(Collectors.toList());

// 其他

// 最大值

int max = intstream.max().getAsInt();

// 最小值

int min = intstream.min().getAsInt();

// 和

intstream.sum();

注意事项

流一旦执行了终止操作就不再可用，必须需要重新获取流。

流式编程为语法糖，最终编译后执行效果和不加糖是一致的，只是语法糖帮我们提升了编程效率和常用操作的最优实现。

以上案例仅为方便说明用法，不可直接执行。

流的常用api以上已说明，案例只简单列举了常用的api用法，可根据简单介绍很容易上手。

欲练此功，必先多敲✊