JavaSE——Java8新特性：Lambda表达式

雷神乐乐

已于 2024-10-11 00:06:35 修改

阅读量232

点赞数 11

分类专栏： # JavaSE 文章标签： Java Lambda

于 2024-10-10 21:30:04 首次发布

本文链接：https://blog.csdn.net/Helen_1997_1997/article/details/130758786

版权

JavaSE 专栏收录该内容

40 篇文章 1 订阅

订阅专栏

3.当参数类型和返回值类型，是引用数据类型时

一、Lambda表达式简介

Lambda表达式是JDK8之后的特性，要使用这个表达式，要求接口中只能有一个抽象方法。可以使用@FunctionalInterface注解来标记一个函数式接口。Lambda表达式本质上是替换匿名内部类的语法，让程序员编写代码更加简单，但是Lambda表达式可读性比较差。

Lambda表达式是面向函数式编程。面向接口中的那一个唯一的抽象方法编程。

基本语法格式：

() -> {}

二、Lambda表达式实例

(一)无参无返回值

定义一个函数式接口

@FunctionalInterface
public interface MyInter {
    // 无参无返回值
    void test(); 
}

public class TestDemo {
    public static void main(String[] args) {
        // 传统写法
        MyInter myInter = new MyInterImpl() {
            @Override
            public void test() {
                System.out.println("test...");
            }
        };      
}

class MyInterImpl implements MyInter {
    @Override
    public void test() {
        System.out.println("test...");
    }
}

Lambda表达式：当方法体中只有一行代码时，可以省略{};

public class TestDemo {
    public static void main(String[] args) {
        // lambda表达式
        MyInter myInter = () -> {
            System.out.println("test...");
        };
        myInter.test(); // test...

        // lambda表达式简化：当方法体中只有一行代码时，可以省略{};
        MyInter myInter1 = () -> System.out.println("test...");
        myInter1.test(); // test...        
    }
}

调用静态方法时传入Lambda表达式：

public class TestDemo {
    public static void main(String[] args) {
        // lambda表达式简化：当方法体中只有一行代码时，可以省略{};
        MyInter myInter1 = () -> System.out.println("test...");
        myInter1.test(); // test...

        // 调用静态方法，使用lambda表达式传参
        method(()->System.out.println("test2...")).test();
        // test2...
        // test1...
    }
    public static MyInter method(MyInter myInter) {
        myInter.test();
        return () -> System.out.println("test1...");
    }
}

(二)有参无返回值

1.参数只有一个

Lambda表达式简化：参数如果只有一个，可以省略()

@FunctionalInterface
public interface MyInter {
    // 只有一个参数，无返回值
    void compareString(String str);
}

public class TestDemo1 {
    public static void main(String[] args) {
        // 匿名内部类写法
        MyInter myInter = new MyInter() {
            @Override
            public void compareString(String str) {
                System.out.println("hello".equals(str));
            }
        };
        myInter.compareString("hello"); // true


        // lambda表达式：参数名可以任意写
        MyInter myInter1 = (string) -> System.out.println("hello".equals(string));
        myInter1.compareString("hello"); // true

        // lambda表达式简化：参数如果只有一个，可以省略()
        MyInter myInter2 = str -> System.out.println("hello".equals(str));
        myInter2.compareString("hello"); // true
    }
}

2.参数有多个

@FunctionalInterface
public interface MyInter {
    // 参数有多个，无返回值
    void max(int num1, int num2);
}

public class TestDemo2 {
    public static void main(String[] args) {
        // 匿名内部类
        MyInter myInter = new MyInter() {
            @Override
            public void max(int num1, int num2) {
                System.out.println("最大值是：" + (num1 > num2 ? num1 : num2));
            }
        };
        myInter.max(10, 20); // 最大值是：20

        // lambda表达式
        MyInter myInter1 = (a, b) -> System.out.println("最大值是：" + (a > b ? a : b));
        myInter1.max(11, 12); // 最大值是：12
    }
}

(三)有参有返回值

1.有一个参数

如果{}中只有一条语句，可以省略{}和return

@FunctionalInterface
public interface MyInter {
    // 有一个参数，有返回值
    boolean compareStr(String str);
}

public class TestDemo3 {
    public static void main(String[] args) {
        // 匿名内部类
        MyInter myInter = new MyInter() {
            @Override
            public boolean compareStr(String str) {
                return "world".equals(str);
            }
        };

        System.out.println(myInter.compareStr("world"));

        // lambda表达式
        MyInter myInter1 = str -> {
            return "world".equals(str);
        };
        System.out.println(myInter1.compareStr("world"));

        // 简化：如果{}中只有一条语句，可以省略{}和return
        MyInter myInter2 = str -> "world".equals(str);
        System.out.println(myInter2.compareStr("world"));

        // 简化：方法引用
        MyInter myInter3 = "world"::equals;
        System.out.println(myInter3.compareStr("world"));
    }
}

2.有多个参数

重写的方法的形参数量，和形参类型和返回值类型，与已有的方法的相同，那么可以使用方法引用。

@FunctionalInterface
public interface MyInter {
    // 有多个参数，有返回值
     int max(int a,int b);
}

public class TestDemo5 {
    public static void main(String[] args) {
        // 匿名内部类
        MyInter myInter = new MyInter() {
            @Override
            public int max(int a, int b) {
                return a > b ? a : b;
            }
        };
        System.out.println(myInter.max(1, 5));

        // lambda表达式
        MyInter myInter1 = (a, b) -> a > b ? a : b;
        System.out.println(myInter1.max(2, 5));

        // 重写的方法的形参数量,和形参类型和返回值类型,与已有的方法的相同，那么可以使用以下写法：
        MyInter myInter2 = Math::max;
        System.out.println(myInter2.max(10, 5));
    }
}

3.当参数类型和返回值类型，是引用数据类型时

可以使用类名::非静态方法

@FunctionalInterface
public interface MyInter {
    // 当参数类型和返回值类型，是引用数据类型时
    Object getPropertyNameValue(Teacher teacher);
}

定义一个Teacher类：

public class Teacher {
    private String name;

    private int 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 Teacher(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

public class TestDemo6 {
    public static void main(String[] args) {
        // 匿名内部类
        MyInter myInter = new MyInter() {
            @Override
            public Object getPropertyNameValue(Teacher teacher) {
                return teacher.getName();
            }
        };

        Teacher teacher = new Teacher("张三",32);
        System.out.println(myInter.getPropertyNameValue(teacher)); // 张三


        // lambda表达式
        MyInter myInter1 = (teacher1) -> {
            return teacher1.getName();
        };
        System.out.println(myInter1.getPropertyNameValue(teacher)); // 张三

        // 简化
        MyInter myInter2 = (teacher1) -> teacher1.getAge();
        System.out.println(myInter2.getPropertyNameValue(teacher)); // 32

        // 方法引用：
        MyInter myInter3 = Teacher::getName;
        System.out.println(myInter3.getPropertyNameValue(teacher)); // 张三

        MyInter myInter4 = Teacher::getAge;
        System.out.println(myInter4.getPropertyNameValue(teacher)); // 32
    }
}