Java8新特性-Stream-优快云博客

本文链接：https://blog.youkuaiyun.com/2401_83329718/article/details/138879870

java.lang.IllegalStateException: stream has already been operated upon or closed

stream的操作是延迟执行的，在列出字符串长度大于3的例子中，在collect方法执行之前，filter、sorted、map方法还未执行，只有当collect方法执行时才会触发之前转换操作

public boolean filter(String s) {

System.out.println(“begin compare”);

return s.length() > 3;

}

@Test

public void test2() {

List strs = new ArrayList() {

{

add(“abc”);

add(“abcd”);

}

};

Stream stream = strs.stream().filter(this::filter);

System.out.println(“split-------------------------------------”);

List list = stream.collect(Collectors.toList());

System.out.println(list);

}

打印结果如下：

split-------------------------------------

begin compare

[abcd]

由此可以看出，在执行完filter时，没有实际执行filter中的方法，而是等到执行collect时才会执行，即是延迟执行的。

注意：

由于stream的延迟执行特性，在聚合操作执行前修改数据源是允许的。
当我们操作一个流的时候，并不会修改流底层的集合（即使集合是线程安全的），如果想要修改原有的集合，就无法定义流操作的输出。

/**

延迟执行特性，在聚合操作之前都可以添加相应元素

@Test

public void test3() {

List wordList = new ArrayList() {

{

add(“a”);

add(“b”);

}

};

Stream words = wordList.stream();

wordList.add(“END”);

long n = words.distinct().count();

System.out.println(n);

}

输出结果

延迟执行特性，会产生干扰

@Test

public void test4(){

List wordList = new ArrayList() {

{

add(“a”);

add(“b”);

}

};

Stream words1 = wordList.stream();

words1.forEach(s -> {

System.out.println(“s->”+s);

if (s.length() < 4) {

System.out.println(“select->”+s);

wordList.remove(s);

System.out.println(wordList);

}

});

}

输出结果

s->a

select->a

[b]

s->null

java.lang.NullPointerException

创建Stream

要进行流操作首先要获取流，有6中方法可以获取流。

通过集合创建流

@Test

public void testCollectionStream() {

List strs = Arrays.asList(“a”, “b”, “c”, “d”);

//创建普通流

Stream stream = strs.stream();

//创建并行流（即多个线程处理）

// Stream stream1 = strs.parallelStream();

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

}

输出结果

通过数组创建流

@Test

public void testArrayStream() {

int[] arr = new int[]{1, 2, 3, 4};

IntStream intStream = Arrays.stream(arr);

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

System.out.println(“========”);

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

Stream stream = Arrays.stream(arr2);

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

}

输出结果

========

通过Stream.of方法创建流

@Test

public void testStreamOf() {

Stream stream = Stream.of(1, 2, 3);

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

}

输出结果

创建规律的无限流

@Test

public void testUnlimitStream() {

Stream stream = Stream.iterate(0, x -> x + 2).limit(3);

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

}

输出结果

创建无限流

@Test

public void testUnlimitStream2() {

Stream stream = Stream.generate(() -> “number” + new Random().nextInt()).limit(3);

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

}

输出结果

number1042047526

number-155761434

number-1605164634

创建空流

@Test

public void testEmptyStream() {

Stream stream = Stream.empty();

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

}

Stream操作分类

中间操作又可以分为无状态（Stateless）与有状态（Stateful）操作，
无状态是指元素的处理不受之前元素的影响，
有状态是指该操作只有拿到所有元素之后才能继续下去。
终结操作又可以分为短路（Short-circuiting）与非短路（Unshort-circuiting）操作，
短路是指遇到某些符合条件的元素就可以得到最终结果，
非短路是指必须处理完所有元素才能得到最终结果。
我们通常还会将中间操作称为懒操作，也正是由这种懒操作结合终结操作、数据源构成的处理管道（Pipeline），实现了 Stream 的高效。

中间操作

无状态

filter：过滤流，过滤流中的元素
map：转换流，将一种类型的流转换为另外一种类型的流
flapMap：拆解流，将流中每一个元素拆解成一个流

filter

filter接收一个Predicate函数接口参数，boolean test(T t);即接收一个参数，返回boolean类型。

@Test

public void testFilter() {

Integer[] arr = new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

Arrays.stream(arr).filter(x -> x > 3 && x < 8).forEach(System.out::println);

}

输出结果

map

map接收一个Function<T, R>函数接口，R apply(T t);即接收一个参数，并且有返回值。

@Test

public void testMap() {

String[] arr = new String[]{“yes”, “YES”, “no”, “NO”};

Arrays.stream(arr).map(x -> x.toLowerCase()).forEach(System.out::println);

}

输出结果

yes

flapMap

flatMap接收一个Function<T, R>函数接口： Stream flatMap(Function<? super T, ? extends Stream<? extends R>> mapper);即入参为集合类型，返回Stream类型。

@Test

public void testFlatMap() {

String[] arr1 = {“a”, “b”};

String[] arr2 = {“e”, “f”};

String[] arr3 = {“h”, “j”};

// Stream.of(arr1, arr2, arr3).flatMap(x -> Arrays.stream(x)).forEach(System.out::println);

Stream.of(arr1, arr2, arr3).flatMap(Arrays::stream).forEach(System.out::println);

}

输出结果

有状态

distinct：元素去重
sorted：元素排序
limit：获取前面的指定数量的元素
skip：跳过前面指定数量的元素，获取后面的元素
concat：把两个stream合并成一个stream

distinct

@Test

public void testDistinct() {

List list = new ArrayList() {

{

add(“user1”);

add(“user2”);

}

};

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

}

输出结果

user1

user2

sorted

@Test

public void testSorted1() {

String[] arr1 = {“abc”, “a”, “bc”, “abcd”};

// 按照字符长度排序

System.out.println(“lambda表达式”);

Arrays.stream(arr1).sorted((x, y) -> {

if (x.length() > y.length())

return 1;

else if (x.length() < y.length())

return -1;

else

return 0;

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

// Comparator.comparing是一个键提取的功能

System.out.println(“方法引用”);

Arrays.stream(arr1).sorted(Comparator.comparing(String::length)).forEach(System.out::println);

}

输出结果

lambda表达式

abc

abcd

方法引用

abc

abcd

reversed

/**

倒序
reversed(),java8泛型推导的问题，所以如果comparing里面是非方法引用的lambda表达式就没办法直接使用reversed()
Comparator.reverseOrder():也是用于翻转顺序，用于比较对象（Stream里面的类型必须是可比较的）
Comparator.naturalOrder()：返回一个自然排序比较器，用于比较对象（Stream里面的类型必须是可比较的）

@Test

public void testSorted2_() {

String[] arr1 = {“abc”, “a”, “bc”, “abcd”};

System.out.println(“reversed(),这里是按照字符串长度倒序排序”);

Arrays.stream(arr1).sorted(Comparator.comparing(String::length).reversed()).forEach(System.out::println);

System.out.println(“Comparator.reverseOrder(),这里是按照首字母倒序排序”);

Arrays.stream(arr1).sorted(Comparator.reverseOrder()).forEach(System.out::println);

System.out.println(“Comparator.naturalOrder(),这里是按照首字母顺序排序”);

Arrays.stream(arr1).sorted(Comparator.naturalOrder()).forEach(System.out::println);

}

输出结果

reversed(),这里是按照字符串长度倒序排序

abcd

abc

Comparator.reverseOrder(),这里是按照首字母倒序排序

abcd

abc

Comparator.naturalOrder(),这里是按照首字母顺序排序

abc

abcd

thenComparing

/**

thenComparing
先按照首字母排序
之后按照String的长度排序

@Test

public void testSorted3() {

String[] arr1 = {“abc”, “a”, “bc”, “abcd”};

Arrays.stream(arr1).sorted(Comparator.comparing(this::firstChar).thenComparing(String::length)).forEach(System.out::println);

}

public char firstChar(String x) {

return x.charAt(0);

}

输出结果

abc

abcd

limit

/**

limit，限制从流中获得前n个数据

@Test

public void testLimit() {

Stream.iterate(1, x -> x + 2).limit(3).forEach(System.out::println);

}

输出结果

skip

/**

skip，跳过前n个数据

@Test

public void testSkip() {

Stream.iterate(1, x -> x + 2).skip(1).limit(3).forEach(System.out::println);

}

输出结果

concat

/**

可以把两个stream合并成一个stream（合并的stream类型必须相同）
只能两两合并

@Test

public void testConcat(){

// 1,3,5

Stream stream1 = Stream.iterate(1, x -> x + 2).limit(3);

// 3,5,7

Stream stream2 = Stream.iterate(1, x -> x + 2).skip(1).limit(3);

Stream.concat(stream1,stream2).distinct().forEach(System.out::println);

}

输出结果

终结操作

非短路操作

forEach：遍历
toArray：将流转换为Object数组
reduce : 归约，可以将流中的元素反复结合起来，得到一个值
collect：收集，将流装换为其他形式，比如List，Set，Map
max：返回流的最大值，无方法参数
min：返回流中的最小值，无方法参数
count：返回流中的元素总个数，无方法参数
summaryStatistics：获取汇总统计数据，比如最大值，最小值，平均值等

forEach

@Test

public void testForEach() {

List list = new ArrayList() {

{

add(“a”);

add(“b”);

}

};

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

}

输出结果

reduce

@Test

public void testReduce() {

Optional optional = Stream.of(1, 2, 3).filter(x -> x > 1).reduce((x, y) -> x + y);

System.out.println(optional.get());

}

输出结果

collect

收集是非常常用的一个操作。将流装换为其他形式。接收到一个Collector接口的实现，用于给Stream中的元素汇总的方法。用collect方法进行收集。方法参数为Collector。Collector可以由Collectors中的toList()，toSet()，toMap(Function(T,R) key,Function(T,R) value)等静态方法实现。

toList() 返回一个 Collector，它将输入元素到一个新的 List 。
toSet() 返回一个 Collector，将输入元素到一个新的 Set 。
toMap(Function<? super T,? extends K> keyMapper, Function<? super T,? extends U> valueMapper) 返回一个 Collector ，它将元素累加到一个 Map ，其键和值是将所提供的映射函数应用于输入元素的结果。

用户

@Data

@AllArgsConstructor

@ToString

public class User {

private String name;

private Integer age;

private Integer salary;

}

toList，toSet，toSet

@Test

public void testCollect() {

List users = Arrays.asList(new User(“张三”, 19, 1000),

new User(“张三”, 58, 2000),

new User(“李四”, 38, 3000),

new User(“赵五”, 48, 4000)

);

List collect = users.stream().map(x -> x.getName()).collect(Collectors.toList());

Set collect1 = users.stream().map(x -> x.getName()).collect(Collectors.toSet());

Map<Integer, String> collect2 = users.stream().collect(Collectors.toMap(x -> x.getAge(), x -> x.getName()));

System.out.println(collect);

System.out.println(collect1);

System.out.println(collect2);

}

输出结果

[张三, 张三, 李四, 赵五]

[李四, 张三, 赵五]

{48=赵五, 19=张三, 38=李四, 58=张三}

groupingBy

Collectors.groupingBy()方法根据分类功能分组元素。这个是非常常用的操作。比如你要对名字相同的进行分组。groupingBy(Function<? super T,? extends K> classifier)

@Test

public void testGroupby() {

List users = Arrays.asList(new User(“张三”, 19, 1000),

new User(“张三”, 58, 2000),

new User(“李四”, 38, 3000),

new User(“赵五”, 48, 4000)

);

Map<String, List> collect3 = users.stream().collect(Collectors.groupingBy(x -> x.getName()));

System.out.println(collect3);

}

输出结果

{李四=[StreamTest.User(name=李四, age=38, salary=3000)], 张三=[StreamTest.User(name=张三, age=19, salary=1000), StreamTest.User(name=张三, age=58, salary=2000)], 赵五=[StreamTest.User(name=赵五, age=48, salary=4000)]}

partitioningBy

如果只有两类，使用partitioningBy会比groupingBy更有效率，按照工资是否大于2500分组

@Test

public void testPartitioningBy() {

List users = Arrays.asList(new User(“张三”, 19, 1000),

new User(“张三”, 58, 2000),

new User(“李四”, 38, 3000),

new User(“赵五”, 48, 4000)

);

Map<Boolean, List> map = users.stream().collect(Collectors.partitioningBy(x -> x.getSalary() > 2500));

map.forEach((x, y) -> System.out.println(x + “->” + y));

}

输出结果

false->[StreamTest.User(name=张三, age=19, salary=1000), StreamTest.User(name=张三, age=58, salary=2000)]

true->[StreamTest.User(name=李四, age=38, salary=3000), StreamTest.User(name=赵五, age=48, salary=4000)]

max、min

@Test

public void testMaxAndMin() {

String[] arr = new String[]{“b”, “ab”, “abc”, “abcd”, “abcde”};

Stream.of(arr).max(Comparator.comparing(String::length)).ifPresent(System.out::println);

Stream.of(arr).min(Comparator.comparing(String::length)).ifPresent(System.out::println);

}

输出结果

abcde

count

@Test

public void testCount(){

String[] arr = new String[]{“b”, “ab”, “abc”, “abcd”, “abcde”};

long count = Stream.of(arr).count();

System.out.println(count);

}

输出结果

summaryStatistics

我们可以使用summaryStatistics方法获得stream中元素的各种汇总数据

@Test

public void testSummaryStatistics() {

//计算 count, min, max, sum, and average for numbers

List numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

// IntSummaryStatistics stats = numbers.stream().collect(Collectors.summarizingInt(x -> x));

IntSummaryStatistics stats = numbers

.stream()

.mapToInt(x -> x)

.summaryStatistics();

System.out.println("List中最大的数字 : " + stats.getMax());

System.out.println("List中最小的数字 : " + stats.getMin());

System.out.println("所有数字的总和 : " + stats.getSum());

System.out.println("所有数字的平均值 : " + stats.getAverage());

}

输出结果

List中最大的数字 : 10

List中最小的数字 : 1

所有数字的总和 : 55

所有数字的平均值 : 5.5

短路操作

anyMatch：检查是否有一个元素匹配，方法参数为断言型接口
allMatch：检查是否匹配所有元素，方法参数为断言型接口
findFirst：返回第一个元素，无方法参数
findAny：返回当前流的任意元素，无方法参数
noneMatch：检查是否没有匹配所有元素，方法参数为断言型接口

anyMatch

@Test

public void testAnyMatch() {

String[] arr = new String[]{“b”, “ab”, “abc”, “abcd”, “abcde”};

Boolean aBoolean = Stream.of(arr).anyMatch(x -> x.startsWith(“a”));

System.out.println(aBoolean);

}

输出结果

true

findFirst

@Test

public void testFindFirst() {

String[] arr = new String[]{“b”, “ab”, “abc”, “abcd”, “abcde”};

String str = Stream.of(arr).parallel().filter(x -> x.length() > 3).findFirst().orElse(“noghing”);

System.out.println(str);

}

输出结果

abcd

findAny

/**

findAny
找到所有匹配的元素
对并行流十分有效
只要在任何片段发现了第一个匹配元素就会结束整个运算

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
("所有数字的平均值 : " + stats.getAverage());

}

输出结果

List中最大的数字 : 10

List中最小的数字 : 1

所有数字的总和 : 55

所有数字的平均值 : 5.5

短路操作

anyMatch：检查是否有一个元素匹配，方法参数为断言型接口
allMatch：检查是否匹配所有元素，方法参数为断言型接口
findFirst：返回第一个元素，无方法参数
findAny：返回当前流的任意元素，无方法参数
noneMatch：检查是否没有匹配所有元素，方法参数为断言型接口

anyMatch

@Test

public void testAnyMatch() {

String[] arr = new String[]{“b”, “ab”, “abc”, “abcd”, “abcde”};

Boolean aBoolean = Stream.of(arr).anyMatch(x -> x.startsWith(“a”));

System.out.println(aBoolean);

}

输出结果

true

findFirst

@Test

public void testFindFirst() {

String[] arr = new String[]{“b”, “ab”, “abc”, “abcd”, “abcde”};

String str = Stream.of(arr).parallel().filter(x -> x.length() > 3).findFirst().orElse(“noghing”);

System.out.println(str);

}

输出结果

abcd

findAny

/**

findAny
找到所有匹配的元素
对并行流十分有效
只要在任何片段发现了第一个匹配元素就会结束整个运算

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

[外链图片转存中…(img-xI8RbgQn-1715710786332)]

[外链图片转存中…(img-17iaRiDZ-1715710786332)]

[外链图片转存中…(img-OvAOg4QO-1715710786333)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！