- 1.Stream 流的获取方法
- 2.Stream 流的常见中间方法
- 3.Stream 流的常见终结方法
- 4.Stream 流的收集方法
获取 Stream 流：创建一条流水线，并把数据放到流水线上准备进行操作。
中间方法：流水线上的操作。一次操作完毕之后，还可以继续进行其他操作。
终结方法：一个 Stream 流只能有一个终结方法，是流水线上的最后一个操作。
示例：创建一个集合，存储多个字符串元素 “张三丰”, “张无忌”, “张翠山”, “王二麻子”, “张良”, “谢广坤”，把集合中所有以 “张” 开头的元素存储到一个新的集合，再把 “张” 开头的集合中的长度为 3 的元素存储到一个新的集合并遍历。
package com.qdu.streamdemo;
import java.util.ArrayList;
import java.util.List;
public class MyStream1 {
public static void main(String[] args) {
// 集合的批量添加
ArrayList list1 = new ArrayList<>(List.of("张三丰","张无忌","张翠山","王二麻子","张良","谢广坤"));
// 遍历list1把以"张"开头的元素添加到list2中
ArrayList list2 = new ArrayList<>();
for (String s : list1) {
if(s.startsWith("张")) {
list2.add(s);
}
}
// 遍历list2集合，把其中长度为3的元素添加到list3中
ArrayList list3 = new ArrayList<>();
for (String s : list2) {
if(s.length() == 3) {
list3.add(s);
}
}
for (String s : list3) {
System.out.println(s);
}
System.out.println("------------------------------");
// Stream流
list1.stream().filter(s->s.startsWith("张"))
.filter(s->s.length() == 3)
.forEach(s-> System.out.println(s));
}
}
1.Stream 流的获取方法
(1) 单列集合：可以使用 Collection 接口中的默认方法 default Stream
package com.qdu.streamdemo;
import java.util.ArrayList;
public class MyStream2 {
public static void main(String[] args) {
// 单列集合
ArrayList list = new ArrayList<>();
list.add("aaa");
list.add("bbb");
list.add("ccc");
// Stream stream = list.stream();
// stream.forEach(s-> System.out.println(s));
list.stream().forEach(s-> System.out.println(s));
}
}
(2) 双列集合：间接地生成流。可以先通过 keySet 或者 entrySet 获取一个 Set 集合，再获取 Stream 流。
package com.qdu.streamdemo;
import java.util.HashMap;
public class MyStream2 {
public static void main(String[] args) {
// 双列集合
HashMap hm = new HashMap<>();
hm.put("zhangsan",23);
hm.put("lisi",24);
hm.put("wangwu",25);
hm.put("zhaoliu",26);
hm.put("qianqi",27);
// 双列集合不能直接获取Stream流
// keySet先获取到所有的键，再把这个Set集合中所有的键放到Stream流中
hm.keySet().stream().forEach(s-> System.out.println(s));
// entrySet先获取到所有的键值对对象，再把这个Set集合中所有的键值对对象放到Stream流中
hm.entrySet().stream().forEach(s-> System.out.println(s));
}
}
(3) 数组：Arrays 中的静态方法 stream() 生成流。
package com.qdu.streamdemo;
import java.util.Arrays;
public class MyStream2 {
public static void main(String[] args) {
int [] arr = {1, 2, 3, 4, 5};
Arrays.stream(arr).forEach(s-> System.out.println(s));
}
}
(4) 同种数据类型的多个数据：使用 Stream.of(T…values) 生成流
package com.qdu.streamdemo;
import java.util.stream.Stream;
public class MyStream2 {
public static void main(String[] args) {
Stream.of(1, 2, 3, 4, 5, 6, 7, 8).forEach(s-> System.out.println(s));
}
}
2.Stream 流的常见中间方法
(1) Stream
Predicate 接口中的方法 boolean test(T t)：对给定的参数进行判断，返回一个布尔值。
package com.qdu.streamdemo;
import java.util.ArrayList;
import java.util.function.Predicate;
public class MyStream3 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
// test方法中的s依次表示流中的每一个数据，
// 我们只要在test方法中对s进行判断就可以了，
// 如果判断的结果为true，则当前的数据留下，
// 如果判断的结果为false，则当前数据就不要。
list.stream().filter(
new Predicate() {
@Override
public boolean test(String s) {
boolean result = s.startsWith("张");
return result;
}
}
).forEach(s-> System.out.println(s));
System.out.println("---------------------------");
// 因为Predicate接口中只有一个抽象方法test，所以我们可以使用lambda表达式来简化
list.stream().filter(
(String s) -> {
boolean result = s.startsWith("张");
return result;
}
).forEach(s-> System.out.println(s));
System.out.println("---------------------------");
// lambda表达式还可以继续简化
list.stream().filter(s ->s.startsWith("张")).forEach(s-> System.out.println(s));
}
}
(2) Stream
package com.qdu.streamdemo;
import java.util.ArrayList;
public class MyStream4 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
// Stream limit(long maxSize)：截取指定参数个数的数据
list.stream().limit(2).forEach(s-> System.out.println(s));
}
}
(3) Stream
package com.qdu.streamdemo;
import java.util.ArrayList;
public class MyStream4 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
// Stream skip(long n)：跳过指定参数个数的数据
list.stream().skip(2).forEach(s-> System.out.println(s));
}
}
(4) static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流。
package com.qdu.streamdemo;
import java.util.ArrayList;
import java.util.stream.Stream;
public class MyStream4 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList<>();
list1.add("张三丰");
list1.add("张无忌");
list1.add("张翠山");
ArrayList list2 = new ArrayList<>();
list2.add("王二麻子");
list2.add("张良");
list2.add("谢广坤");
// Stream stream1 = list1.stream();
// Stream stream2 = list2.stream();
// Stream stream3 = Stream.concat(stream1, stream2);
// stream3.forEach(s-> System.out.println(s));
// static Stream concat(Stream a, Stream b)：合并a和b两个流为一个流
Stream.concat(list1.stream(), list2.stream()).forEach(s -> System.out.println(s));
}
}
(5) Stream distinct()：去除流中重复的元素。依赖hashCode和equals方法。
package com.qdu.streamdemo;
import java.util.ArrayList;
public class MyStream4 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
list.add("谢广坤");
list.add("谢广坤");
list.add("谢广坤");
list.add("谢广坤");
// Stream distinct()：去除流中重复的元素。依赖hashCode和equals方法。
list.stream().distinct().forEach(s -> System.out.println(s));
}
}
3.Stream 流的常见终结方法
(1) void forEach(Consumer action)：对此流的每个元素执行操作。
Consumer 接口中的方法 void accept(T t)：对给定的参数执行此操作。
package com.qdu.streamdemo;
import java.util.ArrayList;
import java.util.function.Consumer;
public class MyStream5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
list.stream().forEach(
new Consumer() {
@Override
public void accept(String s) {
System.out.println(s);
}
}
);
System.out.println("-------------------------");
// 因为Consumer接口中只有一个方法accept，所以可以使用lambda表达式进行简化
list.stream().forEach(
(String s) -> {
System.out.println(s);
}
);
System.out.println("-------------------------");
// lambda表达式还可以进一步简化
list.stream().forEach(s->System.out.println(s));
}
}
(2) long count()：返回此流中的元素数。
package com.qdu.streamdemo;
import java.util.ArrayList;
public class MyStream5 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("张三丰");
list.add("张无忌");
list.add("张翠山");
list.add("王二麻子");
list.add("张良");
list.add("谢广坤");
// long count()：返回此流中的元素数
long count = list.stream().count();
System.out.println(count);
}
}
示例：定义一个集合，并添加一些整数 1, 2, 3, 4, 5, 6, 7, 8, 9, 10，将集合中的奇数删除，只保留偶数。
package com.qdu.streamdemo;
import java.util.ArrayList;
public class MyStream6 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list.add(i);
}
list.stream().filter(number -> number % 2 == 0).forEach(number -> System.out.println(number));
System.out.println("----------------------");
for (Integer integer : list) {
System.out.println(integer);
}
}
}
结论：在 Stream 流中无法直接修改集合、数组等数据源中的数据。
4.Stream 流的收集方法使用 Stream 流操作完毕之后，怎么把流中的数据收集起来呢？
R collect(Collector collector)
工具类 Collectors 提供了具体的收集方式
- public static Collector toList()：把元素收集到 List 集合中
- public static Collector toSet()：把元素收集到 Set 集合中
- public static Collector toMap(Function keyMapper, Function valueMapper)：把元素收集到 Map 集合中
package com.qdu.streamdemo;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
public class MyStream7 {
public static void main(String[] args) {
ArrayList list1 = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
list1.add(i);
}
list1.add(10);
list1.add(10);
list1.add(10);
list1.add(10);
list1.add(10);
List list = list1.stream().filter(number -> number % 2 == 0)
.collect(Collectors.toList());
System.out.println(list); // [2, 4, 6, 8, 10, 10, 10, 10, 10, 10]
Set set = list1.stream().filter(number -> number % 2 == 0)
.collect(Collectors.toSet());
System.out.println(set); // [2, 4, 6, 8, 10]
}
}
package com.qdu.streamdemo;
import java.util.ArrayList;
import java.util.Map;
import java.util.stream.Collectors;
public class MyStream8 {
public static void main(String[] args) {
ArrayList list = new ArrayList<>();
list.add("zhangsan,23");
list.add("lisi,24");
list.add("wangwu,25");
list.stream().filter(
s -> {
String[] split = s.split(",");
int age = Integer.parseInt(split[1]);
return age >= 24;
}
).forEach(s -> System.out.println(s));
Map map = list.stream().filter(
s -> {
String[] split = s.split(",");
int age = Integer.parseInt(split[1]);
return age >= 24;
}
).collect(Collectors.toMap(
s -> s.split(",")[0],
s -> Integer.parseInt(s.split(",")[1]) ));
System.out.println(map);
}
}
示例：现在有两个 ArrayList 集合，分别存储 6 名男演员名称和 6 名女演员名称，男演员只要名字为 3 个字的前两人，女演员只要姓杨的并且不要第一个，把过滤后的男演员姓名和女演员姓名合并到一起，作为构造方法的参数创建演员对象并遍历。
package com.qdu.streamdemo;
public class Actor {
private String name;
public Actor() {
}
public Actor(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "Actor{" +
"name='" + name + ''' +
'}';
}
}
package com.qdu.streamdemo;
import java.util.ArrayList;
import java.util.stream.Stream;
public class MyStream9 {
public static void main(String[] args) {
ArrayList manList = new ArrayList<>();
manList.add("张国立");
manList.add("张晋");
manList.add("刘烨");
manList.add("郑伊健");
manList.add("徐峥");
manList.add("王宝强");
ArrayList womanList = new ArrayList<>();
womanList.add("郑爽");
womanList.add("杨紫");
womanList.add("关晓彤");
womanList.add("张天爱");
womanList.add("杨幂");
womanList.add("赵丽颖");
// 男演员只要名字为3个字的前两人
Stream stream1 = manList.stream().filter(name -> name.length() == 3).limit(2);
//女演员只要姓杨的，并且不要第一个
Stream stream2 = womanList.stream().filter(name -> name.startsWith("杨")).skip(1);
// 把过滤后的男演员姓名和女演员姓名合并到一起，作为构造方法的参数创建演员对象并遍历
Stream.concat(stream1, stream2).forEach(name -> {
Actor actor = new Actor(name);
System.out.println(actor);
});
}
}
