一、Lambda表达式
1.1 函数式编程思想概述
在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
面向对象思想强调“必须通过对象的形式来做事情”
函数式思想强调则金量忽略面向对象的复杂语句：“强调做什么，而不是以什么形式去做”
而我们要学习的Lambda表达式就是函数式思想的体现
1.2 体验Lambda表达式
需求：启动一个线程，在控制台输出一句话：多线程程序启动了
方式1：
- 定义一个类MyRunnable接口，重写run方法
- 创建MyRunnable类的对象
- 创建Thread类对象，把MyRunnable的对象作为构造参数传递
- 启动线程
public class MyRunnable implements Runnable {
@Override
public void run() {
System.out.println("多线程程序启动了");
}
} MyRunnable myRunnable = new MyRunnable();
Thread thread = new Thread(myRunnable);
thread.start();方式2：
在方式1的基础上进行改进，使用匿名内部类的方式
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程程序启动了");
}
}).start();方式3：
Lambda表达式的方式改进：
new Thread(() -> {
System.out.println("多线程程序启动了");
}).start();1.3 Lambda表达式的标准格式
匿名内部类中重写run()方法的代码分析：
- 方法形式参数为空，说明调用方法时不需要传递参数
- 方法返回值类型为void，说明方法执行没有结果返回
- 方法体中的内容，是我们具体要做的事情
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("多线程程序启动了");
}
}).start();Lambda表达式的代码分析：
- ()：里面没有内容，可以看成是方法形式参数为空
- ->：用箭头指向后面要做的事情
- {}：包含一段代码，我们称之为代码块，可以看成是方法体中的内容
new Thread(() -> {
System.out.println("多线程程序启动了");
}).start();组成Lambda表达式的三要素：形式参数、箭头、代码块
Lambda表达式的格式：
- 格式：（形式参数）->{代码块}
- 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
- ->：由英文中画线和大于符号组成，固定写法。代表指向动作
- 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容
1.4 Lambda表达式的练习
Lambda表达式的使用前提
- 有一个接口
- 接口中有且仅有一个抽象方法
练习1：
- 定义一个接口(Eatable)，里面定义一个抽象方法：void eat();
- 定义一个测试类（EatableDemo）,在测试类中提供两个方法：
- 一个方法是：useEatable(Eatable e)
- 一个方法是主方法，在主方法中调用useEatable方法
定义一个接口：
public interface Eatable {
void eat();
}方式一：传统接口实现类
public class EatableImpl implements Eatable{
@Override
public void eat() {
System.out.println("一日三餐，必不可少");
}
}public class EatableDemo{
public static void main(String[] args) {
Eatable eatable = new EatableImpl();
eatable.eat();
}
private static void useEatable(Eatable eatable){
eatable.eat();
}
}方式2：匿名内部类
public class EatableDemo{
public static void main(String[] args) {
useEatable(new Eatable() {
@Override
public void eat() {
System.out.println("一日三餐，必不可少");
}
});
}
private static void useEatable(Eatable eatable){
eatable.eat();
}
}方式3：Lambda表达式
public class EatableDemo{
public static void main(String[] args) {
useEatable(()->{
System.out.println("一日三餐，必不可少");
});
}
private static void useEatable(Eatable eatable){
eatable.eat();
}
}运行结果均相同
练习2：
- 定义一个接口（Flyable），里面定义一个抽象方法：void fiy(String s)；
- 定义一个测试类（FlyableDemo）,在测试类中提供两个方法
- 一个方法是：useFlyable(Flyable f)
- 一个方法是主方法，在主方法中调用useFlayable方法
public interface Flyable {
void fly(String s);
}public class FlyableDemo {
public static void main(String[] args) {
useFlyable(new Flyable() {
@Override
public void fly(String s) {
System.out.println(s);
System.out.println("飞机可以起飞");
}
});
System.out.println("--------------------");
useFlyable((String s)->{
System.out.println(s);
System.out.println("飞机可以起飞");
});
}
private static void useFlyable(Flyable flyable){
flyable.fly("风和日丽，晴空万里");
}
}练习3：
- 定义一个接口（Addable），里面定义一个抽象方法：int add(int x,int y);
- 定义一个测试类（AddableDemo）,在测试类中提供两个方法
- 一个方法是：useAddable(Addable a)
- 一个方法是主方法，在主方法中调用useAddable方法
public interface Addable {
int add(int x,int y);
}public class AddableDemo {
public static void main(String[] args) {
useAddable(new Addable() {
@Override
public int add(int x, int y) {
return x + y;
}
});
useAddable((int x,int y)->{
return x + y;
});
}
private static void useAddable(Addable addable) {
int sum = addable.add(10, 20);
System.out.println(sum);
}
}1.5 Lambda表达式的省略模式
省略规则：
- 参数类型可以省略。如果有多个参数的情况下，不能只省略一个
- 如果参数有且仅有一个，那么小括号可以省略
- 如果代码块的语句只有一条，可以省略大括号和分号，甚至时return
public class LambdaDemo5 {
public static void main(String[] args) {
//参数类型可以省略
useAddable((x, y) -> {
return x + y;
});
System.out.println("------------------------");
//如果只有一个参数，小括号也可以省略
useFlyable(s -> {
System.out.println(s);
});
System.out.println("------------------------");
//如果代码块的语句只有一条，可以省略大括号和分号(有return时要把return也去掉)
useFlyable(s ->
System.out.println(s)
);
useAddable((x,y)->x+y);
}
private static void useFlyable(Flyable flyable) {
flyable.fly("风和日丽，晴空万里");
}
private static void useAddable(Addable addable) {
int sum = addable.add(10, 20);
System.out.println(sum);
}
}接口类参考1.4
1.6 Lambda表达式的注意事项
注意事项：
- 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象的方法
- 必须有上下文环境，才能推导出Lambda对应的接口
- 根据局部变量的赋值得知Lambda对应的接口：Runnable r =() ->System.out.println(“Lambda表达式”);
- 根据调用方法的参数得知Lambda对应的接口：new Thread(()->System.out.println(“Lambda表达式”)).start();
public interface Inter {
void show();
}public class LambdaDemo6 {
public static void main(String[] args) {
useInter(()->
System.out.println("Lambda表达式")
);
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("匿名内部类");
}
}).start();
Runnable r = () -> System.out.println("Lambda表达式");
new Thread(r).start();
new Thread(()->
System.out.println("Lambda表达式")
).start();
}
private static void useInter(Inter inter){
inter.show();
}
}1.7 Lambda表达式和匿名内部类的区别
所需类型不同：
- 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
- Lambda表达式：只能是接口
使用限制不同：
- 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
- 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
实现原理不同：
- 匿名内部类：编译之后，产生一个单独的.class字节码文件
- Lambda表达式：编译之后，没有一个单独的.class字节码文件，对应的字节码会在运行的时候动态生成
二、接口组成更新
1.1 接口组成更新概述
接口的组成:
- 常量：public static final
- 抽象方法：public abstract
- 默认方法（Java 8）
- 静态方法（Java 8）
- 私有方法 （Java 8）
1.2 接口中默认方法
接口中默认方法得定义格式：
- 格式：public default 返回值类型 方法名（参数列表）{}
- 范例：public default void show3(){}
接口中默认方法的注意事项：
- 默认方法不是抽象方法，所以不强制被重写。但是可以被重写，重写的时候去掉default关键字
- public可以省略，default不能重写
public interface MyInterface {
void show1();
void show2();
default void show3(){
System.out.println("show3");
}
}public class MyInterfaceImplOne implements MyInterface{
@Override
public void show1() {
System.out.println("One show1");
}
@Override
public void show2() {
System.out.println("One show2");
}
}public class MyInterfaceImplTwo implements MyInterface{
@Override
public void show1() {
System.out.println("Two show1");
}
@Override
public void show2() {
System.out.println("Two show2");
}
}public class InterfaceDemo {
public static void main(String[] args) {
MyInterface myInterface = new MyInterfaceImplOne();
myInterface.show1();
myInterface.show2();
myInterface.show3();
System.out.println("------------------");
MyInterface myInterface2 = new MyInterfaceImplTwo();
myInterface2.show1();
myInterface2.show2();
myInterface2.show3();
}
}运行结果：
One show1
One show2
show3
------------------
Two show1
Two show2
show3
1.3 接口中静态方法
接口中静态方法的定义格式：
- 格式：public static 返回值类型 方法名（参数列表）{ }
- 范例：public static void show(){ }
接口中静态方法的注意事项：
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略，static不能省略
public interface Inter {
void show();
default void method() {
System.out.println("Inter 中的默认方法执行了");
}
public static void test(){
System.out.println("Inter 中的静态方法执行了");
}
}public class InterImpl implements Inter{
@Override
public void show() {
System.out.println("show方法执行了");
}
}public class InterDemo {
public static void main(String[] args) {
Inter inter = new InterImpl();
inter.show();
inter.method();
Inter.test();
}
} 1.4 接口中私有方法
Java 9中新增了带方法体的私有方法，这其实在Java 8中就埋下了伏笔：Java 8允许在接口中定义带方法体的默认方法和静态方法。这样可能就会引发一个问题：当两个默认方法或者静态方法中包含一段相同的代码实现时，程序必然考虑将这段实现代码抽取成一个共性方法，而这个共性方法时不需要让别人使用的，因此用私有给隐藏起来，这就是Java 9增加私有方法的必然性。
接口中私有方法的定义格式：
- 格式1：private 返回值类型方法名（参数列表）{ }
- 范例1：private void show(){ }
- 格式2：private static 返回值类型 方法名(参数列表){ }
- 范例2：private static void method(){ }
接口中私有方法的注意事项：
- 默认方法可以调用私有的静态方法和非静态方法
- 静态方法只能调用私有的静态方法
public interface Inter {
default void show1(){
System.out.println("show1开始执行");
method();
System.out.println("show1结束执行");
}
default void show2(){
System.out.println("show2开始执行");
method();
System.out.println("show2结束执行");
}
static void method1(){
System.out.println("method1开始执行");
method();
System.out.println("method1结束执行");
}
static void method2(){
System.out.println("method2开始执行");
method();
System.out.println("method2结束执行");
}
static void method(){
System.out.println("初级工程师");
System.out.println("中级工程师");
System.out.println("高级工程师");
}
}public class InterImpl implements Inter{
}public class InterDemo {
public static void main(String[] args) {
Inter inter = new InterImpl();
inter.show1();
System.out.println("------------------------");
inter.show2();
System.out.println("------------------------");
Inter.method1();
System.out.println("------------------------");
Inter.method2();
}
}三、方法引用
1.1 体验方法引用
通过方法引用来使用已经存在的方案
public interface Printable {
void printString(String s);
}public class PrintableDemo {
public static void main(String[] args) {
usePrintable(s->
System.out.println(s)
);
usePrintable(System.out::println);
}
private static void usePrintable(Printable p){
p.printString("hello world");
}
}1.2 方法引用符
- ：：该符号为引用运算符，而它所在表达式被称为方法引用符
- Lambda表达式：usePrintable(s->System.out.println(s));
分析：拿到参数s之后通过Lambda表达式，传递给System.out.println方法去处理
- 方法引用：usePrintable(System.out::println);
分析：直接使用System.out中的println方法来取代Lambda，代码更加的简洁
推导与省略：
- 如果使用Lambda，那么根据“可推导就是可省略”的原则，无需指定参数类型，也无需指定的重载形式，它们都将被自动推导
- 如果使用方法引用，也同要可以根据上下文进行推导
- 方法引用是Lambda的孪生兄弟
public interface Printable {
void printInt(int i);
}public class PrintableDemo2 {
public static void main(String[] args) {
usePrintable(i -> System.out.println(i));
usePrintable(System.out::println);
}
private static void usePrintable(Printable printable){
printable.printInt(1);
}
}1.3 Lambda表达式支持的方法引用
常见的引用方式：
- 引用类方法
- 引用对象的实例方法
- 引用类的实例方法
- 引用构造器
1.4 引用类方法
引用类方法，其实就是引用类的静态方法
- 格式：类名：：静态方法
- 范例：Integer::parseInt
- Integer类的方法：public static int parsenInt(String s),将此String转换为int类型数据
- Lambda表达式被类方法替代的时候，它的形式参数全部传递给静态方法作为参数
public interface Converter {
int convert(String s);
}public class ConverterDemo {
public static void main(String[] args) {
useConverter(s -> Integer.parseInt(s));
useConverter(Integer::parseInt);
}
private static void useConverter(Converter c) {
int number = c.convert("666");
System.out.println(number);
}
}1.5 引用对象的实例方法
引用对象的实例方法，其实就是引用类中的成员方法
- 格式：对象：：成员方法
- 范例：“HelloWorld"::toUpperCase
- String 类中的方法：public String toUpperCase()将此String所有字符转为大写
- Lambda表达式被对象的实例方法替代的时候，它的形式参数全部传递给该方法作为参数
public interface Printer {
void printUpperCase(String s);
}public class PrintString {
public void printUpper(String s){
String result = s.toUpperCase();
System.out.println(result);
}
}public class PrinterDemo {
public static void main(String[] args) {
usePrinter(s -> System.out.println(s.toUpperCase()));
PrintString printString = new PrintString();
usePrinter(printString::printUpper);
}
private static void usePrinter(Printer printer) {
printer.printUpperCase("HelloWorld");
}
}1.6 引用类的实例方法
引用类的实例方法，其实就是引用类中的成员方法
- 格式：类名：：成员方法
- 范例：String::substring
- String类中的方法：public String subString(int beginIndex,int endIndex)从beginIndex开始到endIndex结束，截取字符串。返回一个子串，字串的长度为endIndex-beginIndex
- Lambda表达式被类的实例方法替代的时候，第一个参数作为调用者，后面的参数全部传递给该方法作为参数
public interface MyString {
String mySubString(String s, int x, int y);
}public class MyStringDemo {
public static void main(String[] args) {
useMyString((s, x, y) -> s.substring(x, y));
useMyString(String::substring);
}
private static void useMyString(MyString myString){
String s = myString.mySubString("HelloWorld", 5, 10);
System.out.println(s);
}
}1.7 引用构造器
引用构造器，其实就是引用构造方法
- 格式：类名：：new
- 范例：Student：：new
- Lambda表达式被构造器代替的时候，它的形式参数全部传递给构造器作为参数
public class Student {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
}public interface StudentBuilder {
Student build(String name,int age);
}public class StudentDemo {
public static void main(String[] args) {
useStudentBuilder((name, age) -> new Student(name,age));
useStudentBuilder(Student::new);
}
private static void useStudentBuilder(StudentBuilder studentBuilder){
Student student = studentBuilder.build("xuanxuan", 22);
System.out.println(student.getName()+","+student.getAge());
}
}四、函数式接口
1.1 函数接口概述
函数式接口：有且仅有一个抽象方法的接口
Java中的函数式编程体现就是Lambda表达式，所以函数式接口就是可以使用于Lambda使用的接口
只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导
如何检测一个接口是不是函数式接口呢？
- @FunctionalInterface
- 放在接口定义的上方：如果接口是函数接口，编译通过；如果不是，编译失败
注意：
我们自己定义函数式接口的时候，@FunctionalInterface是可选的，就算我们不写这个注解，只要保证满足函数式接口定义的条件，也照样是函数式接口。但是，建议加上注解。
@FunctionalInterface
public interface MyInterface {
void show();
}public class MyInterfaceDemo {
public static void main(String[] args) {
MyInterface myInterface = ()-> System.out.println("函数式接口");
myInterface.show();
}
}1.2 函数式接口作为方法的参数
如果方法的参数是一个函数式接口，我们可以使用Lambda表达式作为参数传递
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));public class RunnableDemo {
public static void main(String[] args) {
startThread(new Runnable() {
@Override
public void run() {
System.out.println(Thread.currentThread().getName() + "线程启动了");
}
});
startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
startThread(()->{
System.out.println(Thread.currentThread().getName() + "线程启动了");
});
}
private static void startThread(Runnable runnable) {
new Thread(runnable).start();
}
}1.3 函数式接口作为方法的返回值
如果方法的返回值是一个函数式接口，我们可以使用Lambda表达式作为结果返回
private static Comparator<String> getComparator() {
return (s1,s2) -> s1.length() - s2.length();
}public class ComparatorDemo {
public static void main(String[] args) {
ArrayList<String> arrayList = new ArrayList<String>();
arrayList.add("ccc");
arrayList.add("aa");
arrayList.add("dddd");
arrayList.add("b");
System.out.println("排序前" + arrayList);
Collections.sort(arrayList);
System.out.println("排序后" + arrayList);
Collections.sort(arrayList, getComparator());
System.out.println("使用定义比较器排序方法后：" + arrayList);
}
private static Comparator<String> getComparator() {
// return new Comparator<String>() {
// @Override
// public int compare(String s1, String s2) {
// return s1.length() - s2.length();
// }
// };
return (s1,s2) -> s1.length() - s2.length();
}
}1.4 常用的函数式接口
Java 8 在java.util.function包下预定了大量的函数式接口供我们使用，常用如下：
- Supplier接口
- Consumer接口
- Predicate接口
- Function接口
1.5 Supplier接口
Supplier接口
- T get()：获得结果
- 该方法不需要参数，它会按照某种实现逻辑（由Lambda表达式实现)返回一个数据
- Supplier 接口也被称为生产型接口，如果我们指定了接口的泛型是什么类型，那么接口中的get方法就会生产什么类型的数据供我们使用
public class SupplierDemo {
public static void main(String[] args) {
String s = getString(() -> "xuanxuan");
System.out.println(s);
Integer i = getInteger(() -> 666);
System.out.println(i);
}
public static String getString(Supplier<String> supplier) {
return supplier.get();
}
public static Integer getInteger(Supplier<Integer> supplier) {
return supplier.get();
}
}练习：获取最大值
public class SupplierDemo {
public static void main(String[] args) {
int[] arr = new int[]{17, 28, 49, 21, 32, 66};
int maxNumber = getMax(() -> {
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (max < arr[i]) {
max = arr[i];
}
}
return max;
});
System.out.println("数组中的最大值是：" + maxNumber);
}
private static int getMax(Supplier<Integer> supplier) {
return supplier.get();
}
}1.6 Consumer接口
Consumer：包含两个方法
- void accept(T t)：对给定的参数执行此操作
- default Consumer andThen(Consumer after)：返回一个组合的Consumer,依次执行此操作，然后执行after操作
- Consumer 接口也被称为消费型接口，它消费的数据类型由泛型指定
public class ConsumerDemo {
public static void main(String[] args) {
operatorString("abc", s -> System.out.println(s));
operatorString("abc", System.out::println);
operatorString("abc", s -> System.out.println(new StringBuilder(s).reverse().toString()));
System.out.println("----------------------------------");
operatorString("abc", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));
}
private static void operatorString(String name, Consumer<String> consumer) {
consumer.accept(name);
}
private static void operatorString(String name, Consumer<String> consumer1, Consumer<String> consumer2) {
// consumer1.accept(name);
// consumer2.accept(name);
consumer1.andThen(consumer2).accept(name);
}
}练习：
字符串数组中又多条信息，按照：“姓名：name,年龄：age"的格式将信息打印出来
public class ConsumerDemo {
public static void main(String[] args) {
String[] arr = new String[]{"abc,30", "cbd,35", "dna,33"};
printInfo(arr, s -> System.out.print("姓名：" + s.split(",")[0] + ","), s -> System.out.println("年龄：" + Integer.parseInt(s.split(",")[1])));
}
private static void printInfo(String[] arr, Consumer<String> consumer1, Consumer<String> consumer2) {
for (String s : arr) {
consumer1.andThen(consumer2).accept(s);
}
}
}1.7 Predicate接口
常用方法：
练习：判断给定的字符串是否满足要求
public class PredicateDemo {
public static void main(String[] args) {
boolean b1 = checkString("hello", s -> s.length() > 5);
System.out.println(b1);
boolean b2 = checkString("helloworld", s -> s.length() > 8);
System.out.println(b2);
boolean b3 = checkString("hello", s -> s.length() > 5, s -> s.length() > 8);
System.out.println(b3);
boolean b4 = checkString("helloworld", s -> s.length() > 5, s -> s.length() > 8);
System.out.println(b4);
}
private static boolean checkString(String s, Predicate<String> predicate) {
return predicate.test(s);
}
private static boolean checkString(String s, Predicate<String> predicate, Predicate<String> predicate2) {
// return predicate.and(predicate2).test(s);
return predicate.or(predicate2).test(s);
}
}
练习2：
- String[] strArray ={“孙悟空，30”,“唐僧，36”，“沙僧，34”，“猪八戒，32”，“白骨精，5000”}
- 字符串数组中有多条信息，请通过Predicate接口的拼装将符合要求的字符串筛选到集合ArrayLitst中，并遍历ArrayLitst集合
- 同时满足如下要求：name长度大于2，age大于33
public class PredicateDemo3 {
public static void main(String[] args) {
String[] strArray = new String[]{"孙悟空，30", "唐僧，36", "沙僧，34", "猪八戒，32", "白骨精，5000"};
ArrayList<String> arrayList = myFilter(strArray, s -> s.split("，")[0].length() > 2, s -> Integer.parseInt(s.split("，")[1]) > 33);
System.out.println("name长度大于2，age大于33有：");
for (String s : arrayList) {
System.out.print("name：" + s.split("，")[0] + "，");
System.out.println("age：" + Integer.parseInt(s.split("，")[1]));
}
}
private static ArrayList<String> myFilter(String[] strArray, Predicate<String> predicate1, Predicate<String> predicate2) {
ArrayList<String> arrayList = new ArrayList<String>();
for (String s : strArray) {
if (predicate1.and(predicate2).test(s)) {
arrayList.add(s);
}
}
return arrayList;
}
}1.8 Function接口
Function<T,R>两个常用方法：
Function<T,R>接口通常用于对参数进行处理，转换（处理逻辑由Lambda表达式实现）然后返回一个新的值
练习：
public class FunctionDemo {
public static void main(String[] args) {
convert("100", s -> Integer.parseInt(s));
convert("100", Integer::parseInt);
convert(100, i -> String.valueOf(100 + i));
convert("100", s -> Integer.parseInt(s), i -> String.valueOf(i + 566));
}
//定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(String s, Function<String, Integer> function) {
Integer i = function.apply(s);
System.out.println(i);
}
//定义一个方法，把一个int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(int i, Function<Integer, String> function) {
String s = function.apply(i);
System.out.println(s);
}
//定义一个方法，把一个字符串转换为int类型，把int类型的数据加上一个整数之后，转为字符串在控制台输出
private static void convert(String s, Function<String, Integer> function1, Function<Integer, String> function2) {
String ss = function2.apply(function1.apply(s));
System.out.println(ss);
}
}练习2：提取String中的年龄加70岁，并以int型输出
public class FunctionDemo {
public static void main(String[] args) {
String s = "孙悟空，30";
convert(s, s1 -> s1.split("，")[1], s1 -> Integer.parseInt(s1) + 70);
}
private static void convert(String s, Function<String, String> function1, Function<String, Integer> function2) {
Integer i = function2.apply(function1.apply(s));
System.out.println(i);
}
}五、Stream流
1.1 体验Stream流
需求：按照下面的要求完成集合的创建和遍历
- 创建一个集合，存储多个字符串元素
- 把集合中所有以“张”开头的元素存储到一个新的集合再
- 把长度为3的元素存储到一个新集合
- 最后遍历上一步得到的集合
使用Stream流的方式完成过滤操作：
- 直接阅读代码的字面意思即可完美展示无关逻辑方式的语义：生成流、过滤姓氏、过滤长度为3、逐一打印
- Stream流把真正的函数式编程风格引入到java中
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张飞");
list.add("张三丰");
list.add("张三");
list.add("李四");
list.add("孙悟空");
list.add("张一飞");
ArrayList<String> zhangList = new ArrayList<String>();
for (String s : list) {
if (s.startsWith("张")) {
zhangList.add(s);
}
}
ArrayList<String> treeList = new ArrayList<String>();
for (String s : zhangList) {
if (s.length() == 3) {
treeList.add(s);
}
}
for (String s : treeList) {
System.out.println(s);
}
System.out.println("-------------------------------");
//Stream流改进
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(s -> System.out.println(s));
}
}1.2 Stream流的生成方式
Stream流的使用
生成流：通过数据源（集合、数组等）生成流
list.stream();中间操作：一个流后面可以跟随零个或者多个中间操作，其目的主要是打开流，做出某种程度的数据过滤/映射，然后返回一个新的流，交给下一个操作使用
filter()终结操作：一个流只能有一个终结操作，当这个操作执行后，流就被使用“光”了，无法再被操作。所以这必定是流的最后一个操作
forEach()Stream流的常见生成方式
Collection体系的集合可以使用默认方法stream()生成流
default Stream<E> stream()- Map体系的集合间接的生成流
- 数组可以通过Stream接口的静态方法of(T…values)生成流
public class StreamDemo {
public static void main(String[] args) {
List<String> list = new ArrayList<String>();
Stream<String> listStream = list.stream();
Set<String> set = new HashSet<String>();
Stream<String> setStream = set.stream();
Map<String, Integer> map = new HashMap<String, Integer>();
Stream<String> keyStream = map.keySet().stream();
Stream<Integer> valueStream = map.values().stream();
Stream<Map.Entry<String, Integer>> entryStream = map.entrySet().stream();
String[] strArray = {"hello", "world", "java"};
Stream<String> strArrayStream = Stream.of(strArray);
Stream<String> strArrayStream2 = Stream.of("hello", "world", "java");
Stream<Integer> strArrayStream3 = Stream.of(10, 20, 30);
}
}1.3 Stream流的常见中间操作方法
- Stream filter(Predicate predicate)：用于对流中的数据进行过滤
- Predicate接口中的方法：boolean test(T t):对给定的参数进行判断，返回一个布尔值
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张飞");
list.add("张三丰");
list.add("张三");
list.add("李四");
list.add("孙悟空");
list.add("张一飞");
list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
System.out.println("----------------------");
list.stream().filter(s -> s.length() == 3).forEach(System.out::println);
System.out.println("----------------------");
list.stream().filter(s -> s.startsWith("张")).filter(s -> s.length() == 3).forEach(System.out::println);
}
}- Stream limit(long maxSize)：返回此流中的元素组成的流，截取前指定参数个数的数据
- Stream skip(long n)：跳过指定参数个数的数据，返回由该流的剩余元素组成的流
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张飞");
list.add("张三丰");
list.add("张三");
list.add("李四");
list.add("孙悟空");
list.add("张一飞");
//取前三个数据在控制台输出
list.stream().limit(3).forEach(System.out::println);
System.out.println("-----------------------------");
//跳过2个元素，把剩下的元素在控制台上输出
list.stream().skip(2).forEach(System.out::println);
System.out.println("-----------------------------");
//跳过2个元素并将剩下元素的前两个元素在控制台上输出
list.stream().skip(2).limit(2).forEach(System.out::println);
}
}- Stream Stream concat(Stream a,Stream b)：合并a和b两个流为一个流
- Stream distinct：返回由该流的不同元素（根据Objectequals(Object)）组成的流
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张飞");
list.add("张三丰");
list.add("张三");
list.add("李四");
list.add("孙悟空");
list.add("张一飞");
//需求1：取前4个数据组成一个流
Stream<String> limitStream = list.stream().limit(4);
//需求2：跳过2个数据组成一个流
Stream<String> skipStream = list.stream().skip(2);
//需求3：合并需求1和需求2得到的流，并把结果在控制台输出
// Stream.concat(limitStream,skipStream).forEach(System.out::println);
//需求4：合并需求1和需求2得到的流，并把结果在控制台输出，要求字符串元素不能重复
Stream.concat(limitStream,skipStream).distinct().forEach(System.out::println);
}
}- Stream sorted()：返回由此流的元素组成的流，根据自然顺序排序
- Stream sorted(Comparator comparator)：返回由该流的元素组成的流，根据提供的Comparator进行排序
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("zhangfei");
list.add("zhangsanfeng");
list.add("zhangsan");
list.add("lisi");
list.add("sunwukong");
list.add("zhangyifei");
//需求1：按照字母顺序把数据在控制台输出
list.stream().sorted().forEach(System.out::println);
//需求2：按照字符串长度把数据在控制台输出
list.stream().sorted((s1, s2) -> {
int num = s1.length() - s2.length();
int num2 = num == 0 ? s1.compareTo(s2) : num;
return num2;
}).forEach(System.out::println);
}
}- Stream map(Function mapper)：返回由给定函数应用于此流的元素的结果组成的流（Function接口中的方法 R apply(T t)）
- IntStream mapToInt(ToIntFunction mapper)：返回一个IntStream其中包含将给定函数应用于此流的元素的结果
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("10");
list.add("20");
list.add("30");
list.add("40");
list.add("50");
// list.stream().map(s -> Integer.parseInt(s)).forEach(System.out::println);
list.stream().map(Integer::parseInt).forEach(System.out::println);
list.stream().mapToInt(Integer::parseInt).forEach(System.out::println);
int result = list.stream().mapToInt(Integer::parseInt).sum();
System.out.println(result);
}
}1.4 Stream流的常见终结操作方法
- void forEach(Consumer action)：对此流的每个元素执行操作（Consumer接口中的方法 void accept(T t)：对给定的参数执行此操作）
- long count()：返回此流中的元素数
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张飞");
list.add("张三丰");
list.add("张三");
list.add("李四");
list.add("孙悟空");
list.add("张一飞");
//需求1：把集合中的元素在控制台输出
list.stream().forEach(System.out::println);
//需求2：统计集合中有几个姓张的元素并在控制台输出
list.stream().filter(s -> s.startsWith("张")).forEach(System.out::println);
}
}1.5 Stream流的练习
现在又两个ArrayList集合，分别存储6名男演员和6名女演员名称，要求完成如下操作
- 男演员只要名字为3个字的前三人
- 女演员只要姓林的，并且不要第一个
- 把过滤后的男演员姓名和女演员姓名合并到一起
- 把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据（演员类Actor已经提供，里面有一个成员变量，一个带参构造方法，以及成员变量对应的get/set方法）
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> manList = new ArrayList<String>();
manList.add("周润发");
manList.add("成龙");
manList.add("刘德华");
manList.add("吴京");
manList.add("周星驰");
manList.add("李连杰");
ArrayList<String> womanList = new ArrayList<String>();
womanList.add("林心如");
womanList.add("张曼玉");
womanList.add("林青霞");
womanList.add("柳岩");
womanList.add("林志玲");
womanList.add("王祖贤");
//男演员只要名字为3个字的前三人
Stream<String> manStream = manList.stream().filter(s -> s.length() == 3).limit(3);
//女演员只要姓林的，并且不要第一个
Stream<String> womanStream = womanList.stream().filter(s -> s.startsWith("林")).skip(1);
//把过滤后的男演员姓名和女演员姓名合并到一起
Stream<String> stream = Stream.concat(manStream, womanStream);
//把上一步操作后的元素作为构造方法的参数创建演员对象，遍历数据
stream.map(Actor::new).forEach(p -> System.out.println(p.getName()));
System.out.println("------------------------------------");
//改进
Stream.concat(manList.stream().filter(s -> s.length() == 3).limit(3), womanList.stream().filter(s -> s.startsWith("林")).skip(1)).map(Actor::new).forEach(p -> System.out.println(p.getName()));
}
}1.6 Stream流的收集操作
对数据使用Stream流的方式操作完毕后，如何把流中的数据收集到集合中？
Stream流的手机方法
- R collect(Collector collector)
- 但是这个收集方法的参数是一个Collector接口
工具类Collectors提供了具体的收集方式:
- public static Collector toList()：把元素收到List集合中
- public static Collector toSet()：把元素收集到Set集合中
- public static Collector toMap(Function keyMapper,Function valueMapper):把元素收集到Map集合中
public class StreamDemo {
public static void main(String[] args) {
ArrayList<String> list = new ArrayList<String>();
list.add("张飞");
list.add("张三丰");
list.add("张三");
list.add("李四");
list.add("孙悟空");
list.add("张一飞");
//需求1：得到名字为3个字的流
Stream<String> listStream = list.stream().filter(s -> s.length() == 3);
//需求2：把使用Stream流操作完毕的数据收集到List集合中并遍历
List<String> collect = listStream.collect(Collectors.toList());
for (String s : collect) {
System.out.println(s);
}
Set<Integer> set = new HashSet<Integer>();
set.add(10);
set.add(20);
set.add(30);
set.add(33);
set.add(35);
//需求3：得到年龄大于25的流
Stream<Integer> integerStream = set.stream().filter(age -> age > 25);
//需求4：把使用Stream流操作完毕的数据收集到Set集合中并遍历
Set<Integer> collect2 = integerStream.collect(Collectors.toSet());
for (Integer i : collect2) {
System.out.println(i);
}
String[] strArray = {"张飞，28", "张三丰，33", "张三，26", "李四，44"};
//需求5：得到字符串年龄中数据大于28的流
Stream<String> stringStream = Stream.of(strArray).filter(s -> Integer.parseInt(s.split("，")[1]) > 28);
//需求6：把使用Stream流操作完毕的数据收集到Map集合中并遍历，字符串的姓名作为键，年龄作为值
Map<String, Integer> map = stringStream.collect(Collectors.toMap(s -> s.split("，")[0], s -> Integer.parseInt(s.split("，")[1])));
Set<String> keySet = map.keySet();
for (String key : keySet) {
Integer value = map.get(key);
System.out.println(key + "，" + value);
}
}
}到此这篇关于Java 函数式编程梳理的文章就介绍到这了,更多相关Java 函数式编程内容请搜索编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程网！
