Java--stream流、方法引用
Stream流
- Stream流的好处
- 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义
- Stream流把真正的函数式编程风格引入到Java中
- 代码简洁
- Stream流的三类方法
- 获取Stream流
- 创建一条流水线,并把数据放到流水线上准备进行操作
- 中间方法
- 流水线上的操作
- 一次操作完毕之后,还可以继续进行其他操作
- 终结方法
- 一个Stream流只能有一个终结方法
- 是流水线上的最后一个操作
- 生成Stream流的方式
- Collection体系集合
使用默认方法stream()生成流， default Stream<E> stream()
- Map体系集合
把Map转成Set集合，间接的生成流
- 数组
通过Arrays中的静态方法stream生成流
- 同种数据类型的多个数据
通过Stream接口的静态方法of(T... values)生成流
package yyeye;import java.awt.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.stream.Stream;public class test1 {public static void main(String[] args) {//Collection体系的集合可以使用默认方法stream（）生成流ArrayList<String> list = new ArrayList<>();Collections.addAll(list, "a", "b", "c", "d", "e");list.stream().forEach(s -> System.out.println(s));System.out.println("--------------------------");//Map体系的集合间接的生成流HashMap<String, Integer> hm = new HashMap<>();hm.put("a", 1);hm.put("b", 2);hm.put("c", 3);hm.put("d", 4);hm.put("e", 5);hm.keySet().stream().forEach(System.out::print);System.out.println();hm.values().stream().forEach(System.out::print);System.out.println();hm.entrySet().stream().forEach(System.out::println);System.out.println("--------------------------");//数组可以通过Arrays中的静态方法stream生成流int[] arr = {1, 2, 3, 4, 5};String []arr2= {"a","b","c"};Arrays.stream(arr).forEach(System.out::println);System.out.println();Arrays.stream(arr2).forEach(System.out::println);System.out.println("--------------------------");//同种数据类型的多个数据可以通过Stream接口的静态方法of(T... values)生成流Stream.of(1, 2, 3, 4, 5).forEach(System.out::println);Stream.of("a", "b", "c").forEach(System.out::println);//数组也可以直接用第四种方法//有使用前提//Stream接口中静态方法of的细节//参数是一个可变参数，可以传递多个参数，也可以传递数组//但是数组必须是引用数据类型的，如果传递基本数据类型，是会把整个数组当作一个元素，放到stream当中Stream.of(arr).forEach(System.out::println);Stream.of(arr2).forEach(System.out::println);}
}
Stream流中间操作方法
- 概念
中间操作的意思是,执行完此方法之后,Stream流依然可以继续执行其他操作
filter代码演示
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布", "貂蝉", "诸葛亮", "赵云", "关羽", "张飞","曹操","曹丕","曹植");list.stream().filter(s -> s.startsWith("曹")).forEach(System.out::println);}
}limit&skip代码演示
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布", "貂蝉", "诸葛亮", "赵云", "关羽", "张飞","曹操","曹丕","曹植");//需求1：取前3个数据在控制台输出list.stream().limit(3).forEach(s-> System.out.println(s));System.out.println("--------");//需求2：从第3个开始取，取到第6个在控制台输出list.stream().skip(2).limit(4).forEach(s-> System.out.println(s));System.out.println("--------");//需求3：将集合中的元素倒序输出list.stream().sorted(Collections.reverseOrder()).forEach(s-> System.out.println(s));}
}concat&distinct代码演示
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布", "貂蝉", "诸葛亮", "赵云", "关羽", "张飞","曹操","曹丕","曹植");//需求1：取前4个数据组成一个流Stream<String> s1 = list.stream().limit(4);//需求2：跳过2个数据组成一个流Stream<String> s2 = list.stream().skip(2);//需求3：合并需求1和需求2得到的流，并把结果在控制台输出// Stream.concat(s1,s2).forEach(s-> System.out.println(s));//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复Stream.concat(s1,s2).distinct().forEach(s-> System.out.println(s));}
}map代码演示
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布-15","貂蝉-12", "关羽-18", "张飞-20", "赵云-16", "诸葛亮-14", "曹操-17", "孙权-19", "周瑜-13", "黄盖-11");//需求：只获取里面的年龄并打印list.stream().map(s->s.split("-")[1]).forEach(System.out::println);}
}
map的底层原理
//Function中第一个参数表示流对象的数据类型，第二个参数表示要强制转换的数据类型//apply的形参s：依次表示流里面的每一个数据//返回值：表示转换之后的数据 // Stream.concat(boy, girl).map(new Function<String, Actor>() { // @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));Stream.concat(boy,girl).map(s -> new Actor(s.split(",")[0],Integer.parseInt(s.split(",")[1]))).collect(Collectors.toList()).forEach(s-> System.out.println(s));
Stream流终结操作方法
- 概念
终结操作的意思是,执行完此方法之后,Stream流将不能再执行其他操作
forEach&count代码演示
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布", "貂蝉", "诸葛亮", "赵云", "关羽", "张飞", "曹操", "孙权", "周瑜", "黄盖");//method1(list);// long count()：返回此流中的元素数long count = list.stream().count();System.out.println(count);}private static void method1(ArrayList<String> list) {// void forEach(Consumer action)：对此流的每个元素执行操作// Consumer接口中的方法void accept(T t)：对给定的参数执行此操作//在forEach方法的底层,会循环获取到流中的每一个数据.//并循环调用accept方法,并把每一个数据传递给accept方法//s就依次表示了流中的每一个数据.//所以,我们只要在accept方法中,写上处理的业务逻辑就可以了.list.stream().forEach(new Consumer<String>() {@Overridepublic void accept(String s) {System.out.println(s);}});System.out.println("====================");//lambda表达式的简化格式//是因为Consumer接口中,只有一个accept方法list.stream().forEach((String s)->{System.out.println(s);});System.out.println("====================");//lambda表达式还是可以进一步简化的.list.stream().forEach(s->System.out.println(s));}
}
toArray代码演示
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list, "吕布", "貂蝉", "诸葛亮", "赵云", "关羽", "张飞", "曹操", "孙权", "周瑜", "黄盖");// toArray()//Object[] objects = list.stream().toArray();//System.out.println(Arrays.toString(objects));//IntFunction的泛型，具体类型的数组//apply的形参：流中数据的个数，要跟数组的长度保持一致//apply的返回值：具体类型的数组//方法体：就是创建数组//toArray方法的参数的作用：负责创建一个指定类型的数组//toArray方法的底层，会以此得到流里面的每一个数据，并把数据放到数组中//toArray方法的返回值：是一个装着流里面所有数据的数组
// String[] arr = list.stream().toArray(new IntFunction<String[]>() {
// @Override
// public String[] apply(int value) {
// return new String[value];
// }
// });
//
// System.out.println(Arrays.toString(arr));//lambda表达式简化String[] arr = list.stream().toArray(value -> new String[value]);System.out.println(Arrays.toString(arr));}}Stream流的收集操作代码演示
// toList和toSet方法演示 public class MyStream7 {public static void main(String[] args) {ArrayList<Integer> 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);//filter负责过滤数据的.//collect负责收集数据.//获取流中剩余的数据,但是他不负责创建容器,也不负责把数据添加到容器中.//Collectors.toList() : 在底层会创建一个List集合.并把所有的数据添加到List集合中.List<Integer> list = list1.stream().filter(number -> number % 2 == 0).collect(Collectors.toList());System.out.println(list);Set<Integer> set = list1.stream().filter(number -> number % 2 == 0).collect(Collectors.toSet());System.out.println(set);}}/**Stream流的收集方法 toMap方法演示创建一个ArrayList集合，并添加以下字符串。字符串中前面是姓名，后面是年龄"zhangsan,23""lisi,24""wangwu,25"保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值*/public class MyStream8 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();list.add("zhangsan,23");list.add("lisi,24");list.add("wangwu,25");Map<String, Integer> map = list.stream().filter(s -> {String[] split = s.split(",");int age = Integer.parseInt(split[1]);return age >= 24;}// collect方法只能获取到流中剩余的每一个数据.//在底层不能创建容器,也不能把数据添加到容器当中//Collectors.toMap 创建一个map集合并将数据添加到集合当中// s 依次表示流中的每一个数据//第一个lambda表达式就是如何获取到Map中的键//第二个lambda表达式就是如何获取Map中的值).collect(Collectors.toMap(s -> s.split(",")[0],s -> Integer.parseInt(s.split(",")[1]) ));System.out.println(map);}}Stream流综合练习
练习1
- 案例需求
现在有两个ArrayList集合，分别存储6名男演员名称和6名女演员名称，要求完成如下的操作
- 男演员只要名字为3个字的前三人
- 女演员只要姓林的，并且不要第一个
- 把过滤后的男演员姓名和女演员姓名合并到一起
- 把上一步操作后的元素作为构造方法的参数创建演员对象,遍历数据
演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法
演员类
public class Actor {private String name;public Actor(String name) {this.name = name;}public String getName() {return name;}public void setName(String name) {this.name = name;}
}测试类
public static void main(String[] args) {ArrayList<String> Boylist = new ArrayList<>();ArrayList<String> Girllist = new ArrayList<>();Collections.addAll(Boylist, "鲁智深","关羽","诸葛亮","郭襄","黄药师", "洪七公");Collections.addAll(Girllist, "小龙女", "黄蓉", "郭芙", "黄月英", "林黛玉","林志玲");Stream<String> a=Boylist.stream().filter(s -> s.length() == 3).limit(3);Stream<String> b = Girllist.stream().filter(s->s.startsWith("林")).skip(1);Stream<String> concat = Stream.concat(a, b);concat.forEach(name ->{Actor actor =new Actor(name);System.out.println(actor.getName());});}练习2
数据过滤
定义一个集合，并添加一些整数1，2，3，4，5，6，7，8，9，10
过滤奇数，只留下偶数
并将结果保存起来
public static void main(String[] args) {ArrayList <Integer> list = new ArrayList<>();Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);List<Integer> integers = list.stream().filter(i -> i % 2 == 0).collect(Collectors.toList());integers.forEach(System.out::println);}练习3
数据操作
创建一个ArrayList集合，并添加以下字符串，字符串中前面是姓名，后面是年龄
“zhangsan，23”
“lisi，24”
“wangwu，25”
保留年龄大于等于24岁的人，并将结果收集到Map集合中，姓名为键，年龄为值
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"zhangsan,23","lisi,24","wangwu,25");
// Map<String,Integer> collect = list.stream()
// .filter((s -> Integer.parseInt(s.split(",")[1]) >= 24))
// .collect(Collectors.toMap(new Function<String, String>() {
// @Override
// public String apply(String s) {
// return s.split(",")[0];
// }
// }, new Function<String, Integer>() {
// @Override
// public Integer apply(String s) {
// return Integer.parseInt(s.split(",")[1]);
// }
// }));Map<String, Integer> collect = 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(collect);}}练习4
数据操作
现在有两个ArrayList集合，
第一个集合中：存储6个男演员的名字和年龄。第二个集合中：存储6名女演员的名字和年龄。
姓名和年龄中间用逗号隔开。比如：张三，23
要求完成如下的操作：
1、男演员只要名字为3个字的前两人
2、女演员只要姓杨的，并且不要第一个
3、把过滤后的男演员姓名和女演员姓名合并在一起
4、将上一步的演员信息封装成Actor对象
5、将所有的演员对象都保存到List集合中
备注：演员类：Actor，属性有：name,age
public class test1 {public static void main(String[] args) {ArrayList<String> Boylist = new ArrayList<>();ArrayList<String> Girllist = new ArrayList<>();Collections.addAll(Boylist,"蔡徐坤,24","易烊千玺,24","王源,23","王俊凯,22","朱正廷,22","刘昊然,23");Collections.addAll(Girllist,"迪丽热巴,24","杨幂,24","赵丽颖,23","杨超越,22","周冬雨,22","刘诗诗,23");Stream<String> boy = Boylist.stream().filter(s -> s.split(",")[0].length()==3).limit(2);Stream<String> girl = Girllist.stream().filter(s->s.startsWith("杨")).skip(1);//第一个参数表示流对象的数据类型，第二个参数表示要强制转换的数据类型
// Stream.concat(boy, girl).map(new Function<String, Actor>() {
// @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));Stream.concat(boy,girl).map(s -> new Actor(s.split(",")[0],Integer.parseInt(s.split(",")[1]))).collect(Collectors.toList()).forEach(s-> System.out.println(s));}}方法引用
方法引用的出现原因
在使用Lambda表达式的时候，我们实际上传递进去的代码就是一种解决方案：拿参数做操作
那么考虑一种情况：如果我们在Lambda中所指定的操作方案，已经有地方存在相同方案，那是否还有必要再写重复逻辑呢？答案肯定是没有必要
那我们又是如何使用已经存在的方案的呢？
这就是我们要讲解的方法引用，我们是通过方法引用来使用已经存在的方案
方法引用符
:: 该符号为引用运算符，而它所在的表达式被称为方法引用
推导与省略
如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
如果使用方法引用，也是同样可以根据上下文进行推导
方法引用是Lambda的孪生兄弟
方法引用的注意点
需要有函数式接口
被引用方法必须已经存在
被引用方法的形参和返回值需要跟抽象方法保持一致
被引用方法的功能需要满足当前的需求
代码演示：
public interface Printable {void printString(String s);}public class PrintableDemo {public static void main(String[] args) {//在主方法中调用usePrintable方法// usePrintable((String s) -> {// System.out.println(s);// });//Lambda简化写法usePrintable(s -> System.out.println(s));//方法引用usePrintable(System.out::println);}private static void usePrintable(Printable p) {p.printString("爱生活爱Java");}}方法引用的分类
引用静态方法
格式：类名::静态方法
范例：Integer::parseInt
练习：
集合中有以下数字，要求把他们都变成int类型
"1" "2" "3" "4" "5"
代码演示：
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"1","2","3","4","5");//匿名内部类list.stream().map(new Function<String, Integer>() {@Overridepublic Integer apply(String s) {return Integer.parseInt(s);}}).forEach(System.out::println);//方法引用list.stream().map(Integer::parseInt).forEach(System.out::println);}}引用成员方法
格式：对象::成员方法
其他类：其他类对象::方法名
本类：this::方法名
父类：super::方法名
引用其他类的成员方法
练习1：
集合中有一些名字，按照要求过滤数据
代码演示：
定义类
public class StringOperation {public boolean stringJudge(String s){return s.startsWith("曹")&&s.length()==2;}
}测试类
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布","貂蝉","诸葛亮","赵云","关羽","张飞","曹操","曹丕","曹爽","曹植");//使用lambda表达式list.stream().filter(s -> s.startsWith("曹") && s.length() == 2).forEach(System.out::println);//匿名内部类list.stream().filter(new Predicate<String>() {@Overridepublic boolean test(String s) {return s.startsWith("曹") && s.length() == 2;}}).forEach(System.out::println);//方法引用list.stream().filter(new StringOperation()::stringJudge).forEach(System.out::println);}}引用构造方法
格式：类名::new
范例：Student::new
练习：
集合里面存储姓名和年龄，比如：张无忌，15
要求：将数据封装成Student对象并收集到List集合中
代码演示：
定义类
public class Student {private String name;private int age;public Student() {}public Student(String str) {String[] arr=str.split(",");this.name=arr[0];this.age=Integer.parseInt(arr[1]);}public Student(String name, int age) {this.name = name;this.age = age;}public String toString() {return "Student{name = " + name + ", age = " + age + "}";}
}
测试类
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布,24","貂蝉,22","诸葛亮,23","赵云,25","关羽,24","张飞,23");//匿名内部类list.stream().map(new Function<String, Student>() {@Overridepublic Student apply(String s) {return new Student(s.split(",")[0],Integer.parseInt(s.split(",")[1]));}}).collect(Collectors.toList()).forEach(System.out::println);//lambda表达式list.stream().map(s->new Student(s.split(",")[0],Integer.parseInt(s.split(",")[1]))).collect(Collectors.toList()).forEach(System.out::println);//方法引用list.stream().map(Student::new).collect(Collectors.toList()).forEach(System.out::println);}}使用类名引用成员方法
格式：类名::成员方法
范例：String::substring
练习：
集合里面一些字符串。要求变成大写后进行输出
独有的规则：
1.需要有函数式接口
2.被引用的方法必须已经存在
3.被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致
4.被引用方法的功能需要满足当前的需求
抽象方法形参的详解：
第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
在Stream流当中，第一个参数一般都表示流里面的每一个数据
假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法
第二个参数到最后一个参数：
跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法
public class test1 {public static void main(String[] args) {ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"aaa","bbb","ccc");//匿名内部类list.stream().map(new Function<String, String>() {@Overridepublic String apply(String s) {return s.toUpperCase();}}).forEach(System.out::println);//方法引用list.stream().map(String::toUpperCase).forEach(System.out::println);}}引用数组的构造方法
格式：数据类型[]::new
范例：int[]::new
练习
集合中存储一些整数，收集到数组当中
细节：
数组的类型，需要跟流中数据的类型保持一致
public class test1 {public static void main(String[] args) {ArrayList<Integer> list = new ArrayList<>();Collections.addAll(list,1,2,3,4,5);//匿名内部类Integer[] integer=list.stream().toArray(new IntFunction<Integer[]>() {@Overridepublic Integer[] apply(int value) {return new Integer[value];}});System.out.println(Arrays.toString(integer));//方法引用Integer[] integers = list.stream().toArray(Integer[]::new);System.out.println(Arrays.toString(integers));}}方法引用综合小练习
转成自定义对象并收集到数组
练习1
集合中存储一些字符串的数据，比如：张三,23
收集到Student类型的数组中（使用方法引用完成）
练习2
创建集合添加学生对象，学生对象属性：name，age
只获取姓名并放到数组当中（使用方法引用完成）
练习3
创建集合添加学生对象，学生对象属性：name，age
把姓名和年龄拼接成：张三-23的字符串，并放到数组当中（使用方法引用完成）
练习1ArrayList<String> list = new ArrayList<>();Collections.addAll(list,"吕布,23","貂蝉,22","关羽,24","张飞,23");//先把字符串变成student对象，再把Student对象收集起来Student[] students = list.stream().map(Student::new).toArray(Student[]::new);System.out.println(Arrays.toString(students));练习2
ArrayList<Student> list = new ArrayList<>();Collections.addAll(list,new Student("吕布",23),new Student("貂蝉",22),new Student("关羽",24));//技巧//1、现在有没有一个方法符合我当前的需求//2、如果有的话，这个方法是否满足引用的规则//静态 类名：：方法名//成员方法 对象名：：方法名//构造方法 类名：：new//3、如果满足引用的规则，那么就可以直接使用String[] strings = list.stream().map(Student::getName).toArray(String[]::new);System.out.println(Arrays.toString(strings));练习3
测试类ArrayList<Student> list = new ArrayList<>();Collections.addAll(list,new Student("吕布",23),new Student("貂蝉",22),new Student("关羽",24));String[] strings = list.stream().map(Student::subcat).toArray(String[]::new);System.out.println(Arrays.toString(strings));
定义类public class Student {private String name;private int age;public Student() {}public Student(String str) {String[] arr=str.split(",");this.name=arr[0];this.age=Integer.parseInt(arr[1]);}public String subcat(){return this.name+"-"+this.age;}public Student(String name, int age) {this.name = name;this.age = age;}public String toString() {return "Student{name = " + name + ", age = " + age + "}";}
}