Java8新特性之Lambda表达式基础语法（二）

最新推荐文章于 2024-07-13 13:55:40 发布

喜欢编程的夏先生

最新推荐文章于 2024-07-13 13:55:40 发布

阅读量495

点赞数

分类专栏： Java开发文章标签： Lambda java java8 后端

本文链接：https://blog.csdn.net/qq_39746820/article/details/124195928

版权

Java开发专栏收录该内容

187 篇文章 10 订阅

订阅专栏

Lambda 表达式语法概述

Lambda 表达式语法介绍

语法格式一：无参，无返回值，Lambda体只需一条语句

语法格式二：Lambda需要一个参数

语法格式三：Lambda只需要一个参数时，参数的小括号可以省略

语法格式四：Lambda需要两个参数，并且有返回值

语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略

语法格式六：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

①我们第一个需求是实现将给定的数字加上50

②我们第二个需求是实现获取给定数字的平方

测试类TestLambda2详细代码

Lambda 表达式语法概述

Lambda 表达式在Java 语言中引入了一个新的语法元素和操作符。这个操作符为 “ -> ” ，该操作符被称为 Lambda 操作符或剪头操作符。它将 Lambda 分为两个部分：

左侧： 指定了 Lambda 表达式需要的所有参数。

右侧： 指定了 Lambda 体，即 Lambda 表达式要执行的功能。

Lambda 表达式语法介绍

创建TestLambda2测试类进行讲解

语法格式一：无参，无返回值，Lambda体只需一条语句

代码

  //无返回值 无参数
    @Test
    public void test1() {
//        之前的做法
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello r1");
            }
        };
        r1.run();
//        Lambda表达式方式
        Runnable r2 = () -> System.out.println("hello r2");
        r2.run();
    }

输出结果

hello r1
hello r2

语法格式二：Lambda需要一个参数

代码

   @Test
    public void test2(){
//        Lambda需要一个参数
//        之前的做法
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("hello");
//        Lambda表达式
        Consumer<String> con2 = (arg)-> System.out.println(arg);
        con2.accept("world");
    }

结果

hello
world

语法格式三：Lambda只需要一个参数时，参数的小括号可以省略

//    语法格式三：Lambda只需要一个参数时，参数的小括号可以省略
    public void test(){
        Consumer<String> con3 = arg-> System.out.println(arg);
        con3.accept("world");
    }

语法格式四：Lambda需要两个参数，并且有返回值

//    语法格式四：Lambda需要两个参数，并且有返回值且是多条执行语句
    @Test
    public void test3(){
//        以前做法
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("两个参数为"+o1+" and  "+o2);
                return Integer.compare(o1,o2);
            }
        };
        System.out.println(com1.compare(1,2));
//        lambda 方式
        Comparator<Integer> com2 = (Integer a,Integer b)->{
            System.out.println("两个参数为"+a+" and  "+b);

            return Integer.compare(a,b);
        };
        System.out.println(com2.compare(2,1));
    }

结果

两个参数为1 and  2
-1
两个参数为2 and  1
1

语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略

 //    语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略
    @Test
    public void test4() {
        Comparator<Integer> com3 = (Integer a, Integer b) -> Integer.compare(a, b);
        ;
        System.out.println(com3.compare(2, 1));
    }

语法格式六：数据类型可以省略，因为可由编译器推断得出，称为“类型推断”

  //    语法格式六数据类型可以省 略，因为可由编 译器推断得出， 称为“类型推断”
    @Test
    public void test5() {
        Comparator<Integer> com4 = ( a,  b) -> Integer.compare(a, b);
        ;
        System.out.println(com4.compare(2, 1));
    }

类型推断

上述 Lambda 表达式中的参数类型都是由编译器推断得出的。Lambda 表达式中无需指定类型，程序依然可以编译，这是因为 javac 根据程序的上下文，在后台推断出了参数的类型。Lambda 表达式的类型依赖于上下文环境，是由编译器推断出来的。这就是所谓的 “ 类型推断”

函数式接口

通过上面的Lambda的语法介绍相信你已经发现了，如果接口中有多个抽象方法的话那么在使用Lambda的时候，就会懵了。所以能使用Lambda的都是函数式接口。所谓函数式接口就是接口中有且仅有一个抽象方法。从Java8开始，凡是只有一个抽象方法的接口都在其接口上加一个注解

@FunctionalInterface表示其为函数式接口。

