devbox
酷酷是懒虫
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

jdk1.8新特性——lambda表达式基础语法_jdk1.8的lamda表达式常用语法有哪些

作者：酷酷是懒虫 | 2024-07-05 11:44:42

赞

踩

jdk1.8的lamda表达式常用语法有哪些

目录

一、Lambda 表达式的基础语法

  • Java8中引入了一个新的操作符 “->”， 该操作符称为箭头操作符或 Lambda 操作符。
  • 箭头操作符将 Lambda 表达式拆分成两部分：
  • 左侧：Lambda 表达式的参数列表。
  • 右侧：Lambda 表达式中所需执行的功能， 即 Lambda 体。

二、使用Lambda 表达式的注意事项

  • Lambda 表达式需要“函数式接口”的支持。

三、函数式接口的理解

1、理解

  • 接口中只有一个抽象方法的接口，称为 函数式接口。
  • 可以使用注解 @FunctionalInterface 修饰,可以检查是否是函数式接口。

2、例如：Runnable接口就是一个函数式接口

在这里插入图片描述
3、例如：Consumer接口就是一个函数式接口

在这里插入图片描述
4、例如：Comparator接口就是一个函数式接口

在这里插入图片描述

四、Lambda 表达式的基础语法示例

1、基础语法一：无参数，无返回值

  • 示例代码如下：

    package com.xz.springboot_java8.day2;
/**
 * @description: Lambda 表达式的基础语法一：无参数，无返回值
 * @author: xz
 * @create: 2021-08-24 20:04
 */
public class Test1 {
    public static void main(String[] args) {
        generalMethod();
        System.out.println("==============");
        lambdaMethod();
    }

