jdk1.8新特性——lambda表达式基础语法

Posted 小志的博客

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了jdk1.8新特性——lambda表达式基础语法相关的知识，希望对你有一定的参考价值。

目录

一、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();
    }
}

  • 输出结果如下：

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!");
    }
}

  • 输出结果如下：

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!");
    }
}

  • 输出结果如下：

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);
    }
}
  • 输出结果如下：

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);
    }
}
  • 输出结果如下：

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);
    }

}

  • 输出结果如下：

五、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方法此处省略
    ......
}

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);
        }
    }
}

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);
}

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.<
以上是关于jdk1.8新特性——lambda表达式基础语法的主要内容，如果未能解决你的问题，请参考以下文章
 

 jdk1.8新特性 lambda表达式和Stream


 JDK1.8新特性-Lambda 表达式


 jdk1.8新特性——主要内容


 JAVA 8 主要新特性 ----------------JDK1.8优点概括


 JDK1.8新特性


 jdk1.8新特性之lambda表达式