当然了不加也是没关系的，这个注解只是一种校验，如果一个接口加了这个注解而其中有多语一个的抽象方法的时候就会报错的。

这是正确函数式接口的

这也是正确的函数式接口

由于加了注解，系统会检测到多于1个的抽象方法就会报错

Lambda的使用

需求

我们现在需要对某一个数进行操作，至于什么操作需要在具体执行的时候才会知道，那么我们可以这样做。

步骤一

创建一个函数式接口（注解可加可不加，这里我就不加了）

/**
 * @author summer
 * @date 2022-04-15  15:54
 */
public interface MyFunction {
    
    Integer getValue(int num);
}

步骤二

①我们第一个需求是实现将给定的数字加上50

在测试类TestLambda2 加入以下方法进行操作

  //操作方法
    public Integer operation(int num, MyFunction myFunction){
        return myFunction.getValue(num);
    }

//    具体实现数字+50
    @Test
    public void test6(){
//        实现将100加上50
        int result = operation(100,a->a+50);
        System.out.println(result);//150
    }

②我们第二个需求是实现获取给定数字的平方

    @Test
    public void test7() {
//        实现获取100的平法
        int result = operation(100, a -> a * a);
        System.out.println(result);//10000
    }

测试类TestLambda2详细代码

package com.csdn.test;

import com.csdn.myinterface.MyFunction;
import org.junit.Test;

import java.util.Comparator;
import java.util.function.Consumer;

/**
 * @author summer
 * @date 2022-04-15  14:57
 */
public class TestLambda2 {
    //无返回值 无参数
    @Test
    public void test1() {
//        之前的做法
        Runnable r1 = new Runnable() {
            @Override
            public void run() {
                System.out.println("hello r1");
            }
        };
        r1.run();
//        Lambda表达式方式
        Runnable r2 = () -> System.out.println("hello r2");
        r2.run();
    }


    @Test
    public void test2() {
//        Lambda需要一个参数
//        之前的做法
        Consumer<String> con1 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con1.accept("hello");
//        Lambda表达式
        Consumer<String> con2 = (arg) -> System.out.println(arg);
        con2.accept("world");
    }

    //    语法格式三：Lambda只需要一个参数时，参数的小括号可以省略
    public void test() {
        Consumer<String> con3 = arg -> System.out.println(arg);
        con3.accept("world");
    }


    //    语法格式四：Lambda需要两个参数，并且有返回值且是多条执行语句
    @Test
    public void test3() {
//        以前做法
        Comparator<Integer> com1 = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                System.out.println("两个参数为" + o1 + " and  " + o2);
                return Integer.compare(o1, o2);
            }
        };
        System.out.println(com1.compare(1, 2));
//        lambda 方式
        Comparator<Integer> com2 = (Integer a, Integer b) -> {
            System.out.println("两个参数为" + a + " and  " + b);

            return Integer.compare(a, b);
        };
        System.out.println(com2.compare(2, 1));
    }

    //    语法格式五：当 Lambda 体只有一条语句时，return 与大括号可以省略
    @Test
    public void test4() {
        Comparator<Integer> com3 = (Integer a, Integer b) -> Integer.compare(a, b);
        ;
        System.out.println(com3.compare(2, 1));
    }

    //    语法格式六数据类型可以省 略，因为可由编 译器推断得出， 称为“类型推断”
    @Test
    public void test5() {
        Comparator<Integer> com4 = (a, b) -> Integer.compare(a, b);
        ;
        System.out.println(com4.compare(2, 1));
    }

    //操作方法
    public Integer operation(int num, MyFunction myFunction) {
        return myFunction.getValue(num);
    }

    //    具体实现数字+50
    @Test
    public void test6() {
//        实现将100加上50
        int result = operation(100, a -> a + 50);
        System.out.println(result);//150
    }

    @Test
    public void test7() {
//        实现获取100的平法
        int result = operation(100, a -> a * a);
        System.out.println(result);//10000
    }

}

喜欢编程的夏先生

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java8新特性之Lambda表达式基础语法（二）

Lambda表达式是一个匿名函数，我们可以这样理解Lambda表达式：Lambda是一段可以传递的代码（能够做到将代码像数据一样进行传递）。使用Lambda表达式能够写出更加简洁、灵活的代码。并且，使用Lambda表达式能够使Java的语言表达能力得到提升。
复制链接

扫一扫