Lambda表达式

最新推荐文章于 2023-08-08 14:13:58 发布

s0cket

最新推荐文章于 2023-08-08 14:13:58 发布

阅读量288

点赞数

分类专栏： java 文章标签： java 开发语言

本文链接：https://blog.youkuaiyun.com/s0cket/article/details/123443775

版权

java 专栏收录该内容

25 篇文章

订阅专栏

本文介绍了Lambda表达式的基本概念和使用方法，包括两种编程思想的对比、Lambda的标准格式以及如何使用Lambda创建多线程。通过示例展示了Lambda在无参无返回值和有参数有返回值情况下的应用，如创建线程、数组排序以及实现计算接口。总结了Lambda表达式的语法糖特性，如参数类型和代码块的省略，并强调了其在简化代码和提高可读性方面的优势。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

Lambda表达式

文章目录

- - Lambda表达式

一、基本概念

1、两种编程思想

面向对象：做一件事，找一个能解决这个事情的对象，调用对象的方法，完成事情

函数式编程：只要能获取到结果就行，不管谁去做，怎么做，注重结果，不看过程

2、Lambda表达式的标准格式

使用Runnable接口的实现类来创建多线程

/*
    创建Runnable接口的实现类，重写run方法，设置线程任务
 */
public class RunnableImpl implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName()+"新的线程创建了");
    }
}

public class Demo01Runnable {
    public static void main(String[] args) {
        // 第一种方法，创建Runnable接口的实现类对象
        Runnable run = new RunnableImpl();
        Thread t = new Thread(run);
        t.start();

        // 第二种方法,使用匿名内部类
        Runnable r = new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新的线程创建了");
            }
        };
        new Thread(r).start();

        // 第三种方法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"新的线程创建了");
            }
        }).start();
    }
}

匿名内部类的好处和弊端：省去了类的定义，但语法太复杂了

使用Runnable接口的实现类来创建多线程的方式，有很多冗余的代码，我们并不是真的希望创一个匿名内部类对象，我们真正想做的是传递一行代码（run方法中的）。JDK1.8之后，Lambda表达式的重量级特性，为我们打开了新世界的大门。

使用Lambda的标准方式创建多线程

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

Lambda表达式的标准格式

三部分组成，参数、箭头、一段代码。

格式：(参数列表)->{一些重写方法的代码};

():接口中抽象方法的参数列表，没有参数就是空的，有参数就写出参数

->:传递的意思，把参数传递给方法体

{}:重写接口的抽象方法的方法体

二、Lambda表达式使用

1、Lambda标准格式（无参无返回值）

练习：Lambda标准格式（无参无返回值）
给定一个厨子Cook接口，内含唯一的抽象方法makeFood，无参数无返回值。使用Lambda的标准格式调用invokeCook方法，打印输出"吃饭啦！"字样。

// Cook接口，定义了一个方法
public interface Cook {
    void makeFood();
}

public class Demo01Cook {
    public static void main(String[] args) {
        // 匿名内部类方式
        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、Lambda标准格式（有参数有返回值）

练习1：
使用数组存储多个Person对象，对数组中的Person对象使用Arrays.sort方法通过年龄进行升序排序。

// 自定义Person类
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + 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 class Demo01Array {
    public static void main(String[] args) {
        // 创建数组
        Person[] arr = {
                new Person("迪丽热巴",22),
                new Person("古力娜扎",18),
                new Person("赵老师",23)
        };
        // 匿名内部类方式进行排序
/*        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();
        });
        */
        // Lambda的简化方式
        Arrays.sort(arr, (o1, o2) -> o1.getAge()-o2.getAge());

        // 遍历数组，打印数组元素
        for (int i = 0; i < arr.length; i++) {
            System.out.println(arr[i]);
        }
    }
}

上述代码使用了匿名内部类、Lambda表达式的标准格式以及简化方式实现了排序。

练习2：

给定一个计算器Calculator接口，内含抽象方法calc可以将两个int数字相加得到和值。使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算。

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

public class Demo01Calculator {
    public static void main(String[] args) {
        // 使用Lambda的标准格式调用invokeCalc方法，完成120和130的相加计算
        invokeCalc(120, 130, (int a, int b) ->{
                return a + b;
        });

        // 使用Lambda的简化格式计算12+13
        invokeCalc(12,13,(a,b)-> a+b);
    }
    /*
        定义一个方法
        参数传递两个int类型的整数
        参数传递Calculator接口
     */

    public static void invokeCalc(int a,int b,Calculator c){
        int sum = c.calc(a,b);
        System.out.println(sum);
    }
}