学习笔记之Lambda表达式

Lambda表达式

函数式编程：

函数：

• 函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”面向对象思想强调“必须通过对象的形式来做事情”
  函数式思想：
• 尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”，Lambda表达式就是函数思想的体现

例1：

需求：启动一个线程，在控制太输出一句话：多线程程序启动了
方式一：

public class Demo {
    public static void main(String[] args) {
        MyRunnable mr = new MyRunnable();
        Thread t = new Thread(mr);
        t.start();
    }
}

public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("多线程程序启动了");
    }
}

方式二：

• 匿名内部类

public class Demo {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了");
            }
        }).start();
    }
}

方式三：

• Lambda表达式:

public class LambdaDemo {
    public static void main(String[] args) {
        new Thread(() -> {
            System.out.println("多线程程序启动了");
        }).start();
    }
}

Lambda标准格式：

匿名内部类中重写run()方法的代码分析

new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了");
            }
        }).start();

• 方法形式参数为空，说明调用方法时不需要传递参数
• 方法返回值为void,说明方法执行没有结果返回
• 方法体中的内容，时我们具体要做的事情

Lambda表达式的代码分析

 new Thread(() -> {
            System.out.println("多线程程序启动了");
        }).start();

• ():里面没有内容，可以看成是方法形式为空
• ->:用箭头指向后面要做的事情
• {}:包含一段代码，我们称之为代码块，可以看成是方法体中的内容

Lambda表达式的三要素：形式参数，箭头，代码块
Lambda表示的格式

• 格式：(形式参数) -> {代码块}
• 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空
• ->:由英文中画线和大于符号组成，固定写法，代表指向性动作
• 代码块：具体要做的事情，也就是之前写方法体的内容

练习

Lambda表达式的使用前提：

• 有一个接口
• 接口中有且只有一个抽象方法

练习一：

• 定义一个接口(Eatable),里面定义一个抽象方法:void eat():
• 定义一个测试类(Demo),在测试类中提供两个方法
  • 一个方法是:useEatable(Eatable e)
  • 一个方法是主方法，在主方法中调用useEatable方法

public interface Eatable {
     void eat();
}


public class Demo {
    public static void main(String[] args) {
        useEatable(() -> {
            System.out.println("Hello,World");
        });

    }
    private static void useEatable(Eatable e){
        e.eat();
    }
}

练习二：

• 定义一个接口(Flyable),里面定义一个抽象方法:void fly(String s):
• 定义一个测试类(Demo),在测试类中提供两个方法
  • 一个方法是:useEatable(Flyable f)
  • 一个方法是主方法，在主方法中调用useFlyable方法

public interface Flyable {
    void fly(String s);
}


public class Demo {

    public static void main(String[] args) {

        //匿名内部类：
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("风和日丽");
            }
        });
        System.out.println("---------------");
        //Lambda表达式
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("风和日丽");
        });
    }
    private static void useFlyable(Flyable f){
        f.fly("晴空万里");
    }
}

练习三：

• 定义一个接口(Addable),里面定义一个抽象方法:int add(int x, int y)
• 定义一个测试类(Demo),在测试类中提供两个方法
  • 一个方法是:useAddable(Addable a)
  • 一个方法是主方法，在主方法中调用useAddable方法

public interface Addable {
    int add(int x, int y);
}

public class Demo {
    public static void main(String[] args) {
        //匿名内部类

        useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x + y;
            }
        });
        System.out.println("------------");
        
        //Lambda表达式
        useAddable((int x, int y) -> {
            return x + y;
        });
    }

    private static void useAddable(Addable a) {
        int sum = a.add(3, 4);
        System.out.println(sum);
    }
}

Lambda省略模式

public class Demo {
    public static void main(String[] args) {
        //无省略
        useAddable((int x, int y) -> {
            return x + y;
        });

        useFlyable((String s) -> {
            System.out.println(s);
        });

        System.out.println("------------");
        //参数类型省略
        useAddable((x, y) -> {
            return x + y;
        });

        useFlyable(s -> {
            System.out.println(s);
        });
        System.out.println("----------------");
        //若代码块有且只有一条语句，可以省略大括号和分号，若有return语句也要省略return；
        useAddable((x, y) -> x + y);

        useFlyable(s -> System.out.println(s));

    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 30);
        System.out.println(sum);
    }

    private static void useFlyable(Flyable f) {
        f.fly("阳光明媚，风和日丽");
    }
}

学习笔记之Lambda表达式

原文：https://www.cnblogs.com/Hz-z/p/13052347.html