• 技术文章 >Java >Java基础

    介绍Java8语法糖之Lambda表达式

    coldplay.xixicoldplay.xixi2021-02-18 18:09:05转载189

    免费学习推荐:java基础教程

    一、Lambda表达式简介

    Lambda表达式,是Java8的一个新特性,也是Java8中最值得学习的新特性之一。(另一个新特性是流式编程。)

    @FunctionalInterface注解 ,用在接口之前,用来判断接口是否是一个函数式接口。如果不是函数式接口会报错。功能类似于@Override。

    二、Lambda表达式语法

    lambda表达式本质上是一个匿名方法,因此再写lambda表达式时,不需要关心方法名是什么,也不需要关心返回值类型。只需要关心两部分:参数列表方法体

    Lambda表达式基础语法:(参数) ->{
    	方法体}

    下面定义6种参数和返回值各不相同的函数式接口,分别使用lambda表达式对接口中的方法进行实现:

    在这里插入图片描述

    下面是针对上面6种函数式接口的lambda表达式实现。

    /**
     * @Description:
     * @author Guoqianliang
     * @date 19:50 - 2021/2/15
     */public class BasicSyntax {
        public static void main(String[] args) {
            // 1.实现无参数,无返回值的函数式接口
            NoneReturnNoneParameter lambda1 = () -> {
                System.out.println("这是无参,无返回值的方法");
            };
            lambda1.test();
    
            // 2.实现一个参数,无返回值的函数式接口
            NoneReturnSingleParameter lambda2 = (int a) -> {
                System.out.println("这是一个参数,无返回值的方法,参数a:" + a);
            };
            lambda2.test(10);
    
            // 3.实现多个参数,无返回值的函数式接口
            NoneReturnMutipleParameter lambda3 = (int a, int b) -> {
                System.out.println("这是多个参数,无返回值的方法,参数a=" + a + ",b=" + b);
            };
            lambda3.test(10, 20);
    
            // 4.实现无参数,有返回值有返回值的函数式接口
            SingleReturnNoneParameter lambda4 = () -> {
                System.out.println("这是无参数,有返回值的方法,返回值是:");
                return 10;
            };
            System.out.println(lambda4.test());
    
            // 5.实现一个参数,有返回值的函数式接口
            SingleReturnSingleParameter lambda5 = (int a) -> {
                System.out.println("这是一个参数,有返回值的方法,返回值是:");
                return a;
            };
            System.out.println(lambda5.test(10));
    
            // 6.实现多个参数,有返回值的函数式接口
            SingleReturnMutipleParameter lambda6 = (int a, int b) -> {
                System.out.println("这是多个参数,有返回值的方法,返回值是:");
                return a + b;
            };
            System.out.println(lambda6.test(1, 2));
        }}

    语法精简进阶:

    三、函数引用

    lambda表达式是为了简化接口。在lambda表达式中,不应该出现比较复杂的逻辑。如果需要处理的逻辑比较复杂,一般情况会单独写一个方法。在lambda表达式中直接引用这个方法即可。即引用一个已经存在的方法,使其代替lambda表达式完成接口的实现。

    1.静态方法引用

    语法:类::静态方法

    • 在引用的方法后面,不要添加小括号。
    • 引用的这个方法,参数(数量、类型)和返回值,必须要跟接口中定义的一致。
    /**
     * @Description: 方法引用
     * @author Guoqianliang
     * @date 0:26 - 2021/2/16
     */public class Lambda1 {
    
        private static interface Calculate {
            int calculate(int a, int b);
        }
    
        private static int calculate(int x, int y) {
            if (x > y) {
                return x - y;
            } else if (x < y) {
                return y - x;
            }
            return x + y;
        }
    
        public static void main(String[] args) {
            // 静态方法引用
            Calculate calculate = Lambda1::calculate;
            System.out.println(calculate.calculate(10, 20));
        }}

    2.非静态方法引用

    语法:对象::非静态方法

    • 在引用的方法后面,不要添加小括号。
    • 引用的这个方法,参数(数量、类型)和返回值,必须要跟接口中定义的一致。
    /**
     * @Description: 方法引用
     * @author Guoqianliang
     * @date 0:26 - 2021/2/16
     */public class Lambda1 {
    
        private static interface Calculate {
            int calculate(int a, int b);
        }
    
        // 非静态方法
        private int calculate2(int a, int b) {
            if (a != b) {
                return a - b;
            }
            return a + b;
        }
    
        public static void main(String[] args) {
            // 非静态方法引用
            Calculate calculate2 = new Lambda1()::calculate2;
            System.out.println(calculate.calculate(10, 20));
        }}

    3.构造方法引用

    语法:类名::new

    • 可以通过接口中的方法的参数,区分引用不同的构造方法。
    • 如果某一个函数式接口中定义的方法,仅仅是为了得到一个类的对象。此时就可以使用构造方法的引用,简化这个方法的实现。
    /**
     * @Description: 构造方法引用
     * @author Guoqianliang
     * @date 11:20 - 2021/2/16
     */public class Lambda2 {
    
        @FunctionalInterface
        private interface GetPersonWithNoneParameter {
            Person get();
        }
    
        @FunctionalInterface
        private interface GetPersonWithSingleParameter {
            Person get(String name);
        }
    
        @FunctionalInterface
        private interface GetPersonWithMutipleParameter {
            Person get(String name, int age);
        }
    
        private static class Person {
            String name;
            int age;
    
            public Person() {
                System.out.println("Person类的无参构造方法执行了");
            }
    
            public Person(String name) {
                this.name = name;
                System.out.println("Person类的有参构造方法执行了");
            }
    
            public Person(String name, int age) {
                this.name = name;
                this.age = age;
                System.out.println("Person类的两个参数的构造方法执行了");
            }
        }
    
        public static void main(String[] args) {
            // 1.使用lambda表达式,实现GetPersonWithNoneParameter接口
            GetPersonWithNoneParameter getPerson = Person::new;
            // 2.使用lambda表达式,实现GetPersonWithSingleParameter接口
            GetPersonWithSingleParameter getPerson2 = Person::new;
            // 3.使用lambda表达式,实现GetPersonWithMutipleParameter接口
            GetPersonWithMutipleParameter getPerson3 = Person::new;
    
            System.out.println(getPerson.get());
            System.out.println(getPerson2.get("树先生"));
            System.out.println(getPerson3.get("你好", 23));
        }}

    4.对象方法的特殊引用

    使用lambda表达式实现某些接口时,如果lambda表达式中包含了某一个对象,此时方法体中,直接使用这个对象调用它的某一个方法就可以完成整体的逻辑。

    /**
     * @Description: 对象方法的特殊应用
     * @author Guoqianliang
     * @date 11:54 - 2021/2/16
     */public class Lambda3 {
    
        @FunctionalInterface
        private interface MyInterface {
            // String get(Person person);
            void set(Person person, String name);
        }
    
        private static class Person {
            private String name;
    
            public void setName(String name) {
                this.name = name;
            }
    
            public String getName() {
                return name;
            }
        }
    
        public static void main(String[] args) {
            Person p1 = new Person();
            p1.setName("小明");//        逻辑实现只是为了获取到对象的名字//        MyInterface lambda2 = Person::getName;//        System.out.println(lambda2.get(p1));
            
            // 逻辑实现只是为了给对象的某些属性进行赋值
            MyInterface lambda1 = (x, n) -> x.setName(n);
            MyInterface lambda2 = Person::setName;
            lambda2.set(p1, "李华");
            System.out.println(p1.getName());
        }}

    四、Lambda表达式需要注意的问题

    如果用到局部变量,默认会被声明为常量,不能发生值的改变。

    /**
     * @Description:
     * @author Guoqianliang
     * @date 13:05 - 2021/2/16
     */public class Lambda4 {
        public static void main(String[] args) {
            // 1.定义一个局部变量
            int x = 10;
            // 2.使用lambda表达式实现接口
            LambdaTest lambda = () -> {
                System.out.println("x=" + x);
            };
            // 3. 无法修改常量x
            // x=20;
        }}@FunctionalInterfaceinterface LambdaTest {
        void test();}

    相关学习推荐:java基础

    以上就是介绍Java8语法糖之Lambda表达式的详细内容,更多请关注php中文网其它相关文章!

    本文转载于:CSDN,如有侵犯,请联系a@php.cn删除
    专题推荐:Java8 Lambda
    上一篇:Java介绍八锁问题带你彻底理解对象锁和类锁 下一篇:java如何连接sqlserver数据库
    第15期线上培训班

    相关文章推荐

    • python lambda函数如何使用• python中的lambda是什么意思• Java8新特性的lambda,函数式接口,StreamingAPI• 关于java中的Lambda表达式的详细介绍• java使用lambda表达式对List对象集合的某个属性进行排序

    全部评论我要评论

  • 取消发布评论发送
  • 1/1

    PHP中文网