1、forEach方法
|
|
- 该方法接收一个Consumer接口是一个 消费型 的函数式接口，可以传递Lambda表达式，消费数据
- 用来遍历流中的数据，是一个 终结 方法，遍历 之后就不能继续调用Stream流中的其他方法
|
package com.csdn.stream;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class Demo02Stream_forEach {
public static void main(String[] args) {
//获取一个Stream流
Stream<String> stream = Stream.of("小明", "小兰", "小强");
// stream.forEach(new Consumer<String>() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
// stream.forEach(name -> System.out.println(name));
stream.forEach(System.out::println);//小明 小兰 小强
}
}
2、 filter方法
|
|
- 用于对Stream流中的数据进行 过滤 ，方法的参数Predicate是一个函数式接口，所以可以传递Lambda表达式，对数据进行过滤
|
package com.csdn.stream;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class Demo03Stream_filter {
public static void main(String[] args) {
Stream<String> stream = Stream.of("张三丰", "张翠山", "张无忌", "赵敏", "周芷若");
// stream.filter(new Predicate<String>() {
// @Override
// public boolean test(String s) {
// return s.startsWith("张");
// }
// }).forEach(new Consumer<String>() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
// Stream<String> stream2 = stream.filter(name -> name.startsWith("张"));
// stream2.forEach(System.out::println);
// stream.filter(name->name.startsWith("张")).forEach(name-> System.out.println(name));
stream.filter(name -> name.startsWith("张")).forEach(System.out::println);
// 张三丰
// 张翠山
// 张无忌
}
}
3、Stream流的特点
- 只能使用一次，Stream流属于管道流，只能被消费（使用）一次，第一个Stream流调用完毕方法，数据就会流转到下一个Stream上，而这时第一个Stream流已经使用完毕，就会关闭了，所以第一个Stream流就不能再调用方法了
package com.csdn.stream;
import java.util.function.Consumer;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class Demo03Stream_filter {
public static void main(String[] args) {
Stream<String> stream = Stream.of("张三丰", "张翠山", "张无忌", "赵敏", "周芷若");
Stream<String> stream2 = stream.filter(name -> name.startsWith("张"));
stream2.forEach(System.out::println);//张三丰 张翠山 张无忌
//遍历Stream流
stream.forEach(System.out::println);//IllegalStateException
}
}
D:\Java\jdk-17\bin\java.exe
张三丰
张翠山
张无忌
Exception in thread "main" java.lang.IllegalStateException: stream has already been operated upon or closed
at java.base/java.util.stream.AbstractPipeline.sourceStageSpliterator(AbstractPipeline.java:279)
at java.base/java.util.stream.ReferencePipeline$Head.forEach(ReferencePipeline.java:762)
at com.csdn.stream.Demo03Stream_filter.main(Demo03Stream_filter.java:16)
4、map方法
|
|
- 如果需要将流中的元素映射到另一个流中，可以使用map方法，该接口需要一个Function函数式接口，可以将当前流中的 T 类型数据转换为另一种 R 类型的流
|
package com.csdn.stream;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.stream.Stream;
public class Demo04Stream_map {
public static void main(String[] args) {
//获取一个String类型的Stream流
Stream<String> stringStream = Stream.of("1", "2", "3", "4", "5");
// Stream<Integer> integerStream = stringStream.map(new Function<String, Integer>() {
// @Override
// public Integer apply(String s) {
// return Integer.parseInt(s);
// }
// });
// integerStream.forEach(new Consumer<Integer>() {
// @Override
// public void accept(Integer integer) {
// System.out.println(integer);
// }
// });
//使用map方法，把字符串类型的整数，转换（映射）为Integer类型的整数
Stream<Integer> integerStream = stringStream.map(Integer::parseInt);
//遍历integerStream流
integerStream.forEach(System.out::println);//1 2 3 4 5
}
}
5、count方法
|
|
- 用于统计Stream流中 元素的个数 ，是一个 终结方法 ，返回值是一个long类型的整数，所以不能再继续调用Stream流中的其他方法了
|
package com.csdn.stream;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Stream;
public class Demo05Stream_count {
public static void main(String[] args) {
List<String> list = new ArrayList<>();
Collections.addAll(list, "1", "2", "3", "4", "5");
Stream<String> stream = list.stream();
System.out.println(stream.count());//5
}
}
6、limit方法
|
|
- 用于 截取 流中的元素，limit方法可以对流进行截取，只取用前 n 个，参数是一个long型，如果集合当前长度大于参数则进行截取，否则不进行操作
- limit方法是一个 延迟方法 ，只是对流中的元素进行截取，返回的是一个新的流，所以可以继续调用Stream流中的其他方法
|
package com.csdn.stream;
import java.util.stream.Stream;
public class Demo06Stream_limit {
public static void main(String[] args) {
String[] arr = {"喜羊羊", "美羊羊", "懒洋洋", "灰太狼", "红太狼"};
//获取一个Stream流
Stream<String> arr1 = Stream.of(arr);
//使用limit对Stream流中的元素进行截取，只要前3个元素
Stream<String> limit = arr1.limit(3);
//遍历limit流
limit.forEach(System.out::println);//喜羊羊 美羊羊 懒洋洋
}
}
7、skip方法
|
|
- skip用于 跳过 元素，如果希望 跳过前几个元素，可以使用skip方法获取一个截取之后的新流，如果流的当前长度大于 n ，则跳过前 n 个；否则将会得到一个长度为 0 的空流
|
package com.csdn.stream;
import java.util.stream.Stream;
public class Demo07Stream_skip {
public static void main(String[] args) {
String[] arr = new String[]{"喜羊羊", "美羊羊", "懒洋洋", "灰太狼", "红太狼"};
//获取一个Stream流
Stream<String> arr1 = Stream.of(arr);
//使用skip方法跳过前3个元素
Stream<String> skip = arr1.skip(3);
//遍历skip流
skip.forEach(System.out::println);//灰太狼 红太狼
}
}
8、concat方法（concatenate）
|
|
- 用于把流 组合 到一起，如果有两个流，希望合并成为一个流，那么可以使用Stream接口的静态方法concat
|
package com.csdn.stream;
import java.util.stream.Stream;
public class Demo08Stream_concat {
public static void main(String[] args) {
String[] arr = {"喜羊羊", "美羊羊", "懒洋洋", "灰太狼", "红太狼"};
//创建一个Stream流
Stream<String> arr1 = Stream.of(arr);
//获取一个Stream流
Stream<String> arr2 = Stream.of("张三丰", "张翠山", "张无忌", "赵敏", "周芷若");
//把以上两个流组合为一个流
Stream<String> concatenate = Stream.concat(arr1, arr2);
//遍历concatenate流
concatenate.forEach(System.out::println);// 喜羊羊 美羊羊 懒洋洋 灰太狼 红太狼 张三丰 张翠山 张无忌 赵敏 周芷若
}
}
