Java8的Lambda表达式(箭头函数)

柔光的暖阳◎ 2023-07-11 06:18 8阅读 0赞

#### 函数式编程思想 ####

在数学中 函数就是有输入量和输出量的一套计算方案 也就是“拿什么东西做什么事情”  
相对而言 面向对象过分强调必须通过对象的形式来做事情  
而函数式思想则尽量忽略面向对象的复杂语法——**强调做什么 而不是以什么形式做**

*  面向对象的思想：  
    做一件事情 找一个能解决这个事情的对象 调用对象的方法 完成事情
 *  函数式编程思想：  
    只要能获取到结果 谁去做的 怎么做的都不重要,重视的是结果 不重视过程

可能不太好理解 我们举个简单的栗子：

#### 代码冗余 ####

public static void main(String[] args) {
        
            RunnableImpl runnable=new RunnableImpl();
            Thread thread=new Thread(runnable);
            thread.start();
    
            // 使用匿名内部类简化
            Runnable runnable1 = new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + " - new");
                }
            };
            new Thread(runnable1).start();
    
            // 继续简化
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName() + " - new");
                }
            }).start();
        }

在这段多线程代码中：  
1、Thread 类需要 Runnable 接口作为参数 因为其中的抽象 run 方法是用来指定线程任务内容的核心  
2、为了指定 run 的方法体 **不得不**需要存在一个Runnable接口的实现类  
3、为了省去定义一个RunnableImpl实现类的麻烦 **不得不**使用匿名内部类  
4、因为必须覆盖重写抽象的run方法 所以方法名称 方法参数和方法返回值都**不得不**再写一遍 且不能写错  
而实际上 **只有方法体才是关键所在**

因此 我们需要转换我们的编程思想  
更加关注做什么 而不是怎么做

我们为了做这件事情而不得不创建一个匿名内部类对象  
而我们真正希望做的事情是将 run 方法体内的代码传递给 Thread 类

**传递一段代码——这才是真正的目的**

--------------------

# 更加简便： #

在2014年3月Oracle所发布的Java 8（JDK 1.8）中 加入了**Lambda表达式**的重量级新特性 打开了新世界的大门  
如下案例：

public static void main(String[] args) {
        
        // 使用匿名内部类的方式实现多线程
        new Thread(new Runnable() {
        
            @Override
            public void run() {
        
                System.out.println(Thread.currentThread().getName() + " - new");
            }
        }).start();
    
        //使用Lambda表达式实现多线程
        new Thread(() -> {
        
                System.out.println(Thread.currentThread().getName() + " - new");
            }
        ).start();
    }

我们来详细看一下：  
Runnable 接口只有一个 run 方法的定义：`public abstract void run()`  
即制定了一种做事情的方案（其实就是一个函数）：

*  无参数：不需要任何条件即可执行该方案
 *  无返回值：该方案不产生任何结果
 *  代码块（方法体）：该方案的具体执行步骤

在Lambda表达式中更为简单：`() ‐> System.out.println("方法执行")`

