把Stream流学透了你也能写出简洁高效的代码，快来点击进来看看吧(建议收藏)

最新推荐文章于 2024-07-19 17:37:28 发布

2401_84584682

最新推荐文章于 2024-07-19 17:37:28 发布

阅读量1k

点赞数 12

分类专栏：程序员文章标签： java 面试学习

本文链接：https://blog.csdn.net/2401_84584682/article/details/138778790

版权

程序员专栏收录该内容

121 篇文章 2 订阅

订阅专栏

最后

作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

// 1.获取所有姓张的信息

// 2.获取名称长度为3的用户

// 3. 输出所有的用户信息

list.stream()

.filter(s->s.startsWith(“张”))

.filter(s->s.length() == 3)

.forEach(s->{

System.out.println(s);

});

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

list.stream()

.filter(s->s.startsWith(“张”))

.filter(s->s.length() == 3)

.forEach(System.out::println);

}

上面的SteamAPI代码的含义：获取流，过滤张，过滤长度，逐一打印。代码相比于上面的案例更加的简洁直观

2. Steam流式思想概述

注意：Stream和IO流(InputStream/OutputStream)没有任何关系，请暂时忘记对传统IO流的固有印象！

Stream流式思想类似于工厂车间的“生产流水线”，Stream流不是一种数据结构，不保存数据，而是对数据进行加工

处理。Stream可以看作是流水线上的一个工序。在流水线上，通过多个工序让一个原材料加工成一个商品。

在这里插入图片描述

Stream API能让我们快速完成许多复杂的操作，如筛选、切片、映射、查找、去除重复，统计，匹配和归约。

3. Stream流的获取方式

3.1 根据Collection获取

首先，java.util.Collection 接口中加入了default方法 stream，也就是说Collection接口下的所有的实现都可以通过steam方法来获取Stream流。

public static void main(String[] args) {

List list = new ArrayList<>();

list.stream();

Set set = new HashSet<>();

set.stream();

Vector vector = new Vector();

vector.stream();

}

但是Map接口别没有实现Collection接口，那这时怎么办呢？这时我们可以根据Map获取对应的key value的集合。

public static void main(String[] args) {

Map<String,Object> map = new HashMap<>();

Stream stream = map.keySet().stream(); // key

Stream stream1 = map.values().stream(); // value

Stream<Map.Entry<String, Object>> stream2 = map.entrySet().stream(); // entry

}

3.1 通过Stream的of方法

在实际开发中我们不可避免的还是会操作到数组中的数据，由于数组对象不可能添加默认方法，所有Stream接口中提供了静态方法of

