Java8中Lambda表达式的理解与应用

目录
  • 简介
  • 正文
    • 1. lambda的语法
    • 2. 为啥引入lambda
    • 3. 什么是函数式接口
    • 4. 什么是行为参数化
    • 5. 手写一个函数式接口
    • 6. 常用的函数式接口
    • 7. 什么是方法引用
    • 8. 什么是构造引用
    • 9. lambda表达式中引入外部变量的限制
    • 10. lambda的组合操作
  • 总结

简介

Lambda表达式是一个可传递的代码块,可以在以后执行一次或多次;

下面贴个对比代码:

// Java8之前:旧的写法
Runnable runnable = new Runnable() {
 @Override
 public void run() {
   System.out.println("old run");
}
};
Thread t = new Thread(runnable);

// Java8之后:新的写法
Runnable runnable1 = ()->{
 System.out.println("lambda run");
};
Thread t1 = new Thread(runnable1);

可以看到,有了lambda,代码变得简洁多了

你可以把lambda当作一个语法糖

下面让我们一起来探索lambda的美好世界吧

正文

1. lambda的语法

下面分别说下语法中的三个组成部分

  • 参数: ( Dog dog )

    • 参数类型可省略(当编译器可以自动推导时),比如Comparator<String> comparatorTest = (a, b)->a.length()-b.length();,可以推导出a,b都为String
    • 当参数类型可省略,且只有一个参数时,括弧也可以省略(但是个人习惯保留)
  • 符号:->
  • 主体{ System.out.println("javalover"); }
    • 如果是一条语句,则需要加大括号和分号{;}(比如上图所示)
    • 如果是一个表达式,则直接写,啥也不加(比如a.length()- b.length()

2. 为啥引入lambda

为了简化代码

因为Java是面向对象语言,所以在lambda出现之前,我们需要先构造一个对象,然后在对象的方法中实现具体的内容,再把构造的对象传递给某个对象或方法

但是有了lambda以后,我们可以直接将代码块传递给对象或方法

现在再回头看下开头的例子

可以看到,用了lambda表达式后,少了很多模板代码,只剩下一个代码块(最核心的部分)

3. 什么是函数式接口

就是只定义了一个抽象方法的接口

  • 正例:有多个默认方法,但是如果只有一个抽象方法,那它就是函数式接口,示例代码如下
@FunctionalInterface
public interface FunctionInterfaceDemo {
   void abstractFun();
   default void fun1(){
       System.out.println("fun1");    
  }
   default void fun2(){
       System.out.println("fun2");
  }  
}

这里的注解@FunctionalInterface可以省略,但是建议加上,就是为了告诉编译器,这是一个函数式接口,此时如果该接口有多个抽象方法,那么编译器就会报错

  • 反例:比如A extends B,A和B各有一个抽象方法,那么A就不是函数式接口,示例代码如下
// 编译器会报错,Multiple non-overriding abstract methods found in XXX
@FunctionalInterface
public interface NoFunctionInterfaceDemo extends FunctionInterfaceDemo{
 void abstractFun2();
}

上面的父接口FunctionInterfaceDemo中已经有了一个抽象方法,此时NoFunctionInterfaceDemo又定义了一个抽象方法,结果编译器就提示了:存在多个抽象方法

在Java8之前,其实我们已经接触过函数式接口

比如Runnable 和 Comparable

只是没有注解@FunctionalInterface。

那这个函数式接口要怎么用呢?

配合lambda食用,效果最佳(就是把lambda传递给函数式接口),示例代码如下:

new Thread(() -> System.out.println("run")).start();

其中用到的函数式接口是Runnable

4. 什么是行为参数化

就是把行为定义成参数,行为就是函数式接口

类似泛型中的类型参数化,类型参数化是把类型定义成参数

行为参数化,通俗点来说:

  • 就是用函数式接口形参
  • 然后传入接口的各种实现内容(即lambda表达式)作为实参
  • 最后在lambda内实现各种行为(好像又回到多态的那一节了?这也是为啥多态是Java的三大特性的原因之一,应用太广泛了)

这样来看的话,行为参数化和设计模式中的策略模式有点像了(后面章节会分别讲常用的几种设计模式)

下面我们手写一个函数式接口来加深理解吧

5. 手写一个函数式接口

下面我们循序渐进,先从简单的需求开始

  • 第一步:比如我们想要读取某个文件,那可以有如下方法:
public static String processFile() throws IOException {
   // Java7新增的语法,try(){},可自动关闭资源,减少了代码的臃肿
   try( BufferedReader bufferedReader =
       new BufferedReader(new  FileReader("./test.txt"))){
       return bufferedReader.readLine();
  }
}

可以看到,核心的行为动作就是 return bufferedReader.readLine();,表示读取第一行的数据并返回

那如果我们想要读取两行呢?三行?

  • 第二步:这时就需要用到上面的函数式接口了,下面就是我们自己编写的函数式接口
@FunctionalInterface
interface FileReadInterface{
// 这里接受一个BufferedReader对象,返回一个String对象
   String process(BufferedReader reader) throws IOException;
}

可以看到,只有一个抽象方法process(),它就是用来处理第一步中的核心动作(读取文件内容)

至于想读取多少内容,那就需要我们在lambda表达式中定义了

  • 第三步:接下来我们定义多个lambda表达式,用来传递函数式接口,其中每个lambda表达式就代表了一种不同的行为,代码如下:
// 读取一行
FileReadInterface fileReadInterface = reader -> reader.readLine();
// 读取两行
FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine();
  • 第四步:我们需要修改第一步的processFile(),让其接受一个函数式接口,并调用其中的抽象方法,代码如下:
// 参数为第二步我们自己手写的函数式接口
public static String processFile(FileReadInterface fileReadInterface) throws IOException {
       try( BufferedReader bufferedReader =
                new BufferedReader(new FileReader("./test.txt"))){
// 这里我们不再自己定义行为,而是交给函数式接口的抽象方法来处理,然后通过lambda表达式的传入来实现多个行为
         return fileReadInterface.process(bufferedReader);
      }
  }
  • 第五步:拼接后,完整代码如下:
public class FileReaderDemo {
   public static void main(String[] args) throws IOException {
// 第三步:
    // lambda表达式1 传给 函数式接口:只读取一行
    FileReadInterface fileReadInterface = reader -> reader.readLine();
// lambda表达式2 传给 函数式接口:只读取两行
    FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine();
    // 最后一步: 不同的函数式接口的实现,表现出不同的行为
       String str1 = processFile(fileReadInterface);
       String str2 = processFile(fileReadInterface2);
       System.out.println(str1);
       System.out.println(str2);
  }
// 第四步: 读取文件方法,接受函数式接口作为参数
   public static String processFile(FileReadInterface fileReadInterface) throws IOException {
       try( BufferedReader bufferedReader =
                new BufferedReader(new FileReader("./test.txt"))){
// 调用函数式接口中的抽象方法来处理数据
         return fileReadInterface.process(bufferedReader);
      }
  }
// 第一步:
 public static String processFile() throws IOException {
       try( BufferedReader bufferedReader =
                new BufferedReader(new FileReader("./test.txt"))){
         return bufferReader.readLine();
      }
  }

}

// 第二步: 我们手写的函数式接口
@FunctionalInterface
interface FileReadInterface{
   String process(BufferedReader reader) throws IOException;
}

其实你会发现,我们手写的这个函数式接口,其实就是Function<T>去除泛型化后的接口,如下所示:

@FunctionalInterface
public interface Function<T, R> {
// 都是接受一个参数,返回另一个参数
 R apply(T t);
}

下面我们列出Java中常用的一些函数式接口,你会发现自带的已经够用了,基本不会需要我们自己去写

这里的手写只是为了自己实现一遍,可以加深理解程度

6. 常用的函数式接口

7. 什么是方法引用

我们先看一个例子

前面我们写的lambda表达式,其实还可以简化,比如

// 简化前
Function<Cat, Integer> function = c->c.getAge();
// 简化后
Function<Cat, Integer> function2 = Cat::getAge;

其中简化后的Cat::getAge,我们就叫做方法引用

方法引用就是引用类或对象的方法

下面我们列出方法引用的三种情况:

  • Object::instanceMethod(对象的实例方法)
  • Class::staticMethod(类的静态方法)
  • Class::instanceMethod(类的实例方法)

像我们上面举的例子就是第三种:类的实例方法

下面我们用代码演示上面的三种方法:

public class ReferenceDemo {
   public static void main(String[] args) {
       // 第一种:引用对象的实例方法
       Cat cat = new Cat(1);
       Function<Cat, Integer> methodRef1 = cat::getSum;
       // 第二种:引用类的静态方法
       Supplier<Integer> methodRef2 = Cat::getAverageAge;
       // 第三种:引用类的实例方法
       Function<Cat, Integer> methodRef3 = Cat::getAge;
  }
}
class Cat {
   int age;

   public Cat(int age) {
       this.age = age;
  }

   // 获取猫的平均年龄
   public static int getAverageAge(){
       return 15;
  }
   // 获取两只猫的年龄总和
   public int getSum(Cat cat){
       return cat.getAge() + this.getAge();
  }

   public int getAge() {
       return age;
  }    public void setAge(int age) {
       this.age = age;
  }
}

为啥要用这个方法引用呢?

方法引用好比lambda表达式的语法糖,语法更加简洁,清晰

一看就知道是调用哪个类或对象的哪个方法

8. 什么是构造引用

上面介绍了方法引用,就是直接引用某个方法

这里的构造引用同理可得,就是引用某个类的构造方法

构造引用的表达式为:Class::new,仅此一种

如果你有多个构造函数,那编译器会自己进行推断参数(你看看,多好,多简洁)

比如下面的代码:

// 这里调用 new Cat()
Supplier<Cat> constructRef1 = Cat::new;
// 这里调用 new Cat(Integer)
Function<Integer, Cat> constructRef2 = Cat::new;

9. lambda表达式中引入外部变量的限制

要求引入lambda表达式中的变量,必须是最终变量,即该变量不会再被修改

比如下面的代码:

public static void main(String[] args) {
 String str = "javalover.cc";
 Runnable runnable = ()->{
   str = "1";// 这里会报错,因为修改了str引用的指向
   System.out.println(str);
}
}

可以看到,lambda表达式引用了外面的str引用,但是又在表达式内部做了修改,结果就报错了

为啥要有这个限制呢?

为了线程安全,因为lambda表达式有一个好处就是只在需要的时候才会执行,而不是调用后立马执行

这样就会存在多个线程同时执行的并发问题

所以Java就从根源上解决:不让变量被修改,都是只读的

那你可能好奇,我不把str的修改代码放到表达式内部可以吗?

也不行,道理是一样的,只要lambda有用到这个变量,那这个变量不管是在哪里被修改,都是不允许的

不然的话,我这边先执行了一次lambda表达式,结果你就改了变量值,那我第二次执行lambda,不就乱了吗

10. lambda的组合操作

最后是lambda的必杀技:组合操作

在这里叫组合或者复合都可以

概述:组合操作就是先用一个lambda表达式,然后再在后面组合另一个lambda表达式,然后再在后面组合另另一个lambda表达式,然后。。。有点像是链式操作

学过JS的都知道Promise,里面的链式操作就和这里的组合操作很像

用过Lombok的朋友,应该很熟悉@Builder注解,其实就是构造者模式

下面我们用代码演示下组合操作:

// 重点代码
public class ComposeDemo {
   public static void main(String[] args) {
       List<Dog> list = Arrays.asList(new Dog(1,2), new Dog(1, 1));
       // 1. 先按年龄排序(默认递增)
    // Dog::getAge, 上面介绍的方法引用
    // comparingInt, 是Comparator的一个静态方法,返回Comparator<T>
    Comparator<Dog> comparableAge = Comparator.comparingInt(Dog::getAge);
       // 2. 如果有相同的年龄,则年龄相同的再按体重排序(如果年龄已经比较出大小,则下面的体重就不会再去比较)
       Comparator<Dog> comparableWeight = Comparator.comparingInt(Dog::getWeight);;
       // 3. 调用list对象的sort方法排序,参数是Comparator<? super Dog>
       list.sort(comparableAge.thenComparing(comparableWeight));
       System.out.println(list);
  }
}
// 非重点代码
class Dog{
   private int age;
   private int weight;

   public Dog(int age, int weight) {
       this.age = age;
       this.weight = weight;
  }

   public int getAge() {
       return age;
  }

   public void setAge(int age) {
       this.age = age;
  }

   public int getWeight() {
       return weight;
  }

   public void setWeight(int weight) {
       this.weight = weight;
  }

   @Override
   public String toString() {
       return "Dog{" +
               "age=" + age +
               ", weight=" + weight +
               '}';
  }
}

输出:[Dog{age=1, weight=1}, Dog{age=1, weight=2}]

比较的流程如下所示:

总结

  • lambda的语法:  参数+符合+表达式或语句,比如(a,b)->{System.out.println("javalover.cc");}
  • 函数式接口:只有一个抽象方法,最好加@FunctionalInterface,这样编译器可及时发现错误,javadoc也说明这是一个函数式接口(可读性)
  • 行为参数化:就是函数式接口作为参数,然后再将lambda表达式传给函数式接口,通过不同的lambda内容实现不同的行为
  • 方法引用:lambda的语法糖,总共有三种:
    • Class::instanceMethod(类的实例方法)
    • Object::instanceMethod(对象的实例方法)
    • Class::staticMethod(类的静态方法)
  • 构造引用:就一种,编译器自己可判断是哪个构造函数,语法为Class::new
  • 在lambda中引入外部变量,必须保证这个变量是最终变量,即不再被修改
  • lambda的组合操作,就是链式操作,组合是通过函数式接口的静态方法来组合(静态方法会返回另一个函数式接口的对象)

比如list.sort(comparableAge.thenComparing(comparableWeight));

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

(0)

相关推荐

  • Java8新特性之Lambda表达式浅析

    说到java 8,首先会想到lambda(闭包)以及虚拟扩展方法(default method),这个特性早已经被各大技术网站炒得沸沸扬扬了,也是我们java 8系列开篇要讲的第一特性(JEP126 http://openjdk.java.net/jeps/126),jdk8的一些库已经应用了lambda表达式重新设计了,理解他对学习java 8新特性有着重要的意义. 一.函数式接口 函数式接口(functional interface 也叫功能性接口,其实是同一个东西).简单来说,函数式接口是

  • Java8 Lambda表达式详解及实例

    第一个Lambda表达式 在Lambda出现之前,如果我们需要写一个多线程可能需要下面这种方式: Runnable runnable = new Runnable() { @Override public void run() { System.out.println("Hello runnable"); } }; ... thread.start(); 上面的例子如果改成使用Lambda就会简单许多: Runnable noArgs = ()->System.out.print

  • Java8新特性lambda表达式有什么用(用法实例)

    我们期待了很久lambda为java带来闭包的概念,但是如果我们不在集合中使用它的话,就损失了很大价值.现有接口迁移成为lambda风格的问题已经通过default methods解决了,在这篇文章将深入解析Java集合里面的批量数据操作(bulk operation),解开lambda最强作用的神秘面纱. 1.关于JSR335 JSR是Java Specification Requests的缩写,意思是Java 规范请求,Java 8 版本的主要改进是 Lambda 项目(JSR 335),其

  • Java8与Scala中的Lambda表达式深入讲解

    前言 最近几年Lambda表达式风靡于编程界.很多现代编程语言都把它作为函数式编程的基本组成部分.基于JVM的编程语言如Scala.Groovy及Clojure把它作为关键部分集成在语言中.而如今,(最终)Java 8也加入了这个有趣的行列. Java8 终于要支持Lambda表达式!自2009年以来Lambda表达式已经在Lambda项目中被支持.在那时候,Lambda表达式仍被称为Java闭包.在我们进入一些代码示例以前,先来解释下为什么Lambda表达式在Java程序员中广受欢迎. 1.为

  • 30分钟入门Java8之lambda表达式学习

    前言 Google在今年发布Android N开发者预览版,一并宣布开始支持Java 8.我们终于能在Android开发中使用到Java8的一些语言特性了.目前支持: 默认方法 lambda表达式 多次注解 今天我们就简要学习lambda表达式. 配置开发环境 首先需要下载安装JDK1.8. 如果想在Android开发中使用lambda表达式,需要在Android Studio中配置Java 8开发环境. 配置app的Gradle文件: 开启jack编译选项 设置编译选项兼容到1.8 andro

  • Java8中lambda表达式的应用及一些泛型相关知识

    语法部分就不写了,我们直接抛出一个实际问题,看看java8的这些新特性究竟能给我们带来哪些便利 顺带用到一些泛型编程,一切都是为了简化代码 场景: 一个数据类,用于记录职工信息 public class Employee { public String name; public int age; public char sex; public String time; public int salary; } 我们有一列此类数据 List<Employee> data = Arrays.asL

  • Java8 新特性Lambda表达式实例详解

    Java8 新特性Lambda表达式实例详解 在介绍Lambda表达式之前,我们先来看只有单个方法的Interface(通常我们称之为回调接口): public interface OnClickListener { void onClick(View v); } 我们是这样使用它的: button.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { v.setText("

  • Java8中的lambda表达式入门教程

    1.基本介绍 lambda表达式,即带有参数的表达式,为了更清晰地理解lambda表达式,先上代码: 1.1 两种方式的对比 1.1.1 方式1-匿名内部类 class Student{ private String name; private Double score; public Student(String name, Double score) { this.name = name; this.score = score; } public String getName() { ret

  • Java8新特性Lambda表达式的一些复杂用法总结

    简介 lambda表达式是JAVA8中提供的一种新的特性,它支持Java也能进行简单的"函数式编程". 它是一个匿名函数,Lambda表达式基于数学中的λ演算得名,直接对应于其中的lambda抽象(lambda abstraction),是一个匿名函数,即没有函数名的函数. 本文将介绍关于Java8 Lambda表达式的一些复杂用法,分享出来供大家参考学习,下面来一起看看详细的介绍: 复杂用法实例 传入数组ids,在list<Obj>上操作,找出Obj中id想匹配的,并且按

  • Java8中的 Lambda表达式教程

     1. 什么是λ表达式 λ表达式本质上是一个匿名方法.让我们来看下面这个例子: public int add(int x, int y) { return x + y; } 转成λ表达式后是这个样子: (int x, int y) -> x + y; 参数类型也可以省略,Java编译器会根据上下文推断出来: (x, y) -> x + y; //返回两数之和 或者 (x, y) -> { return x + y; } //显式指明返回值 可见λ表达式有三部分组成:参数列表,箭头(-&g

随机推荐