Java8新特性之Lambda表达式的使用

1. lambda表达式介绍

lambda表达式是Java8提供的新特性之一,也可以称之为闭包;它支持Java能够进行简单的函数式编程,也就是说可以把一个匿名函数作为一个方法的参数进行传递;其格式分为三部分,第一部分为入参列表,第二部由->固定组成,第三部分为方法体;

public class LambdaTest {

    public static void main(String[] args) {
        // 使用lambda表达式创建线程
        Thread thread = new Thread(() -> {
            System.out.println("thread running");
        });
        thread.start();
    }
}

// 运行结果
thread running

2. lambda表达式的重要特征

可选的参数类型声明:不需要声明参数的类型,编译器可以统一识别参数值;

public class LambdaTest {

    private Integer a;

    public LambdaTest(Integer a) {
        this.a = a;
    }

    public void print(LambdaInterface lambdaInterface) {
        lambdaInterface.print(this.a);
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123);
        // 声明参数类型
        System.out.println("声明参数类型");
        lambdaTest.print((Integer a) -> {
            System.out.println("a: " + a);
        });
        // 不声明参数类型
        System.out.println("不声明参数类型");
        lambdaTest.print((a) -> {
            System.out.println("a: " + a);
        });
    }
}

interface LambdaInterface {
    void print(Integer a);
}

// 运行结果
声明参数类型
a: 123
不声明参数类型
a: 123

可选的参数圆括号:一个参数时不需要定义圆括号,但没有参数或者多个参数时则必须要定义;

public class LambdaTest {

    private Integer a;

    public LambdaTest(Integer a) {
        this.a = a;
    }

    public void print(LambdaInterface lambdaInterface) {
        lambdaInterface.print(this.a);
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123);
        // 定义参数圆括号
        System.out.println("定义参数圆括号");
        lambdaTest.print((a) -> {
            System.out.println("a: " + a);
        });
        // 一个参数可不定义参数圆括号
        System.out.println("一个参数可不定义参数圆括号");
        lambdaTest.print(a -> {
            System.out.println("a: " + a);
        });
    }
}

interface LambdaInterface {
    void print(Integer a);
}

// 运行结果
定义参数圆括号
a: 123
一个参数可不定义参数圆括号
a: 123

可选的大括号:如果方法体仅有一个语句,可不需要使用大括号;

public class LambdaTest {

    private Integer a;

    public LambdaTest(Integer a) {
        this.a = a;
    }

    public void print(LambdaInterface lambdaInterface) {
        lambdaInterface.print(this.a);
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123);
        // 使用方法体大括号
        System.out.println("使用方法体大括号");
        lambdaTest.print(a -> {
            System.out.println("a: " + a);
        });
        // 一个语句可不使用方法体大括号
        System.out.println("一个语句可不使用方法体大括号");
        lambdaTest.print(a -> System.out.println("a: " + a));
    }
}

interface LambdaInterface {
    void print(Integer a);
}

// 运行结果
使用方法体大括号
a: 123
一个语句可不使用方法体大括号
a: 123

可选的返回关键字:如果方法体仅有一个表达式返回值语句,可不需要声明返回关键字,但存在大括号时则必须声明;

public class LambdaTest {

    private Integer a;
    private Integer b;

    public LambdaTest(Integer a, Integer b) {
        this.a = a;
        this.b = b;
    }

    public Integer sum(LambdaInterface lambdaInterface) {
        return lambdaInterface.calculate(this.a, this.b);
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123, 456);
        // 声明返回关键字
        System.out.println("声明返回关键字");
        Integer s1 = lambdaTest.sum((Integer a, Integer b) -> {
            return a + b;
        });
        System.out.println(s1);
        // 一个表达式返回值语句可不声明返回关键字
        System.out.println("一个表达式返回值语句可不声明返回关键字");
        Integer s2 = lambdaTest.sum((a, b) -> a + b);
        System.out.println(s2);
    }
}

interface LambdaInterface {
    Integer calculate(Integer a, Integer b);
}

// 运行结果
声明返回关键字
579
一个表达式返回值语句可不声明返回关键字
579

3. lambda表达式对域外变量的限制

