目录
Lambda表达式
1.什么是Lambda表达式
Lambda表达式（也称为匿名函数或箭头函数）是一种在编程中使用简洁的函数语法来表示一个函数的方法。Lambda表达式允许你在需要一个函数的地方快速定义一个函数，而无需按照传统方式声明一个完整的函数。
从Java 8开始引入Lambda表达式，用于简化代码，特别是在使用集合框架和并行流时
2.Lambda表达式的使用
先来看传统的匿名内部类的写法
// 传统的匿名内部类
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("这是传统的匿名内部类写法");
}
});
对比使用Lambda表达式
// 使用Lambda表达式简化
new Thread(() -> System.out.println("这是Lambda表达式写法")).start();在这个例子中，我们定义了一个线程，它将在启动时打印一段话。使用Lambda表达式，我们可以省略匿名内部类的声明，使代码更加简洁。
3.Lambda表达式的写法规则（以以上例子来说）
在Lambda表达式中的主要有三部分组成（参数 ，->，执行的逻辑）
参数 -> 要执行对的逻辑
如果没有参数的话就直接用 () ->
在上述的例子中 这个线程中的run()方法就没有参数，所以在Lambda表达式中就是() ->开头
而这个线程中run()方法执行的逻辑是打印一段话，所以箭头后面的执行逻辑就直接写
4.要注意的要点
在有参数的情况下在定义参数的时候要把参数类型明确的指出
(int a, int b)-> a + b
// （在执行的逻辑大于一行的时候不能省略{}以及return）
(int a, int b) -> {int c = a + b; return c}
// 当可以根据上下文推断出参数类型的时候，可以省略参数类型
(a, b) -> a + b
// 这个是函数式接口，里面有且只能有一个方法 --- Lambda表达式就是函数式接口的实现
Interface Lambda1{
Int op(int a, int b);
}
// 只有一个参数时，（）可以省略
a -> a;
// 注意：在定义参数类型的时候 ----- 要么参数类型都加上，要么参数类型都不加,不能一个有参数类型，另外一个没有参数类型方法引用
方法引用就是将现有的方法对象调用化为函数对象
// Math::max 是一个方法引用，它引用了 java.lang.Math 类中的 max 静态方法
左侧的方法调用跟右侧的Lambda表达式的作用完全是相似的
Math::max (int a, int b) -> Math.max(a, b)
// 以下的同理都是方法的引用
非静态方法类型
Student::getName() (Student stu) -> stu.getName()
构造函数类型
System.out::println (Object obj) -> System.out.println(obj);
构造函数类型
Student::new () -> new Student();函数式接口
1.什么是函数式接口
在Java中，函数式接口（Functional Interface）是指只包含一个抽象方法的接口。这个接口可以有多个默认方法，但抽象方法只能有一个。函数式接口的主要用途是与Lambda表达式一起使用，Lambda表达式提供了这个抽象方法的实现。
2.函数是接口的自定义使用
// 这个是函数式接口，里面有且只能有一个方法 --- Lambda表达式就是函数式接口的实现
// 这种是有参数，有返回值的类型 --- 参数是Int类型的两个参数 返回值是Int类型
对应的Lambda表达式是 (int a, int b) -> 任何返回是Int的逻辑(如 a + b, a * b)
Interface Lambda1{
Int op(int a, int b);
}
// 这种是有参数，有返回值的类型 --- 参数是Int类型的一个参数 返回值是boolean类型
对应的Lambda表达式 (Integer number) -> (number & 1 == 0)
Interface Lambda2{
boolean op(int a);
}
// 这种是无参数，有返回值的类型 --- 返回值类型是泛型,返回任何类型
对应的Lambda表达式 Lambda3 lambda = () -> "这是输出一段话"
() -> Math.random(); ---还可以生成随机数
// 具体实现
Lambda3<String> lambda3 = () -> "hello";
String str = lambda3.op();
System.out.println(str);
Interface Lambda3<T>{
T op();
}
// 这种是有参数，有返回值的类型 --- 参数是泛型，返回值类型是泛型,返回任何类型
对应的Lambda表达式 (Int a) -> String.valueOf(a) --- 这里参数是Int，返回值是String
Interface Lambda3<T,R>{
R op(T t);
}
3.JDK自带的函数式接口
以上都是自定的函数式接口，但是在JDK中有自带的函数式接口
这里的@FunctionalInterface注解的作用就是检查函数式接口是否只有一个方法
这种类型就是返回boolean类型的 一个参数的
@FunctionalInterface
public interface IntPredicate {
/**
* Evaluates this predicate on the given argument.
*
* @param value the input argument
* @return {@code true} if the input argument matches the predicate,
* otherwise {@code false}
*/
boolean test(int value);
这种类型的是返回Int类型的然后两个参数的
@FunctionalInterface
public interface IntBinaryOperator {
/**
* Applies this operator to the given operands.
*
* @param left the first operand
* @param right the second operand
* @return the operator result
*/
int applyAsInt(int left, int right);
}
这种类型是返回一个泛型但是没有参数
@FunctionalInterface
public interface Supplier<T> {
T get();
}
这种类型是带两个泛型的（一个参数泛型，一个返回结果泛型）
第一个是方法参数，第二个是返回结果参数
@FunctionalInterface
public interface Function<T, R> {
/**
* Applies this function to the given argument.
*
* @param t the function argument
* @return the function result
*/
R apply(T t);
}
常见的函数式接口
常见的函数接口
1、 Runnable () -> void 用在多线程中
2、 Callable () -> T 用在多线程中
3、 Comparator (T,T) - > int 用来比较的
4、 Consumer,BiConsumer,IntConsumer,LongConsumer,DoubleConsumer
(T) -> void , Bi是两个参数,Int 指参数是int 表示函数对象都没有返回值
5、 Function, BiFunctino,Int Long Double
(T) -> R, Bi是两参，Int指参数是int 将来的函数对象有参数并且有返回值的 而且参数和返回值的对象不一样
6、 Predicate, BiPredicate, Int Long Double
(T) -> Boolean, Bi是两参，Int指参数是Int 表示有参数有返回值，返回值类型都是boolean
7、 Supplier, Int Long Double
() -> T, Int指返回值是int 没有参数，但是有返回值
8、 UnaryOprator, BinaryOperator,Int Long Double
(T) -> T,Unary 一参， Binary 两参，Int 参数是指int 参数与返回结果要一样
总结
名称 含义
Consumer 有参，无返回值
Function 有参，有返回值
Predicate 有参，有返回值boolean
Supplier 无参，有返回值
Operator 有参，有返回值，并且类型一样
Lambda表达式和函数式接口的结合使用，使得Java代码能够以一种更加声明式和简洁的方式来表达复杂的逻辑。这种组合特别适用于实现回调机制、事件监听器、线程行为、集合操作等场景
-
代码简洁：Lambda表达式和函数式接口使得代码更加简洁，减少了模板代码。
-
提高可读性：通过减少冗余代码，提高了代码的可读性。
-
易于维护：简洁的代码更易于理解和维护。
-
函数式编程：支持函数式编程范式，允许开发者以声明式的方式处理数据集合。
-
灵活性：Lambda表达式和函数式接口提供了编写灵活代码的能力，能够更容易地实现高阶函数。