public class StreamTest05 {

public static void main(String[] args) {

Stream a1 = Stream.of(“a1”, “a2”, “a3”);

String[] arr1 = {“aa”,“bb”,“cc”};

Stream arr11 = Stream.of(arr1);

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

Stream arr21 = Stream.of(arr2);

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

// 注意：基本数据类型的数组是不行的

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

Stream.of(arr3).forEach(System.out::println);

}

4.Stream常用方法介绍

Stream常用方法

Stream流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：

| — | — | — | — |

| map | 映射 | Stream | 函数拼接 |

终结方法：返回值类型不再是 Stream 类型的方法，不再支持链式调用。本小节中，终结方法包括 count 和 forEach 方法。

非终结方法：返回值类型仍然是 Stream 类型的方法，支持链式调用。（除了终结方法外，其余方法均为非终结方法。）

Stream注意事项(重要)

Stream只能操作一次
Stream方法返回的是新的流
Stream不调用终结方法，中间的操作不会执行

4.1 forEach

forEach用来遍历流中的数据的

void forEach(Consumer<? super T> action);

该方法接受一个Consumer接口，会将每一个流元素交给函数处理

public static void main(String[] args) {

Stream.of(“a1”, “a2”, “a3”).forEach(System.out::println);;

}

4.2 count

Stream流中的count方法用来统计其中的元素个数的

long count();

该方法返回一个long值，代表元素的个数。

public static void main(String[] args) {

long count = Stream.of(“a1”, “a2”, “a3”).count();

System.out.println(count);

}

4.3 filter

filter方法的作用是用来过滤数据的。返回符合条件的数据

在这里插入图片描述

可以通过filter方法将一个流转换成另一个子集流

Stream filter(Predicate<? super T> predicate);

该接口接收一个Predicate函数式接口参数作为筛选条件

public static void main(String[] args) {

Stream.of(“a1”, “a2”, “a3”,“bb”,“cc”,“aa”,“dd”)

.filter((s)->s.contains(“a”))

.forEach(System.out::println);

}

输出：

4.4 limit

在这里插入图片描述

limit方法可以对流进行截取处理，支取前n个数据，

Stream limit(long maxSize);

参数是一个long类型的数值，如果集合当前长度大于参数就进行截取，否则不操作：

public static void main(String[] args) {

Stream.of(“a1”, “a2”, “a3”,“bb”,“cc”,“aa”,“dd”)

.limit(3)

.forEach(System.out::println);

}

输出：

4.5 skip

在这里插入图片描述

如果希望跳过前面几个元素，可以使用skip方法获取一个截取之后的新流：

Stream skip(long n);

操作：

public static void main(String[] args) {

Stream.of(“a1”, “a2”, “a3”,“bb”,“cc”,“aa”,“dd”)

.skip(3)

.forEach(System.out::println);

}

输出：

4.6 map

如果我们需要将流中的元素映射到另一个流中，可以使用map方法：

Stream map(Function<? super T, ? extends R> mapper);

在这里插入图片描述

该接口需要一个Function函数式接口参数，可以将当前流中的T类型数据转换为另一种R类型的数据

public static void main(String[] args) {

Stream.of(“1”, “2”, “3”,“4”,“5”,“6”,“7”)

//.map(msg->Integer.parseInt(msg))

.map(Integer::parseInt)

.forEach(System.out::println);

}

4.7 sorted

如果需要将数据排序，可以使用sorted方法：

Stream sorted();

在使用的时候可以根据自然规则排序，也可以通过比较强来指定对应的排序规则

public static void main(String[] args) {

Stream.of(“1”, “3”, “2”,“4”,“0”,“9”,“7”)

//.map(msg->Integer.parseInt(msg))

.map(Integer::parseInt)

//.sorted() // 根据数据的自然顺序排序

.sorted((o1,o2)->o2-o1) // 根据比较强指定排序规则

.forEach(System.out::println);

}

4.8 distinct

如果要去掉重复数据，可以使用distinct方法：

Stream distinct();

在这里插入图片描述

使用：

public static void main(String[] args) {

Stream.of(“1”, “3”, “3”,“4”,“0”,“1”,“7”)

//.map(msg->Integer.parseInt(msg))

.map(Integer::parseInt)

//.sorted() // 根据数据的自然顺序排序

.sorted((o1,o2)->o2-o1) // 根据比较强指定排序规则

.distinct() // 去掉重复的记录

.forEach(System.out::println);

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

Stream.of(

new Person(“张三”,18)

,new Person(“李四”,22)

,new Person(“张三”,18)

).distinct()

.forEach(System.out::println);

}

Stream流中的distinct方法对于基本数据类型是可以直接出重的，但是对于自定义类型，我们是需要重写hashCode和equals方法来移除重复元素。

4.9 match

如果需要判断数据是否匹配指定的条件，可以使用match相关的方法

boolean anyMatch(Predicate<? super T> predicate); // 元素是否有任意一个满足条件

boolean allMatch(Predicate<? super T> predicate); // 元素是否都满足条件

boolean noneMatch(Predicate<? super T> predicate); // 元素是否都不满足条件

使用

public static void main(String[] args) {

boolean b = Stream.of(“1”, “3”, “3”, “4”, “5”, “1”, “7”)

.map(Integer::parseInt)

//.allMatch(s -> s > 0)

//.anyMatch(s -> s >4)

.noneMatch(s -> s > 4)

;

System.out.println(b);

}

注意match是一个终结方法

4.10 find

如果我们需要找到某些数据，可以使用find方法来实现

Optional findFirst();

Optional findAny();

在这里插入图片描述

使用：

public static void main(String[] args) {

Optional first = Stream.of(“1”, “3”, “3”, “4”, “5”, “1”, “7”).findFirst();

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

Optional any = Stream.of(“1”, “3”, “3”, “4”, “5”, “1”, “7”).findAny();

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

}

4.11 max和min

在这里插入图片描述

如果我们想要获取最大值和最小值，那么可以使用max和min方法

Optional min(Comparator<? super T> comparator);

Optional max(Comparator<? super T> comparator);

使用

public static void main(String[] args) {

Optional max = Stream.of(“1”, “3”, “3”, “4”, “5”, “1”, “7”)

.map(Integer::parseInt)

.max((o1,o2)->o1-o2);

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

Optional min = Stream.of(“1”, “3”, “3”, “4”, “5”, “1”, “7”)

.map(Integer::parseInt)

.min((o1,o2)->o1-o2);

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

}

4.12 reduce方法

在这里插入图片描述

如果需要将所有数据归纳得到一个数据，可以使用reduce方法

T reduce(T identity, BinaryOperator accumulator);

使用：

public static void main(String[] args) {

Integer sum = Stream.of(4, 5, 3, 9)

// identity默认值

// 第一次的时候会将默认值赋值给x

// 之后每次会将上一次的操作结果赋值给x y就是每次从数据中获取的元素

.reduce(0, (x, y) -> {

System.out.println(“x=”+x+“,y=”+y);

return x + y;

});

System.out.println(sum);

// 获取最大值

Integer max = Stream.of(4, 5, 3, 9)

.reduce(0, (x, y) -> {

return x > y ? x : y;

});

System.out.println(max);

}

4.13 map和reduce的组合

在实际开发中我们经常会将map和reduce一块来使用

public static void main(String[] args) {

// 1.求出所有年龄的总和

Integer sumAge = Stream.of(

new Person(“张三”, 18)

, new Person(“李四”, 22)

, new Person(“张三”, 13)

, new Person(“王五”, 15)

, new Person(“张三”, 19)

).map(Person::getAge) // 实现数据类型的转换

.reduce(0, Integer::sum);

System.out.println(sumAge);

// 2.求出所有年龄中的最大值

Integer maxAge = Stream.of(

new Person(“张三”, 18)

, new Person(“李四”, 22)

, new Person(“张三”, 13)

, new Person(“王五”, 15)

, new Person(“张三”, 19)

).map(Person::getAge) // 实现数据类型的转换，符合reduce对数据的要求

.reduce(0, Math::max); // reduce实现数据的处理

System.out.println(maxAge);

// 3.统计字符 a 出现的次数

Integer count = Stream.of(“a”, “b”, “c”, “d”, “a”, “c”, “a”)

.map(ch -> “a”.equals(ch) ? 1 : 0)

.reduce(0, Integer::sum);

System.out.println(count);

}

输出结果

4.14 mapToInt

如果需要将Stream中的Integer类型转换成int类型，可以使用mapToInt方法来实现

在这里插入图片描述

使用

public static void main(String[] args) {

// Integer占用的内存比int多很多，在Stream流操作中会自动装修和拆箱操作

Integer arr[] = {1,2,3,5,6,8};

Stream.of(arr)

.filter(i->i>0)

.forEach(System.out::println);

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

// 为了提高程序代码的效率，我们可以先将流中Integer数据转换为int数据，然后再操作

IntStream intStream = Stream.of(arr)

.mapToInt(Integer::intValue);

intStream.filter(i->i>3)

.forEach(System.out::println);

}

4.15 concat

如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat

public static Stream concat(Stream<? extends T> a, Stream<? extends T> b) {

Objects.requireNonNull(a);

Objects.requireNonNull(b);

@SuppressWarnings(“unchecked”)

Spliterator split = new Streams.ConcatSpliterator.OfRef<>(

(Spliterator) a.spliterator(), (Spliterator) b.spliterator());

Stream stream = StreamSupport.stream(split, a.isParallel() || b.isParallel());

return stream.onClose(Streams.composedClose(a, b));

}

使用:

public static void main(String[] args) {

Stream stream1 = Stream.of(“a”,“b”,“c”);

Stream stream2 = Stream.of(“x”, “y”, “z”);

// 通过concat方法将两个流合并为一个新的流

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

}

4.16 综合案例

定义两个集合，然后在集合中存储多个用户名称。然后完成如下的操作：

第一个队伍只保留姓名长度为3的成员
第一个队伍筛选之后只要前3个人
第二个队伍只要姓张的成员
第二个队伍筛选之后不要前两个人
将两个队伍合并为一个队伍
根据姓名创建Person对象
打印整个队伍的Person信息

package com.bobo.jdk.stream;

import com.bobo.jdk.lambda.domain.Person;

import java.util.Arrays;

import java.util.List;

import java.util.stream.Stream;

public class StreamTest21Demo {

/**

1. 第一个队伍只保留姓名长度为3的成员
1. 第一个队伍筛选之后只要前3个人
1. 第二个队伍只要姓张的成员
1. 第二个队伍筛选之后不要前两个人
1. 将两个队伍合并为一个队伍
1. 根据姓名创建Person对象
1. 打印整个队伍的Person信息
@param args

public static void main(String[] args) {

List list1 = Arrays.asList(“迪丽热巴”, “宋远桥”, “苏星河”, “老子”, “庄子”, “孙子”, “洪七公”);

List list2 = Arrays.asList(“古力娜扎”, “张无忌”, “张三丰”, “赵丽颖”, “张二狗”, “张天爱”, “张三”);

// 1. 第一个队伍只保留姓名长度为3的成员

// 2. 第一个队伍筛选之后只要前3个人

Stream stream1 = list1.stream().filter(s -> s.length() == 3).limit(3);

// 3. 第二个队伍只要姓张的成员

// 4. 第二个队伍筛选之后不要前两个人

Stream stream2 = list2.stream().filter(s -> s.startsWith(“张”)).skip(2);

// 5. 将两个队伍合并为一个队伍

// 6. 根据姓名创建Person对象

// 7. 打印整个队伍的Person信息

Stream.concat(stream1,stream2)

//.map(n-> new Person(n))

.map(Person::new)

.forEach(System.out::println);

}

输出结果：

Person{name=‘宋远桥’, age=null, height=null}

Person{name=‘苏星河’, age=null, height=null}

Person{name=‘张二狗’, age=null, height=null}

Person{name=‘张天爱’, age=null, height=null}

Person{name=‘张三’, age=null, height=null}

5.Stream结果收集

5.1 结果收集到集合中

/**

Stream结果收集
收集到集合中

@Test

public void test01(){

// Stream stream = Stream.of(“aa”, “bb”, “cc”);

List list = Stream.of(“aa”, “bb”, “cc”,“aa”)

.collect(Collectors.toList());

System.out.println(list);

// 收集到 Set集合中

Set set = Stream.of(“aa”, “bb”, “cc”, “aa”)

.collect(Collectors.toSet());

System.out.println(set);

// 如果需要获取的类型为具体的实现，比如：ArrayList HashSet

ArrayList arrayList = Stream.of(“aa”, “bb”, “cc”, “aa”)

//.collect(Collectors.toCollection(() -> new ArrayList<>()));

.collect(Collectors.toCollection(ArrayList::new));

System.out.println(arrayList);

HashSet hashSet = Stream.of(“aa”, “bb”, “cc”, “aa”)

.collect(Collectors.toCollection(HashSet::new));

System.out.println(hashSet);

}

输出：

[aa, bb, cc, aa]

[aa, bb, cc]

[aa, bb, cc, aa]

[aa, bb, cc]

5.2 结果收集到数组中

Stream中提供了toArray方法来将结果放到一个数组中，返回值类型是Object[],如果我们要指定返回的类型，那么可以使用另一个重载的toArray(IntFunction f)方法

/**

Stream结果收集到数组中

@Test

public void test02(){

Object[] objects = Stream.of(“aa”, “bb”, “cc”, “aa”)

.toArray(); // 返回的数组中的元素是 Object类型

System.out.println(Arrays.toString(objects));

// 如果我们需要指定返回的数组中的元素类型

String[] strings = Stream.of(“aa”, “bb”, “cc”, “aa”)

.toArray(String[]::new);

System.out.println(Arrays.toString(strings));

}

5.3 对流中的数据做聚合计算

当我们使用Stream流处理数据后，可以像数据库的聚合函数一样对某个字段进行操作，比如获得最大值，最小值，求和，平均值，统计数量。

/**

Stream流中数据的聚合计算

@Test

public void test03(){

// 获取年龄的最大值

Optional maxAge = Stream.of(

new Person(“张三”, 18)

, new Person(“李四”, 22)

, new Person(“张三”, 13)

, new Person(“王五”, 15)

, new Person(“张三”, 19)

).collect(Collectors.maxBy((p1, p2) -> p1.getAge() - p2.getAge()));

System.out.println(“最大年龄：” + maxAge.get());

// 获取年龄的最小值

Optional minAge = Stream.of(

new Person(“张三”, 18)

, new Person(“李四”, 22)

, new Person(“张三”, 13)

, new Person(“王五”, 15)

, new Person(“张三”, 19)

).collect(Collectors.minBy((p1, p2) -> p1.getAge() - p2.getAge()));

System.out.println(“最新年龄:” + minAge.get());

// 求所有人的年龄之和

Integer sumAge = Stream.of(

new Person(“张三”, 18)

, new Person(“李四”, 22)

, new Person(“张三”, 13)

, new Person(“王五”, 15)

, new Person(“张三”, 19)

)

//.collect(Collectors.summingInt(s -> s.getAge()))

.collect(Collectors.summingInt(Person::getAge))

;

System.out.println(“年龄总和：” + sumAge);

// 年龄的平均值

Double avgAge = Stream.of(

new Person(“张三”, 18)

, new Person(“李四”, 22)

, new Person(“张三”, 13)

, new Person(“王五”, 15)

, new Person(“张三”, 19)

).collect(Collectors.averagingInt(Person::getAge));

System.out.println(“年龄的平均值：” + avgAge);

// 统计数量

Long count = Stream.of(

new Person(“张三”, 18)

, new Person(“李四”, 22)

, new Person(“张三”, 13)

, new Person(“王五”, 15)

, new Person(“张三”, 19)

).filter(p->p.getAge() > 18)

.collect(Collectors.counting());

System.out.println(“满足条件的记录数:” + count);

}

5.4 对流中数据做分组操作

当我们使用Stream流处理数据后，可以根据某个属性将数据分组

/**

分组计算

@Test

public void test04(){

// 根据账号对数据进行分组

Map<String, List> map1 = Stream.of(

new Person(“张三”, 18, 175)

, new Person(“李四”, 22, 177)

, new Person(“张三”, 14, 165)

, new Person(“李四”, 15, 166)

, new Person(“张三”, 19, 182)

).collect(Collectors.groupingBy(Person::getName));

map1.forEach((k,v)-> System.out.println(“k=” + k +“\t”+ “v=” + v));

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

// 根据年龄分组如果大于等于18 成年否则未成年

Map<String, List> map2 = Stream.of(

new Person(“张三”, 18, 175)

, new Person(“李四”, 22, 177)

, new Person(“张三”, 14, 165)

, new Person(“李四”, 15, 166)

, new Person(“张三”, 19, 182)

).collect(Collectors.groupingBy(p -> p.getAge() >= 18 ? “成年” : “未成年”));

map2.forEach((k,v)-> System.out.println(“k=” + k +“\t”+ “v=” + v));

}

输出结果：

k=李四 v=[Person{name=‘李四’, age=22, height=177}, Person{name=‘李四’, age=15, height=166}]

k=张三 v=[Person{name=‘张三’, age=18, height=175}, Person{name=‘张三’, age=14, height=165}, Person{name=‘张三’, age=19, height=182}]

k=未成年 v=[Person{name=‘张三’, age=14, height=165}, Person{name=‘李四’, age=15, height=166}]

k=成年 v=[Person{name=‘张三’, age=18, height=175}, Person{name=‘李四’, age=22, height=177}, Person{name=‘张三’, age=19, height=182}]

多级分组: 先根据name分组然后根据年龄分组

/**

分组计算–多级分组

@Test

public void test05(){

// 先根据name分组，然后根据age(成年和未成年)分组

Map<String,Map<Object,List>> map = Stream.of(

new Person(“张三”, 18, 175)

, new Person(“李四”, 22, 177)

, new Person(“张三”, 14, 165)

, new Person(“李四”, 15, 166)

, new Person(“张三”, 19, 182)

).collect(Collectors.groupingBy(

Person::getName

,Collectors.groupingBy(p->p.getAge()>=18?“成年”:“未成年”

)

));

map.forEach((k,v)->{

System.out.println(k);

v.forEach((k1,v1)->{

System.out.println(“\t”+k1 + “=” + v1);

});

}

输出结果：

李四

未成年=[Person{name=‘李四’, age=15, height=166}]

成年=[Person{name=‘李四’, age=22, height=177}]

张三

未成年=[Person{name=‘张三’, age=14, height=165}]

成年=[Person{name=‘张三’, age=18, height=175}, Person{name=‘张三’, age=19, height=182}]

5.5 对流中的数据做分区操作

Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表，一个true列表，一个false列表

在这里插入图片描述

/**

分区操作

@Test

public void test06(){

Map<Boolean, List> map = Stream.of(

new Person(“张三”, 18, 175)

, new Person(“李四”, 22, 177)

, new Person(“张三”, 14, 165)

, new Person(“李四”, 15, 166)

, new Person(“张三”, 19, 182)

1200页Java架构面试专题及答案

小编整理不易，对这份1200页Java架构面试专题及答案感兴趣劳烦帮忙转发/点赞

百度、字节、美团等大厂常见面试题

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

分组计算–多级分组

@Test

public void test05(){

// 先根据name分组，然后根据age(成年和未成年)分组

Map<String,Map<Object,List>> map = Stream.of(

new Person(“张三”, 18, 175)

, new Person(“李四”, 22, 177)

, new Person(“张三”, 14, 165)

, new Person(“李四”, 15, 166)

, new Person(“张三”, 19, 182)

).collect(Collectors.groupingBy(

Person::getName

,Collectors.groupingBy(p->p.getAge()>=18?“成年”:“未成年”

)

));

map.forEach((k,v)->{

System.out.println(k);

v.forEach((k1,v1)->{

System.out.println(“\t”+k1 + “=” + v1);

});

}

输出结果：

李四

未成年=[Person{name=‘李四’, age=15, height=166}]

成年=[Person{name=‘李四’, age=22, height=177}]

张三

未成年=[Person{name=‘张三’, age=14, height=165}]

成年=[Person{name=‘张三’, age=18, height=175}, Person{name=‘张三’, age=19, height=182}]

5.5 对流中的数据做分区操作

Collectors.partitioningBy会根据值是否为true,把集合中的数据分割为两个列表，一个true列表，一个false列表

在这里插入图片描述

/**

分区操作

@Test

public void test06(){

Map<Boolean, List> map = Stream.of(

new Person(“张三”, 18, 175)

, new Person(“李四”, 22, 177)

, new Person(“张三”, 14, 165)

, new Person(“李四”, 15, 166)

, new Person(“张三”, 19, 182)

1200页Java架构面试专题及答案

小编整理不易，对这份1200页Java架构面试专题及答案感兴趣劳烦帮忙转发/点赞

[外链图片转存中…(img-LGftNOMk-1715545185581)]

[外链图片转存中…(img-cd0ihDZ2-1715545185582)]

百度、字节、美团等大厂常见面试题

[外链图片转存中…(img-z2H95HT6-1715545185582)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

2401_84584682

关注

12
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
把Stream流学透了你也能写出简洁高效的代码，快来点击进来看看吧(建议收藏)

作为过来人，小编是整理了很多进阶架构视频资料、面试文档以及PDF的学习资料，针对上面一套系统大纲小编也有对应的相关进阶架构视频资料// 1.获取所有姓张的信息// 2.获取名称长度为3的用户// 3. 输出所有的用户信息.filter(s->s.startsWith(“张”))});.filter(s->s.startsWith(“张”))上面的SteamAPI代码的含义：获取流，过滤张，过滤长度，逐一打印。代码相比于上面的案例更加的简洁直观2. Steam流式思想概述。
复制链接

扫一扫