lambda表达式对域外的局部变量具有隐性final语义的限制,但对成员变量没有该限制;

public class LambdaTest {

    private Integer a;
    private Integer b;

    public LambdaTest(Integer a, Integer b) {
        this.a = a;
        this.b = b;
    }

    public Integer sum(LambdaInterface lambdaInterface) {
        return lambdaInterface.calculate(this.a, this.b);
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123, 456);
        int c = 111;
        Integer s1 = lambdaTest.sum((a, b) -> {
            // 修改域外局部变量将出现编译错误
            c = 222;
            return a + b;
        });
        System.out.println(s1);

        int d = 333;
        Integer s2 = lambdaTest.sum((a, b) -> {
            // 域外修改lambda表达式内部使用过的域外局部变量也将导致编译错误
            return a + b + d;
        });
        d = 444;
        System.out.println(s2);
    }
}

interface LambdaInterface {
    Integer calculate(Integer a, Integer b);
}
public class LambdaTest {

    private Integer a;
    private Integer b;
    private Integer c;

    public LambdaTest(Integer a, Integer b, Integer c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public Integer sum(LambdaInterface lambdaInterface) {
        return lambdaInterface.calculate(this.a, this.b);
    }

    public static void main(String[] args) {
        LambdaTest lambdaTest = new LambdaTest(123, 456, 789);
        Integer s1 = lambdaTest.sum((a, b) -> {
            // 没有出现编译错误
            lambdaTest.c = 999;
            return a + b + lambdaTest.c;
        });
        System.out.println(s1);
    }
}

interface LambdaInterface {
    Integer calculate(Integer a, Integer b);
}

// 运行结果
1578

4. lambda表达式的优缺点

优点:

1.使代码更加简洁;

2.减少匿名内部类的创建,节省资源;

缺点:

1.可维护性差,必须熟悉抽象方法的参数列表;

2.可读性差,必须对lambda表达式有一定深入;

5. lambda表达式的使用场景

在声明方法时,方法的形参列表包含一个或者多个函数式接口就可以使用lambda表达式;如:

使用实现Runnable接口创建线程

使用实现Callable接口创建FutureTask

使用四大函数式接口消费者接口Consumer提供者接口Supplier断言型接口Predicate函数型接口Function

6. lambda表达式的实现原理

lambda表达式是通过特定的语法,让编译器对java文件进行编译时,针对每一个lambda表达式会编译成一个对应的静态方法,由此也可证明lambda表达式并不是一种语法糖;

// 对上面的LambdaTest.java编译后的LambdaTest.class文件使用javap -p进行查看将会得到如下结果
javap -p LambdaTest.class
Compiled from "LambdaTest.java"
public class cn.jackiegu.java8.study.lambda.LambdaTest {
  private java.lang.Integer a;
  private java.lang.Integer b;
  private java.lang.Integer c;
  public cn.jackiegu.java8.study.lambda.LambdaTest(java.lang.Integer, java.lang.Integer, java.lang.Integer);
  public java.lang.Integer sum(cn.jackiegu.java8.study.lambda.LambdaInterface);
  public static void main(java.lang.String[]);
  private static java.lang.Integer lambda$main$0(cn.jackiegu.java8.study.lambda.LambdaTest, java.lang.Integer, java.lang.Integer);
}

到此这篇关于Java8新特性之Lambda表达式的使用的文章就介绍到这了,更多相关java的Lambda表达式内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • Java lambda 循环累加求和代码