前面的一对小括号即 run 方法的**参数**(无） 代表不需要任何条件  
中间的一个箭头代表将前面的参数**传递**给后面的代码  
后面的输出语句即**业务逻辑**代码

--------------------

# 一、Lambda表达式的标准格式 #

Lambda省去了面向对象语法的条条框框  
格式由3个部分组成：

*  一些参数
 *  一个箭头
 *  一段代码

标准格式：

(参数类型 参数名称) ‐> {
         代码语句 }

小括号内的语法与传统方法参数列表一致：无参数则留空 多个参数则用逗号分隔  
\-> 是新引入的语法格式 代表**指向动作**  
大括号内的语法与传统方法体要求基本一致

# 二、案例： #

## 1、无参数无返回值 ##

接口类：

public interface Cook {
        
        public abstract void makeFood();
    }

测试类：

public class CookTest {
        
        public static void main(String[] args) {
        
            // 调用invokeCook()方法 传递Cook接口的匿名内部类对象
            invokeCook(new Cook() {
        
                @Override
                public void makeFood() {
        
                    System.out.println("开饭了");
                }
            });
    
            // 使用Lambda表达式简化匿名内部类的书写
            invokeCook(() -> {
        
                System.out.println("开饭了");
            });
        }
    
        // 定义一个方法 参数传递Cook接口 方法内部调用Cook接口中的makeFood()方法
        public static void invokeCook(Cook cook)
        {
        
            cook.makeFood();
        }
    }

## 2、有参数有返回值 ##

#### 例一、 ####

实体类：

public class Person {
        
        private String name;
        private int age;
    
        ...
    }

测试类：

public class ArraysTest {
        
        public static void main(String[] args) {
        
            // 使用数组存储多个Person对象
            Person[] arr={
        new Person("小A",10),
                    	new Person("小B",13),
                    	new Person("小C",12)};
    
            // 升序操作
            Arrays.sort(arr, new Comparator<Person>() {
        
                @Override
                public int compare(Person o1, Person o2) {
        
                    return o1.getAge()-o2.getAge();
                }
            });
    
            // 使用Lambda表达式简化匿名内部类的书写
            Arrays.sort(arr,(Person o1, Person o2) -> {
        
                return o1.getAge()-o2.getAge();
            });
    
            // 遍历输出结果
            for (Person p:arr)
            {
        
                System.out.println(p);
            }
        }
    }

--------------------

#### 例二、 ####

计算类：

public interface Calculate {
        
        public abstract int calc(int a,int b);
    }

测试类：

public class CalculateTest {
        
        public static void main(String[] args) {
        
            // 调用方法 参数是一个接口 可以使用匿名内部类
            invokeCalc(1, 2, new Calculate() {
        
                @Override
                public int calc(int a, int b) {
        
                    return a+b;
                }
            });
    
            // 使用Lambda表达式简化匿名内部类的书写
            invokeCalc(1,2,(int a,int b) -> {
        
                return a+b;
            });
        }
    
        // 参数传递两个int类型的整数和Calculate接口 内部调用方法计算两个整数的和
        public static void invokeCalc(int a,int b,Calculate calculate)
        {
        
            System.out.println(calculate.calc(a, b));
        }
    }

# 三、Lambda省略格式 #

Lambda表达式是可推导可省略的  
凡是根据上下文推导出来的内容 都可以省略书写

可省略的内容：  
1、参数列表：括号中参数列表的数据类型可以省略不写 因为在接口里已经定义了类型  
2、参数列表：括号中的参数如果只有一个 那么类型和()都可以省略  
3、代码：如果\{\}中的代码只有一行 那么无论是否有返回值 都可以省略\{\}和return和分号 但**要省略必须一起省略**

public static void main(String[] args) {
        
       // 在JDK1.7版本之前 必须把前后的泛型都写上
        ArrayList<String> arrayList1=new ArrayList<String>();
    
        // 在JDK1.7版本之后 等号后的泛型可省略 因为可以根据前面的泛型推导出来
        ArrayList<String> arrayList2=new ArrayList<>();
    }

## 案例 ##

无参数无返回值：

// 调用invokeCook()方法 传递Cook接口的匿名内部类对象
    invokeCook(new Cook() {
        
        @Override
        public void makeFood() {
        
            System.out.println("开饭了");
        }
    });
    
    // 使用Lambda表达式简化匿名内部类的书写
    invokeCook(() -> {
        
        System.out.println("吃饭了");
    });
    
    // 优化省略Lambda ★
    invokeCook(() -> System.out.println("吃饭了"));

--------------------

有参数有返回值：

// 调用方法 参数是一个接口 可以使用匿名内部类
    invokeCalc(1, 2, new Calculate() {
        
         @Override
         public int calc(int a, int b) {
        
             return a+b;
         }
     });
    
     // 使用Lambda表达式简化匿名内部类的书写
     invokeCalc(1,2,(int a,int b) -> {
        
         return a+b;
     });
    
     // 优化省略Lambda ★
     invokeCalc(1,2,(a,b) -> a+b);

--------------------

总结：  
1、使用Lambda必须具有接口 且要求接口中**有且仅有一个抽象方法**  
因此 无论是JDK内置的 Runnable 接口或 Comparator 接口还是自定义的接口 只有当接口中的抽象方法存在且唯一时 才可使用Lambda  
因为如果有多个抽象方法的话 就不知道调用哪个抽象方法了  
2、使用Lambda必须具有**上下文推断**  
也就是方法的参数或局部变量类型必须为Lambda对应的接口类型 才能使用Lambda作为该接口的实例

注：有且仅有一个抽象方法的接口称为**函数式接口**

--------------------