Stream流
Stream流
- Stream流
-
- Stream流的获取
- Stream流中间方法
- Stream流的终结方法
- Stream流练习
Stream流
- Stream流的作用 ：
结合了Lambda表达式，简化集合，数组操作 - Stream流的使用步骤
Stream流的获取
1、先得到一条Stream流（流水线），并把数据放上去
单列集合：
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.stream.Stream;
public class StreamDemo1 {
public static void main(String[] args) {
//1、单列集合获取Stream流
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"a","b","c","d","e");
// list.stream().forEach(s-> System.out.println(s));
// //获取一条流水线，并把集合中的数据放到流水线上
// Stream stream1 = list.stream();
// //使用终结方法打印一下流水线上的所有数据
// stream1.forEach(new Consumer() {
// @Override
// public void accept(String s) {
// //s:依次表示流水线上的每一个数据
// System.out.println(s);
// }
// });
}
}
双列集合：
import java.util.HashMap;
public class StreamDemo2 {
public static void main(String[] args) {
//1、创建集合
HashMap<String,Integer> hm = new HashMap<>();
//2、添加元素
hm.put("aaa",111);
hm.put("bbb",222);
hm.put("ccc",333);
hm.put("ddd",444);
//3、第一种获取Stream流的办法
hm.keySet().stream().forEach(s -> System.out.println(s));
//3、第二种获取Stream流的办法
hm.entrySet().stream().forEach(s-> System.out.println(s));
}
}
数组：
import java.util.Arrays;
public class StreamDemo3 {
public static void main(String[] args) {
//1、创建数组
int[]arr = {1,2,3,4,5,6,7,8,9,10};
//2、获取Stream流
Arrays.stream(arr).forEach(s-> System.out.println(s));
}
}
一堆零散数据
import java.util.stream.Stream;
public class StreamDemo4 {
public static void main(String[] args) {
Stream.of(1,2,3,4,5).forEach(s-> System.out.println(s));
Stream.of("a","b","c","d","e").forEach(s-> System.out.println(s));
}
}
注意：
Stream接口中的静态方法of的细节
方法的形参是一个可变参数，可以传递一堆零散的数据，也可以传递数组，但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当做一个元素，放到Stream当中。
Stream流中间方法
2、使用中间方法对流水线上的数据进行操作
注意1：中间方法，返回新的Stream流，原来的Stream流只能使用一次，建议使用链式编程
注意2：修改Stream流中的数据，不会影响原来集合或者数组中的数据
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;
public class StreamDemo5 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌","张无忌","周芷若","赵敏","张强","张三丰",
"张翠山","张良","王二麻子","谢广坤","谢广坤");
ArrayList<String> list2 = new ArrayList<>();
Collections.addAll(list2,"张三-10","李四-20","王五-30","赵六-40");
//filter过滤，把张开头的留下，其余数据过滤不要
// list.stream().filter(new Predicate() {
// @Override
// public boolean test(String s) {
// return s.startsWith("张");
// }
// }).forEach(s-> System.out.println(s));
Stream<String> stream1 = list.stream().filter(s -> s.startsWith("张"));
Stream<String> stream2 = stream1.filter(s -> s.length() == 3);
stream2.forEach(s-> System.out.println(s));
System.out.println("-------------------------");
list.stream().
filter(s->s.startsWith("张"))
.filter(s->s.length() == 3)
.forEach(s-> System.out.println(s));
System.out.println("-------------------------");
list.stream().limit(3).forEach(s-> System.out.println(s));//获取前三个
System.out.println("-------------------------");
list.stream().skip(4).forEach(s-> System.out.println(s));//跳过前四个
System.out.println("-------------------------");
list.stream().distinct().forEach(s-> System.out.println(s));//去重
System.out.println("-------------------------");
//合并a和b两个流为一个流
Stream.concat(list.stream(),list2.stream()).forEach(s-> System.out.println(s));
System.out.println("-------------------------");
//利用Map方法转化流中的数据类型
//需求：只获取里面的年龄进行打印（String->int）
//第一个类型：流中原本的数据类型
//第二个类型：要转成之后的类型
//apply的形参s：依次表示流里面的每一个数据
//返回值：表示转换之后的数据
list2.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
String[] arr = s.split("-");
String ageString = arr[1];
int age = Integer.parseInt(ageString);
return age;
}
}).forEach(s-> System.out.println(s));
System.out.println("-------------------------");
//Lambda表达式：
list2.stream()
.map(s->Integer.parseInt(s.split("-")[1]))
.forEach(s-> System.out.println(s));
System.out.println("-------------------------");
System.out.println(list);//数据不变
}
}
Stream流的终结方法
3、使用终结方法对流水线上的数据进行操作
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.Consumer;
import java.util.function.IntFunction;
public class StreamDemo6 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰",
"张翠山","张良","王二麻子","谢广坤");
//void forEach(Consumer action)
//Consumer的泛型：表示流中的数据类型
//accept方法的形参s：依次表示流里面的每一个数据
// list.stream().forEach(new Consumer() {
// @Override
// public void accept(String s) {
// System.out.println(s);
// }
// });
//Lambda表达式
list.stream().forEach(s-> System.out.println(s));//遍历
System.out.println("-------------------------");
long count = list.stream().count();//统计
System.out.println(count);//9
System.out.println("-------------------------");
// //toArray()
// Object[] arr1 = list.stream().toArray();
// System.out.println(Arrays.toString(arr1));
//IntFunction的泛型：具体类型的数组
//apply的形参：流中数据的个数，要跟数组的长度保持一致
//apply的返回值：具体类型的数组
//方法体：就是创建数组
//toArray方法的参数作用：负责创建一个指定类型的数组
//toArray方法的底层，会依次得到流里面的每一个数据，并把数据放到数组当中
//toArray方法的返回值：是一个装着流里面所有的数据的数组
/*String[] arr = list.stream().toArray(new IntFunction() {
@Override
public String[] apply(int value) {
return new String[value];
}
});
System.out.println(Arrays.toString(arr));*/
String[] arr2 = list.stream().toArray(value -> new String[value]);
System.out.println(Arrays.toString(arr2));
}
}
collect收集方法：
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
public class StreamDemo7 {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list,"张无忌-男-15","周芷若-女-14",
"赵敏-女-13","张强-男-20","张三丰-男-100","张翠山-男-40","张良-男-35",
"王二麻子-男-37","谢广坤-男-41");
//收集List集合当中
//需求：把所有的男性收集起来
List<String> newList1 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toList());
System.out.println(newList1);
System.out.println("---------------");
//收集Set集合当中
//需求：把所有的男性收集起来
Set<String> newList2 = list.stream()
.filter(s->"男".equals(s.split("-")[1]))
.collect(Collectors.toSet());
System.out.println(newList2);
System.out.println("---------------");
//收集Map集合当中
//注意：如果我们要收集到Map集合当中，键不能重复，否则会报错
//需求：把所有的男性收集起来。键：姓名。值：年龄
Map<String, Integer> map = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
/*
toMap:参数1表示键的生成规则
参数2表示值的生成规则
参数1：
Function泛型一：表示流中的每一个数据的类型
泛型而：表示Map集合中键的数据类型
方法apply形参：依次表示流里面的每一个数据
方法体：生成键的代码
返回值：已经生成的键
参数2：
Function泛型一：表示流中的每一个数据的类型
泛型而：表示Map集合中值的数据类型
方法apply形参：依次表示流里面的每一个数据
方法体：生成值的代码
返回值：已经生成的值
*/
.collect(Collectors.toMap(new Function<String, String>() {
@Override
public String apply(String s) {
//"张无忌-男-15"
return s.split("-")[0];
}
},
new Function<String, Integer>() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s.split("-")[2]);
}
}));
System.out.println(map);
//Lambda表达式
Map<String, Integer> map2 = list.stream()
.filter(s -> "男".equals(s.split("-")[1]))
.collect(Collectors.toMap(
s -> s.split("-")[0],
s -> Integer.parseInt(s.split("-")[2])));
System.out.println("---------------");
System.out.println(map2);
}
}
Stream流练习
1、定义一个集合并添加一些整数：1，2，3，4，5，6，7，8，9，10
过滤奇数，只留下偶数
并将结果保存起来
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class Test1 {
public static void main(String[] args) {
//1、创建集合
ArrayList<Integer> list = new ArrayList<>();
//2、添加数据
Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
//3、过滤奇数，只留下偶数
List<Integer> list2 = list.stream()
.filter(s -> s % 2 == 0)
.collect(Collectors.toList());
//4、打印集合
System.out.println(list2);
}
}
2、创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄
“zhangsan,23”
“lisi,24”;
“wangwu,25”
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
import java.beans.Introspector;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
public class Test2 {
public static void main(String[] args) {
//1、创建集合
ArrayList<String> list = new ArrayList<>();
//2、添加数据
Collections.addAll(list,"zhangsan,23","lisi,24", "wangwu,25");
//3、过滤年龄大于24岁的人并收集
// list.stream().filter(s->Integer
// .parseInt(s.split(",")[1]) >= 24)
// .collect(Collectors.toMap(new Function() {
// @Override
// public String apply(String s) {
// return s.split(",")[0];
// }
// }, new Function() {
// @Override
// public Integer apply(String s) {
// return Integer.parseInt(s.split(",")[1]);
// }
// }));
//Lambda表达式
Map<String, Integer> map = list.stream()
.filter(s -> Integer.parseInt(s.split(",")[1]) >= 24)
.collect(Collectors.toMap(
s -> s.split(",")[0],
s -> Integer.parseInt(s.split(",")[1])));
System.out.println(map);
}
}
现在有两个ArrayList集合，分别存储6名男演员的名字和年龄以及6名女演员的名字和年龄。姓名和年龄中间用逗号隔开。比如:张三,23
要求完成如下的操作:
1，男演员只要名字为3个字的前两人
2，女演员只要姓杨的，并且不要第一个
3，把过滤后的男演员姓名和女演员姓名合并到一起
4，将上一步的演员姓名封装成Actor对象。
5，将所有的演员对象都保存到List集合中。
备注:演员类Actor，属性有:name，age
男演员：“蔡坤坤,24”，“叶駒咸 ,23”，“刘不甜,22”，“吴签， 24”,“谷嘉,30”，“肖梁梁，27”
女演员：“赵小颖,35”，“杨颖,36”，“高元元,43”，“张天天,31”,“刘诗,35”， “杨小幂,33”
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
public class Test3 {
public static void main(String[] args) {
//1、创建集合
ArrayList<String> manList = new ArrayList<>();
ArrayList<String> womanList = new ArrayList<>();
//2、添加数据
Collections.addAll(manList,"蔡坤坤,24","叶駒咸,23",
"刘不甜,22","吴签,24","谷嘉,30","肖梁梁,27");
Collections.addAll(womanList,"赵小颖,35","杨颖,36",
"高元元,43","张天天,31","刘诗,35","杨小幂,33");
//3、男演员只要名字为3个字的前两人
Stream<String> stream1 = manList.stream().
filter(s -> s.split(",")[0].length() == 3)
.limit(2);
//4、女演员只要姓杨的，并且不要第一个
Stream<String> stream2 = womanList.stream()
.filter(s -> s.split(",")[0].startsWith("杨"))
.skip(1);
//5、把过滤后的男演员姓名和女演员姓名合并到一起
// Stream.concat(stream1,stream2).map(new Function() {
// @Override
// public Actor apply(String s) {
// String name = s.split(",")[0];
// int age = Integer.parseInt(s.split(",")[1]);
// return new Actor(name,age);
// }
// }).forEach(s-> System.out.println(s));
//Lambda表达式
List<Actor> list = Stream.concat(stream1, stream2).
map(s -> new Actor(s.split(",")[0], Integer.parseInt(s.split(",")[1])))
.collect(Collectors.toList());
System.out.println(list);
}
}