提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  工具

当前栏目

Lambda表达式学习笔记

笔记学习 表达式 lambda
2023-06-13 09:13:52 时间

Lambda表达式

1. 需求分析

创建一个新的线程，指定线程要执行的任务

    public static void main(String[] args) {
        // 开启一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("新线程中执行的代码 : "+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("主线程中的代码：" + Thread.currentThread().getName());
    }

代码分析：

  1. Thread类需要一个Runnable接口作为参数，其中的抽象方法run方法是用来指定线程任务内容的核心
  2. 为了指定run方法体，不得不需要Runnable的实现类
  3. 为了省去定义一个Runnable 的实现类，不得不使用匿名内部类
  4. 必须覆盖重写抽象的run方法，所有的方法名称，方法参数，方法返回值不得不都重写一遍，而且不能出错，
  5. 而实际上，我们只在乎方法体中的代码

2.Lambda表达式初体验

Lambda表达式是一个匿名函数，可以理解为一段可以传递的代码

new Thread(() -> { System.out.println("新线程Lambda表达式..." +Thread.currentThread().getName()); })
                .start();

Lambda表达式的优点：简化了匿名内部类的使用，语法更加简单。

匿名内部类语法冗余，体验了Lambda表达式后，发现Lambda表达式是简化匿名内部类的一种方式。

3. Lambda的语法规则

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

(参数类型 参数名称) -> {
    代码体;
}

格式说明：

  • (参数类型 参数名称):参数列表
  • {代码体;} :方法体
  • -> : 箭头，分割参数列表和方法体

3.1 Lambda练习1

练习无参无返回值的Lambda

定义一个接口

public interface UserService {
    void show();
}

然后创建主方法使用

public class Demo03Lambda {
​
    public static void main(String[] args) {
        goShow(new UserService() {
            @Override
            public void show() {
                System.out.println("show 方法执行了...");
            }
        });
        System.out.println("----------");
        goShow(() -> { System.out.println("Lambda show 方法执行了..."); });
    }
​
    public static void goShow(UserService userService){
        userService.show();
    }
}

输出：

show 方法执行了...
----------
Lambda show 方法执行了...

3.2 Lambda练习2

完成一个有参且有返回值得Lambda表达式案例

创建一个Person对象

​
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
​
    private String name;
​
    private Integer age;
​
    private Integer height;
​
}
​

然后我们在List集合中保存多个Person对象，然后对这些对象做根据age排序操作

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("周杰伦",33,175));
        list.add(new Person("刘德华",43,185));
        list.add(new Person("周星驰",38,177));
        list.add(new Person("郭富城",23,170));
​
        Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }
​

我们发现在sort方法的第二个参数是一个Comparator接口的匿名内部类，且执行的方法有参数和返回值，那么我们可以改写为Lambda表达式

    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("周杰伦",33,175));
        list.add(new Person("刘德华",43,185));
        list.add(new Person("周星驰",38,177));
        list.add(new Person("郭富城",23,170));
​
        /*Collections.sort(list, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getAge()-o2.getAge();
            }
        });
        for (Person person : list) {
            System.out.println(person);
        }*/
        System.out.println("------");
        Collections.sort(list,(Person o1,Person o2) -> {
            return o1.getAge() - o2.getAge();
        });
        for (Person person : list) {
            System.out.println(person);
        }
    }

输出结果

Person(name=郭富城, age=23, height=170)
Person(name=周杰伦, age=33, height=175)
Person(name=周星驰, age=38, height=177)
Person(name=刘德华, age=43, height=185)

4. @FunctionalInterface注解

/**
 * @FunctionalInterface
 *    这是一个标志注解，被该注解修饰的接口只能声明一个抽象方法
 */
@FunctionalInterface
public interface UserService {
​
    void show();
​
}

5. Lambda表达式的原理

匿名内部类的本质是在编译时生成一个Class 文件。XXXXX$1.class

public class Demo01Lambda {
​
    public static void main(String[] args) {
        // 开启一个新的线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("新线程中执行的代码 : "+Thread.currentThread().getName());
            }
        }).start();
        System.out.println("主线程中的代码：" + Thread.currentThread().getName());
        System.out.println("---------------");
        /*new Thread(() -> { System.out.println("新线程Lambda表达式..." +Thread.currentThread().getName()); })
                .start();*/
    }
}

还可以通过反编译工具来查看生成的代码 XJad 工具来查看

static class Demo01Lambda$1
    implements Runnable
{
​
    public void run()
    {
        System.out.println(
        (new StringBuilder()).append("新线程中执行的代码 : " )
        .append(Thread.currentThread().getName()).toString()
        );
    }
​
    Demo01Lambda$1()
    {
    }
}

Lambda表达式的省略写法

在lambda表达式的标准写法基础上，可以使用省略写法的规则为：

  1. 小括号内的参数类型可以省略
  2. 如果小括号内有且仅有一个参数，则小括号可以省略
  3. 如果大括号内有且仅有一个语句，可以同时省略大括号，return 关键字及语句分号。
public class Demo05Lambda {
​
    public static void main(String[] args) {
        goStudent((String name,Integer age)->{
            return name+age+" 6666 ...";
        });
        // 省略写法
        goStudent((name,age)-> name+age+" 6666 ...");
        System.out.println("------");
        goOrder((String name)->{
            System.out.println("--->" + name);
            return 666;
        });
        // 省略写法
        goOrder(name -> {
            System.out.println("--->" + name);
            return 666;
        });
        goOrder(name ->  666);
    }
​
    public static void goStudent(StudentService studentService){
        studentService.show("张三",22);
    }
​
    public static void goOrder(OrderService orderService){
        orderService.show("李四");
    }
    
}

7.Lambda表达式的使用前提

Lambda表达式的语法是非常简洁的，但是Lambda表达式不是随便使用的，使用时有几个条件要特别注意

  1. 方法的参数或局部变量类型必须为接口才能使用Lambda
  2. 接口中有且仅有一个抽象方法(@FunctionalInterface)

8.Lambda和匿名内部类的对比

Lambda和匿名内部类的对比

  1. 所需类型不一样
    • 匿名内部类的类型可以是 类，抽象类，接口
    • Lambda表达式需要的类型必须是接口
  2. 抽象方法的数量不一样
    • 匿名内部类所需的接口中的抽象方法的数量是随意的
    • Lambda表达式所需的接口中只能有一个抽象方法
  3. 实现原理不一样
    • 匿名内部类是在编译后形成一个class
    • Lambda表达式是在程序运行的时候动态生成class

相关文章