    java 8 stream 提供了下面几种类型的求和 Stream::mapToInt Stream::mapToDouble Stream::mapToLong public void test() { List<Person> people = new ArrayList<>(); people.add(new Person("zhangsan",20)); people.add(new Person("lisi", 26)); peop

  • Java8 Lambda表达式模板方法实现解析

    Java注解提供了关于代码的一些信息,但并不直接作用于它所注解的代码内容.在这个教程当中,我们将学习Java的注解,如何定制注解,注解的使用以及如何通过反射解析注解. Java1.5引入了注解,当前许多java框架中大量使用注解,如Hibernate.Jersey.Spring.注解作为程序的元数据嵌入到程序当中.注解可以被一些解析工具或者是编译工具进行解析.我们也可以声明注解在编译过程或执行时产生作用. 在使用注解之前,程序源数据只是通过java注释和javadoc,但是注解提供的功能要远远超

  • java中lambda表达式的分析与具体用法

    Lamda表达式 λ 希腊字母表中排序第十一位字母,英语名称为Lambda 避免匿名内部类定义过多 其实质属于函数式 编程的概念 (params)->expression[表达式] (params)->statement[语句] (params)->{statements} (a-> System.out.print("i like lambda–>"+a)); new Thread (()->System.out.println("多线程

  • java 8 lambda表达式中的异常处理操作

    简介 java 8中引入了lambda表达式,lambda表达式可以让我们的代码更加简介,业务逻辑更加清晰,但是在lambda表达式中使用的Functional Interface并没有很好的处理异常,因为JDK提供的这些Functional Interface通常都是没有抛出异常的,这意味着需要我们自己手动来处理异常. 因为异常分为Unchecked Exception和checked Exception,我们分别来讨论. 处理Unchecked Exception Unchecked exc

  • Java8的Lambda表达式你真的会吗

    理解Lambda Lambda表达式可以是一段可以传递的代码,它的核心思想是将面向对象中的传递数据变成传递行为,也就是行为参数化,将不同的行为作为参数传入方法. 随着函数式编程思想的引进,Lambda表达式让可以用更加简洁流畅的代码来代替之前冗余的Java代码. 口说无凭,直接上个例子吧.在Java8之前,关于线程代码是这样的: class Task implements Runnable{ @Override public void run() { System.out.println("Ja

  • Java lambda list转换map时,把多个参数拼接作为key操作

    我就废话不多说了,大家还是直接看代码吧~ Map<String, Parts> partsMap = synList.stream().collect(Collectors.toMap(k -> k.getOe()+k.getOeId()+k.getPartGroupId()+k.getStdPartId()+k.getBrandCode(), part -> part)); 补充知识:Java8 Collectors.toMap的两个大坑 Collectors.toMap()方法

  • 使用Java 8 Lambda表达式将实体映射到DTO的操作

    当我们需要将DTO转换为实体(Hibernate实体等)并向后转换时,我们都会面临混乱的开销代码. 在我的示例中,我将用Java 8演示代码如何变得越来越短. 让我们创建目标DTO: public class ActiveUserListDTO { public ActiveUserListDTO() { } public ActiveUserListDTO(UserEntity userEntity) { this.username = userEntity.getUsername(); ..

  • Java8如何使用Lambda表达式简化代码详解

    系统环境: Java JDK 版本:1.8 参考地址: Java 8 Lambda 表达式 Jdk 8 新特性 04 方法引用与构造器引用 Java 8 新特性:Lambda 表达式之方法引用 一.Lambda 表达式简介 1.什么是 Lambda 表达式 Lambda 表达式是在 JDK 8 中引入的一个新特性,可用于取代大部分的匿名内部类.使用 Lambda 表达式可以完成用少量的代码实现复杂的功能,极大的简化代码代码量和代码结构.同时,JDK 中也增加了大量的内置函数式接口供我们使用,使得

  • java lambda 表达式中的双冒号的用法说明 ::

    双冒号运算就是Java中的[方法引用],[方法引用]的格式是 类名::方法名 注意是方法名哦,后面没有括号"()"哒.为啥不要括号,因为这样的是式子并不代表一定会调用这个方法.这种式子一般是用作Lambda表达式,Lambda有所谓懒加载嘛,不要括号就是说,看情况调用方法. 例如 表达式: person -> person.getAge(); 可以替换成 Person::getAge 表达式 () -> new HashMap<>(); 可以替换成 HashMa

  • 详解Java8中的lambda表达式、::符号和Optional类

    Java8中的lambda表达式.::符号和Optional类 0. 函数式编程 函数式编程(Functional Programming)属于编程范式(Programming Paradigm)中的用语,此外还有命令式编程(Imperative Programing)等,有兴趣的同学可以自行了解,我们这里大概解释一下函数式编程,在函数式编程中,输入一旦确定了,输出都确定了,函数调用的结果只依赖于传入的输入变量和内部逻辑,不依赖于外部,这样的写出的函数没有副作用.举个例子: public cla

  • Java8语法糖之Lambda表达式的深入讲解

    一.Lambda表达式简介 Lambda表达式,是Java8的一个新特性,也是Java8中最值得学习的新特性之一.(另一个新特性是流式编程.) Lambda表达式,从本质上讲是一个匿名方法.可以使用这个匿名方法,实现接口中的方法. 功能:通常使用Lambda表达式,是为了简化接口实现的.关于接口实现可以有多种方式实现,例如:①设计接口的实现类.②使用匿名内部类.但是③使用lambda表达式,比这两种方式都简单. 要求:lambda表达式,只能实现函数式接口:即一个接口中,要求实现类必须实现的抽象

  • Java8新特性:Lambda表达式之方法引用详解

    1.方法引用简述 方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法.方法引用提供了一种引用而不执行方法的方式,它需要由兼容的函数式接口构成的目标类型上下文.计算时,方法引用会创建函数式接口的一个实例. 当Lambda表达式中只是执行一个方法调用时,不用Lambda表达式,直接通过方法引用的形式可读性更高一些.方法引用是一种更简洁易懂的Lambda表达式. Lambda表达式全文详情地址:http://blog.csdn.net/sun_promise/article/details/

  • java8 多个list对象用lambda求差集操作

    业务场景:调用同步接口获取当前全部有效账户,数据库已存在部分账户信息,因此需要筛选同步接口中已存在本地的帐户. 调用接口获取的数据集合 List<AccountVo> list = response.getData().getItems(); 本地查询出来的账户集合 List<Account> towList = accountRepository.findAll(); 筛选差集代码 List<AccountVo> distinctByUniqueList = list

  • java8 forEach结合Lambda表达式遍历 List操作

    我就废话不多说了,大家还是直接看代码吧~ @Test void testJava8ForeachMap() { Map<String, Integer> items = new HashMap<>(); items.put("A", 10); items.put("B", 20); items.put("C", 30); items.put("D", 40); items.put("E&quo

  • Java8 lambda表达式2种常用方法代码解析

    与python不一样,python lambda是定义匿名函数,而在java8中lambda是匿名内部类 例1.用lambda表达式实现Runnable 我开始使用Java 8时,首先做的就是使用lambda表达式替换匿名类,而实现Runnable接口是匿名类的最好示例.看一下Java 8之前的runnable实现方法,需要4行代码,而使用lambda表达式只需要一行代码.我们在这里做了什么呢?那就是用() -> {}代码块替代了整个匿名类. // Java 8之前: new Thread(ne

  • 详解Java8中的Lambda表达式

    Lambda是什么 Lambda表达式,也可称为闭包,是java8的新特性,作用是取代大部分内部类,优化java代码结构,让代码变得更加简洁紧凑. Lambda的基本语法 (expression)->expression 或 (expression)->{statements;} Lambda最重要特点 用()->{}代码块替代匿名内部类 //(param)->expression;//(param)->statment;//(param)->{statments};/

  • java lambda循环_使用Java 8 Lambda简化嵌套循环操作

    java lambda循环 对于每个经常需要在Java 8(或更高版本)中使用多维数组的人来说,这只是一个快速技巧. 在这种情况下,您可能经常会以类似于以下代码的结尾: float[][] values = ... for (int i = 0; i < values.length; i++) { for (int k = 0; k < values[i].length; k++) { float value = values[i][k]; // do something with i, k

  • 详解Java函数式编程和lambda表达式

    为什么要使用函数式编程 函数式编程更多时候是一种编程的思维方式,是种方法论.函数式与命令式编程的区别主要在于:函数式编程是告诉代码你要做什么,而命令式编程则是告诉代码要怎么做.说白了,函数式编程是基于某种语法或调用API去进行编程.例如,我们现在需要从一组数字中,找出最小的那个数字,若使用用命令式编程实现这个需求的话,那么所编写的代码如下: public static void main(String[] args) { int[] nums = new int[]{1, 2, 3, 4, 5,

随机推荐