当前位置：首页 > news >正文

lambda、function基础/响应式编程基础

news 2025/6/29 10:22:38

lambda表达式

只要是函数式接口（接口内只有一个未实现的方法，可以有其它默认方法），就可以用lambda表达式，也就是快速new一个匿名内部类。

实例化接口的三种方式

继承接口，并实现接口
直接实现匿名内部类

通过lambda表达式去实现匿名内部类

package org.khaoden.lambda;interface animal {void sound();default void eat() {System.out.println("Eating");};
}interface cat {void sound();default void eat() {System.out.println("Eating1");}
}class Dog implements animal {public void sound() {System.out.println("Barking");}
}public class Lambda {public static void main(String[] args) {Dog d = new Dog();d.sound();System.out.println("~~~~~~~~~~~~~~~~~");animal c = new animal() {@Overridepublic void sound() {System.out.println("Meow");}};c.sound();System.out.println("~~~~~~~~~~~~~~~~~");animal a = () -> {System.out.println("Woof");};a.sound();a.eat();System.out.println("~~~~~~~~~~~~~~~~~");}
}

lambda表达式的匹配方式
1. 如果没有参数类型，是通过函数的参数数量来匹配的，按照顺序匹配
2. 如果有参数类型，就加上类型的匹配

例子

比较器的lambda写法

package org.khaoden.lambda;import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;class Student {String name;Integer grade;public Student(String name, int grade) {this.name = name;this.grade = grade;}
}public class example {public static void main(String[] args) {List<Student> list = new ArrayList<>();list.add(new Student("khaoden", 10));list.add(new Student("khaoden1", 9));list.add(new Student("khaoden2", 8));printListVal(list);//        Collections.sort(list, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.grade.compareTo(o2.grade);
//            }
//        });// lambda表达式
//        Collections.sort(list, (o1, o2) -> o1.grade.compareTo(o2.grade));// 方法引用，必须是传入的值就是比较的，且一定是升序的
//        Collections.sort(list, Integer::compareTo); // 每次拿一个值去比较，list的元素类型就是比较器方法的擦参数类型// 对于有对应静态方法的可以直接使用Collections.sort(list, Comparator.comparingInt(o -> o.grade));printListVal(list);Runnable runnable = () -> System.out.println("hello world");runnable.run();Thread t = new Thread(() -> System.out.println("hello world from thread"));System.out.println("hello world1");t.start();}private static void printListVal(List<Student> list) {for (Student student : list) {System.out.println(student.name + " " + student.grade);}}
}

使用注意
- lambda表达式本质就是对方法的快速实现，如果对应的类型有现成的方法，可以使用方法引用去调用。
- 方法引用不需要传递参数，直接把值传入比较即可。如果比较的是对应对象的属性，可以使用Comparator的静态方法，比如Integer是comparingInt(x -> x.val)
- lambda表达式的变量类型必须是接口，因为是用来匿名内部类的，写一个类完全没有意义，而且也没有接口继承类的。

Function

java提供了一系列的函数时接口

类型分别

消费者 accept
生产者 get
多功能函数 apply

普通函数

import java.util.function.BiFunction;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;public class Func {public static void main(String[] args) {// 消费者Consumer<String> consumer = (t) -> {System.out.println(t);};// 提供者Supplier<String> supplier = () -> {return "hello world";};// 普通函数Runnable runnable = () -> {System.out.println("hello world");};// 多功能函数Function<String, String> function = (t) -> {return t;};// 多参数功能函数BiFunction<String, String, String> biFunction = (t, u) -> {return t + u;};System.out.println(function.apply("hello world"));System.out.println(biFunction.apply("hello", " world"));System.out.println(supplier.get());consumer.accept("hello world");}
}

常用接口

断言Predicate：返回值是boolean，根据传来的参数去判断

// 断言
Predicate<Integer> predicate = t -> t % 2 == 0;
System.out.println(predicate.test(2)); // 正向判断
System.out.println(predicate.negate().test(2)); // 反向判断

实例

import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;public class FuncDEMO {public static void main(String[] args) {// 定义数字提供函数Supplier<String> supplier = () -> "42";// 定义偶数断言Predicate<Integer> predicate = (t) -> t % 2 == 0;// 转换器，字符串转数字Function<String, Integer> func = Integer::parseInt;// 消费者，打印数字Consumer<Integer> consumer = System.out::println;Myfunc(predicate, func, supplier, consumer);Myfunc((t) -> t % 2 == 0, Integer::parseInt, () -> "43", System.out::println);}private static void Myfunc(Predicate<Integer> predicate, Function<String, Integer> func, Supplier<String> supplier, Consumer<Integer> consumer) {if (predicate.test(func.apply(supplier.get()))) {consumer.accept(func.apply(supplier.get()));} else {System.out.println("不是偶数");}}
}