    //匿名内部类方式
    public static void generalMethod(){
        Runnable r=new Runnable() {
            @Override
            public void run() {
                System.out.println("Hello World!");
            }
        };
        r.run();
    }
    //lambda表达式方式（无参数，无返回值格式）
    public static void lambdaMethod(){
        Runnable r=()-> System.out.println("Hello Lambda!");
        r.run();
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

  • 输出结果如下：
    在这里插入图片描述

2、基础语法二：有一个参数，并且无返回值

  • 示例代码如下：

    package com.xz.springboot_java8.day2;
import java.util.function.Consumer;
/**
 * @description: Lambda 表达式的基础语法二：有一个参数，并且无返回值
 * @author: xz
 * @create: 2021-08-24 20:15
 */
public class Test2 {
    public static void main(String[] args) {
        generalMethod();
        System.out.println("--------");
        lambdaMethod();
    }

    //匿名内部类方式（有一个参数，并且无返回值）
    public static void generalMethod(){
        Consumer<String> consumer= new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("Hello World!");
    }

    //lambda表达式方式（有一个参数，并且无返回值）
    public static void lambdaMethod(){
        Consumer<String> con = (x) -> System.out.println(x);
        con.accept("Hello Lambda!");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

  • 输出结果如下：
    在这里插入图片描述

3、基础语法三：有一个参数，并且无返回值（若只有一个参数，小括号可以省略不写）

  • 示例代码如下：

    package com.xz.springboot_java8.day2;
import java.util.function.Consumer;
/**
 * @description: Lambda 表达式的基础语法三：
 *               有一个参数，并且无返回值（若只有一个参数，小括号可以省略不写）
 * @author: xz
 * @create: 2021-08-24 20:30
 */
public class Test3 {
    public static void main(String[] args) {
        generalMethod();
        System.out.println("================");
        lambdaMethod();
    }

    //匿名内部类方式（有一个参数，并且无返回值）
    public static void generalMethod(){
        Consumer<String> consumer= new Consumer<String>() {
            @Override
            public void accept(String str) {
                System.out.println(str);
            }
        };
        consumer.accept("Hello World!");
    }

    //lambda表达式方式（有一个参数，并且无返回值）
    //若只有一个参数，小括号可以省略不写
    public static void lambdaMethod(){
        Consumer<String> con = x -> System.out.println(x);
        con.accept("Hello Lambda!");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

  • 输出结果如下：
    在这里插入图片描述

4、基础语法四：有两个以上的参数，有返回值，并且 Lambda 体中有多条语句

  • 示例代码如下：
    package com.xz.springboot_java8.day2;
import java.util.Comparator;
/**
 * @description: Lambda 表达式的基础语法四：
 *                      有两个以上的参数，有返回值，并且 Lambda 体中有多条语句
 * @author: xz
 * @create: 2021-08-24 20:45
 */
public class Test4 {
    public static void main(String[] args) {
        generalMethod();
        System.out.println("=========================");
        lambdaMethod();
    }

    //匿名内部类方式（有两个以上的参数，有返回值,并且有多条语句）
    public static void generalMethod(){
        Comparator<Integer> comparator= new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("Hello World!");
                System.out.println(Integer.compare(o1, o2));
                return Integer.compare(o1,o2);
            }
        };
        comparator.compare(10,20);
    }

    //lambda表达式方式（有两个以上的参数，有返回值，并且有多条语句）
    public static void lambdaMethod(){
        Comparator<Integer> com = (x, y) -> {
 			System.out.println("Hello Lambda!");
            System.out.println(Integer.compare(x, y));
 			return Integer.compare(x, y);
 		};
       com.compare(10,20);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
  • 输出结果如下：
    在这里插入图片描述

5、基础语法五：若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写

  • 示例代码如下：
    package com.xz.springboot_java8.day2;
import java.util.Comparator;
/**
 * @description: Lambda 表达式的基础语法五：
 *                   若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
 * @author: xz
 * @create: 2021-08-24 20:58
 */
public class Test5 {
    public static void main(String[] args) {
        int a1=generalMethod();
        System.out.println(a1);

        System.out.println("=========================");

        int a2=lambdaMethod();
        System.out.println(a2);
    }

    //匿名内部类方式（有两个以上的参数，有返回值并且只有一条语句）
    public static int generalMethod(){
        Comparator<Integer> comparator= new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        return comparator.compare(10,20);
    }

    //lambda表达式方式（有两个以上的参数，有返回值并且只有一条语句)
    //若 Lambda 体中只有一条语句， return 和 大括号都可以省略不写
    public static int lambdaMethod(){
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
        return com.compare(10,20);
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
  • 输出结果如下：
    在这里插入图片描述

6、基础语法六： Lambda 表达式的参数列表的数据类型可以省略不写

  • 示例代码如下：

    package com.xz.springboot_java8.day2;
import java.util.Comparator;
/**
 * @description:  Lambda 表达式的基础语法六：
 *                  Lambda 表达式的参数列表的数据类型可以省略不写，
 *                  因为JVM编译器通过上下文推断出，数据类型，即“类型推断”
 *
 *                  示例：
 *                  (Integer x, Integer y) -> Integer.compare(x, y);
 *                  可以省略参数类型如下：
 *                  (x,y) -> Integer.compare(x, y);
 * @author: xz
 * @create: 2021-08-24 21:12
 */
public class Test6 {
    public static void main(String[] args) {
        int a1=generalMethod();
        System.out.println(a1);

        System.out.println("=========================");

        int a2=lambdaMethod();
        System.out.println(a2);
    }

    //匿名内部类方式（有两个以上的参数，有返回值并且只有一条语句）
    public static int generalMethod(){
        Comparator<Integer> comparator= new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1,o2);
            }
        };
        return comparator.compare(10,20);
    }

    //Lambda表达式的参数列表的数据类型可以省略不写
    public static int lambdaMethod(){
        //Comparator<Integer> com = (Integer x,Integer y) -> Integer.compare(x,y);
        Comparator<Integer> com = (x,y) -> Integer.compare(x, y);
        return com.compare(10,20);
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

  • 输出结果如下：
    在这里插入图片描述

五、Lambda 表达式的基础练习

习题1：调用Collections.sort()方法，通过定制排序比较两个Employee(先按年龄比，年龄相同按薪资比)，使用Lambda作为参数传递。

1、创建一个Employee 类。代码如下：

public class Employee {
    private int id;//id
    private String name;//名称
    private int age;//年龄
    private Double salary; //薪水

    public Employee() { }

    public Employee(int id, String name, int age, Double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }
    //getter、setter及toString方法此处省略
    ......
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

2、需求及测试代码如下：

public class Test1 {
    public static void main(String[] args) {
        //初始化员工数据并转成list
        List<Employee> emps = Arrays.asList(
                new Employee(1, "张三", 25, 3333.33),
                new Employee(2, "李四", 38, 5555.55),
                new Employee(3, "王五", 18, 2222.22),
                new Employee(4, "赵六", 45, 8888.88),
                new Employee(3, "xz", 18, 1111.11)
        );
        getEmployeeInfo(emps);
    }

    public static void getEmployeeInfo(List<Employee> emps){
        Collections.sort(emps,(o1,o2)->{
            if(o1.getAge() ==o2.getAge()){//年龄相同按薪资比
                return o1.getSalary().compareTo(o2.getSalary());
            }else{//按年龄比
                return  Integer.compare(o1.getAge(),o2.getAge());
            }
        });
        //遍历
        for (Employee emp : emps) {
            System.out.println(emp);
        }
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

3、运行main函数，输出结果如下：
在这里插入图片描述

习题2：
声明函数式接口，接口中声明抽象方法，public String getvalue(String str);
声明类Test2，类中编写方法使用接口作为参数，将一个字符串转成大写，并作为方法的返回值。
再将一个字符串的第2个和第4个索引位置进行截取子串。

1、声明名称为MyInterface的函数式接口，代码如下:

package com.xz.springboot_java8.day3.interfaces;
/**
 * @description: 声明函数式接口
 */
@FunctionalInterface
public interface MyInterface {
    String getvalue(String str);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

2、需求及测试代码如下：

package com.xz.springboot_java8.day3;
import com.xz.springboot_java8.day3.interfaces.MyInterface;

public class Test2 {
    public static void main(String[] args) {
        getResult();
    }
    /**
     * 获取结果方法
     */
    public static void getResult(){
        //将一个字符串转成大写
        String str1= strHandler("sdkljakdjlksa",(x) -> x.toUpperCase() );
        System.out.println(str1);

        //将字符串的第2个和第4个索引位置进行截取子串。
        String str2=strHandler("sdkljakdjlksa",(x)->x.substring(2,5));
        System.out.println(str2);
    }
    /**
     * 声明类Test2，类中编写方法使用接口作为参数，并作为方法的返回值。
     * @return
     */
    public static String strHandler(String str, MyInterface myInterface){
        return myInterface.getvalue(str);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27

3、运行main函数，输出结果如下：
在这里插入图片描述

习题3：
声明一个带两个泛型的函数式接口，泛型类型为<T,R>， T为参数，R为返回值
接口中声明对应的抽象方法
在Test3类中声明方法，使用接口作为参数，计算两个long型参数的和
再计算两个long型参数的乘积。

1、声明名称为MyInterface2的函数式接口，泛型类型为<T,R>，代码如下:

package com.xz.springboot_java8.day3.interfaces;
/**
 * 声明函数式接口
 */
@FunctionalInterface
public interface MyInterface2<T,R> {
    public R getValue(T t1, T t2);
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

2、需求及测试代码如下：

public class Test3 {
    public static void main(String[] args) {
        getResult();
    }
    /**
     * 获取结果方法
     */
    public static void getResult(){
        long sumValue= getCompute(25l,30l,(x,y)->x+y);
        System.out.println("两数之和="+sumValue);
        long rideValue= getCompute(25l,30l,(x,y)->x*y);
        System.out.println("两数之积="+rideValue);
    }
    /**
     * 在Test3类中声明方法，使用接口作为参数，计算两个long型参数的和
     * @return
     */
    public static Long getCompute(Long l1,Long l2, MyInterface2<Long,Long> myInterface2){
        return myInterface2.getValue(l1,l2);
    }
}

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

3、运行main函数，输出结果如下：
在这里插入图片描述

六、Lambda 表达式的总结

  • 由以上示例可知，每次使用lambda表达式都需要创建函数式接口。而实际中java已经创建好了函数式接口，直接使用即可。
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/酷酷是懒虫/article/detail/790031
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号