文章目录
- Stream流式编程
-
- 一、Stream流式编程介绍
- 二、Stream流的三类方法
- 三、创建Stream流的方式
-
- （1）方式1：根据集合获取流
-
- ⭐ 单列集合代码演示
- ⭐ 双列集合代码演示
- （2）方式2：根据of方法获取流（常用）
-
- ⭐ of方法获取流代码演示
- 四、Stream流的常用方法
-
- 1、终结方法
-
- （1）count方法：返回流中的元素个数（统计个数）
- （2）foreach方法：遍历流中的数据
-
- ⚡foreach使用注意
- 2、中间方法
-
- （1）filter 方法：过滤数据，得到符合条件的数据，放入到Stream中，返回新的流
-
- ⚡ filter使用注意
- （2）limit(n)方法：截取前n个数据，返回新Stream流（截取超过长度的时候不会报错，会把所有数据截取）
-
- ⚡limit注意：当截取超过流的长度
- （3）skip(n)方法： 跳过前n个数据，返回到新Stream流（数量不够也不会报错，只不过没有数据）
-
- ⚡skip 注意：当跳过超过流的长度
- （4）map 方法：数据转换,将流中的数据类型进行转换
-
- ⚡ map方法的应用场景
- ⚡ map方法的使用注意
- 3、静态方法
-
- （1）concat方法： static Stream concat(流1，流2) ， 可以把两个流合并成一个新的流
- 五、Stream流的使用注意
-
- 🔺代码演示1：流只能使用一次
- 🔺 代码演示2：终结方法如果没有调用，中间方法也不会执行
- 六、Stream流的收集
-
- 1、Stream流收集到数组
-
- 🔺代码演示
- 2、Stream流收集到集合
-
- 🔺代码演示1：收集到List集合
- 🔺 演示2：收集到Set集合
- 作者：KJ.JK
Stream流式编程
🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈 🌈
🍂个人博客首页： KJ.JK
欢迎大家点赞👍收藏💖评论💬关注🔒
💖源码获取 | 💻学习交流 | 🤝商务合作 | 💨私信作者
一、Stream流式编程介绍
* 从JDK8开始，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于简化已有集合类的数据操作。
* Stream流相当于工厂里面的流水线，提供了丰富的API，方便对数据进行加工处理
二、Stream流的三类方法
* 获取Stream流
"创建一条流水线"，并把数据放到流水线上准备进行操作
* 中间方法
流水线上的操作，一次操作完毕之后，"还可以继续进行其他操作"
* 终结方法
是流水线上的最后一个操作，"一个Stream流只能有一次终结方法"
三、创建Stream流的方式
（1）方式1：根据集合获取流
Collection根接口中提供了 "stream( ) 方法" 可以获取流
* 单列集合:
"直接调用stream()方法"即可
* 双列集合:
"先获取键和值的单列集合"，再通过集合"获取键和值各自的Stream流"
⭐ 单列集合代码演示
ArrayList<Integer> list=new ArrayList<>();
list.add(11);
list.add(22);
Stream<Integer> st = list.stream();
⭐ 双列集合代码演示
HashMap<String,String> map=new HashMap<>();
//获取键的集合/值的集合
//通过键和值的集合,各自获取对应的Stream
//获取键的集合
Set<String> keySet = map.keySet();
//获取键集合对应的Stream流
Stream<String> stream = keySet.stream();
//获取值的集合,(调用map对象.values方法即可)
Collection<String> values = map.values();
//获取值集合对应的Stream流
Stream<String> stream1 = values.stream();
（2）方式2：根据of方法获取流（常用）
Stream类提供了静态的 "of( ) 方法"，可以创建一个流对象
* Stream.of(T ... values)
⭐ of方法获取流代码演示
//根据of方法获取流(数据不在集合中)
Stream<Integer> i = Stream.of(11, 22, 33);
Stream<String> s1 = Stream.of("java", "mysql");
四、Stream流的常用方法
1、终结方法
（1）count方法：返回流中的元素个数（统计个数）
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);
long count = stream.count();
System.out.println(count); //5
（2）foreach方法：遍历流中的数据
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);
//遍历流中的数据
//匿名内部类
stream.forEach(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
}
});
优化输出
⚡foreach使用注意
forEach里面是一个"Consumer函数式接口",每次使用可以先new这个接口出来,再对应使用Lambda简化
2、中间方法
（1）filter 方法：过滤数据，得到符合条件的数据，放入到Stream中，返回新的流
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55,66);
Stream<Integer> stream1 = stream.filter(new Predicate<Integer>() { //会返回一个筛选过的流,记得接它
/*
a代表流的每个元素
返回值为true,数据就会保留
返回值为false,数据就会被去掉
*/
@Override
public boolean test(Integer a) {
return a % 2 == 0;
}
});
//简化效果
// Stream<Integer> stream1 = stream.filter(a -> a % 2 == 0);
//遍历
stream1.forEach(integer -> {
System.out.println(integer); //22 ,44
});
⚡ filter使用注意
filter里面是一个"Predicate函数式接口",每次使用可以先new这个接口出来,再对应使用Lambda简化
（2）limit(n)方法：截取前n个数据，返回新Stream流（截取超过长度的时候不会报错，会把所有数据截取）
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);
//截取前3个数据
Stream<Integer> limit = stream.limit(3);
//遍历
limit.forEach(integer -> System.out.println(integer)); //11 22 33
⚡limit注意：当截取超过流的长度
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);
//截取前40个数据,如果数量不够,也不会报错
Stream<Integer> limit1 = stream.limit(40);
limit1.forEach(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer); //11 22 33 44 55 66
}
});
（3）skip(n)方法： 跳过前n个数据，返回到新Stream流（数量不够也不会报错，只不过没有数据）
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);
//跳过前三个数据
Stream<Integer> skip = stream.skip(3);
skip.forEach(integer -> System.out.println(integer)); // 44 55 66
⚡skip 注意：当跳过超过流的长度
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55, 66);
// 跳过前20个数据,数量不够也不会报错
Stream<Integer> skip1 = stream.skip(20);
skip1.forEach(integer -> System.out.println(integer)); //什么都没有了,不会报错
（4）map 方法：数据转换,将流中的数据类型进行转换
//将流中的字符串转为整数类型
Stream<String> stream = Stream.of("11", "22", "33", "44", "55", "66");
/*
String: 流中数据原来的类型
Integer : 要变的类型
*/
Stream<Integer> stream1 = stream.map(new Function<String, Integer>() { //有返回值,记得接
@Override
public Integer apply(String s) {
return Integer.parseInt(s); //这步需要自己操作转换对应的类型
}
});
⚡ map方法的应用场景
Stream<String> stream = Stream.of("11", "22", "33", "44", "55", "66");
//把String流变成Integer流,再进行筛选奇数的流出来并遍历
Stream<Integer> stream1 = stream.map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s);
}
});
Stream<Integer> stream2 = stream1.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
return integer % 2 != 0;
}
});
stream2.forEach(new Consumer<Integer>() {
@Override
public void accept(Integer integer) {
System.out.println(integer);
}
});
⚡ map方法的使用注意
map里面是一个"Function函数式接口",每次使用可以先new这个接口出来,再对应使用Lambda简化
3、静态方法
（1）concat方法： static Stream concat(流1，流2) ， 可以把两个流合并成一个新的流
Stream<Integer> stream = Stream.of(11, 22);
Stream<Integer> stream1 = Stream.of(33, 44);
//合并流(前提是两个流的数据类型是一样的)
Stream<Integer> concat = Stream.concat(stream, stream1);
//方法引用简化输出
concat.forEach(System.out::println); //11 22 33 44
🔥系列热门专栏🔥：
⚡《JavaEE进阶序列 | 从小白到工程师》系列文章⚡
⚡《JavaEE项目实战》系列文章⚡
⚡《JavaSwing项目合集》系列文章⚡
⚡《数据分析中的pandas》系列文章⚡
五、Stream流的使用注意
* Stream 流的常用方法大体分为两类
1.中间方法:
返回值类型是一个新的Stream流,可以继续往后处理值
2.终结方法:
返回值类型不是Stream,流的处理已经结束
* Stream 流的使用注意:
1. "一个Stream流对象只能操作一次"
2. "终结方法如果没有调用,中间方法也不会执行"
//终结方法有 count、forEach
🔺代码演示1：流只能使用一次
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);
long count = stream.count();
System.out.println(count);
//流只能用一次
stream.forEach(System.out::println); //stream has already been operated upon or closed
🔺 代码演示2：终结方法如果没有调用，中间方法也不会执行
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);
stream.filter(new Predicate<Integer>() {
@Override
public boolean test(Integer integer) {
System.out.println(integer);
return integer%2==0;
}
}); //不会执行,什么都没有
六、Stream流的收集
1、Stream流收集到数组
*格式:
Object[] toArray();
*范例:
Stream<String> st = Stream.of("11", "22", "33","44");
Object[] arr = st.toArray();
🔺代码演示
Stream<Integer> stream = Stream.of(11, 22, 33, 44);
//流转为数组
Object[] array = stream.toArray();
System.out.println(Arrays.toString(array)); //[11, 22, 33, 44]
2、Stream流收集到集合
* 格式:
collect(Collector <? super T,A,R> collector) 提供一个流收集器,用于收集数据,返回集合对象
1."收集到List集合"
stream对象.collect(Collectors.toList());
2."收集到Set集合"
stream对象.collect(Collectors.toSet());
🔺代码演示1：收集到List集合
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);
//收集到List集合
List<Integer> list = stream.collect(Collectors.toList());
System.out.println(list); //[11, 22, 33, 44, 55]
🔺 演示2：收集到Set集合
Stream<Integer> stream = Stream.of(11, 22, 33, 44, 55);
//收集到Set集合
Set<Integer> set = stream.collect(Collectors.toSet());
System.out.println(set); //[33, 22, 55, 11, 44]
作者：KJ.JK
文章对你有所帮助的话，欢迎给个赞或者 star，你的支持是对作者最大的鼓励，不足之处可以在评论区多多指正，交流学习
版权声明：程序员胖胖胖虎阿 发表于 2023年9月3日 下午3:48。
转载请注明：【JavaEE进阶系列 | 从小白到工程师】JavaEE中的Stream流知识点使用，精华总结，一文直接上手 | 胖虎的工具箱-编程导航
转载请注明：【JavaEE进阶系列 | 从小白到工程师】JavaEE中的Stream流知识点使用，精华总结，一文直接上手 | 胖虎的工具箱-编程导航
相关文章
暂无评论...
致力于称为最好的程序员导航网站