Explication détaillée et exemple de code des expressions Java Lambda

L'expression Java Lambda est une nouvelle fonctionnalité introduite dans Java 8. On peut dire qu'il s'agit d'un sucre syntaxique pour simuler la programmation fonctionnelle. Elle est similaire aux fermetures en Javascript, mais quelque peu différente. L'objectif principal est de fournir une syntaxe fonctionnelle. pour simplifier notre codage.

Syntaxe de base de Lambda

La structure de base de Lambda est (arguments) -> corps, il existe les situations suivantes :

Lorsque le type de paramètre peut être déduit, il il n'est pas nécessaire de spécifier le type, comme (a) -> System.out.println(a)

Lorsqu'il n'y a qu'un seul paramètre et que le type peut être déduit, l'écriture de () n'est pas obligatoire, tel que -> System.out.println(a )

Lors de la spécification du type de paramètre, il doit y avoir des parenthèses, telles que (int a) -> System.out.println(a)

Le paramètre peut être vide, tel que () -> System .out.println(“hello”)

body doit utiliser {} pour inclure des instructions lorsqu'il n'y a qu'une seule instruction. , {} peut être omis

La méthode d'écriture courante est la suivante :

(a) -> > a b
(a, b) -> {return a - b;}
() -> ; System.out.println(Thread.currentThread().getId())

Interface fonctionnelle FunctionalInterface

Concept

Expression Java Lambda sous forme fonctionnelle basée sur une interface. Qu'est-ce qu'une interface fonctionnelle (FunctionalInterface) ? En termes simples, il s'agit d'une interface avec une seule méthode (fonction). Le but de ce type d'interface est d'effectuer une seule opération, ce qui équivaut à une seule fonction. Les interfaces courantes telles que Runnable et Comparator sont des interfaces fonctionnelles et sont annotées avec @FunctionalInterface.

Exemple

Prenons Thread comme exemple pour illustrer qu'il est facile à comprendre. L'interface Runnable est une interface couramment utilisée dans notre programmation de threads. Elle contient une méthode void run(), qui est la logique d'exécution du thread. D'après la syntaxe précédente, lorsque l'on crée un nouveau thread, on utilise généralement la classe anonyme Runnable, de la manière suivante :

new Thread(new Runnable() {
  @Override
  public void run() {
    System.out.println(Thread.currentThread().getId());
  }
 
}).start();

Ecrire trop serait ennuyeux, mais basé sur Lambda règles d'écriture Cela devient concis et clair, comme suit :

new Thread(() -> System.out.println(Thread.currentThread().getId())).start();

Faites attention aux paramètres de Thread. L'implémentation anonyme de Runnable est réalisée en une phrase. Il vaut mieux la comprendre si elle est écrite comme suit

Runnable r = () ->. ; System.out.println(Thread.currentThread() .getId());

new Thread(r).start();

Bien sûr, le but de Lambda n'est pas seulement écrire de manière concise, mais résumer l'objectif de niveau supérieur après l'avoir compris.

Regardez un autre exemple de comparateur Selon la méthode d'écriture traditionnelle, il s'écrit comme suit :

Integer[] a = {1, 8, 3, 9, 2, 0, 5};
Arrays.sort(a, new Comparator<Integer>() {
  @Override
  public int compare(Integer o1, Integer o2) {
    return o1 - o2;
  }
});

L'expression lambda s'écrit comme suit :

Entier[ ] a = {1, 8, 3, 9, 2, 0, 5};

Arrays.sort(a, (o1, o2) -> o1 - o2);

Interfaces fonctionnelles dans JDK

Afin que les bibliothèques de classes existantes puissent utiliser directement les expressions Lambda, certaines interfaces avant Java 8 ont été marquées comme interfaces fonctionnelles :

java .lang.Runnable

java.util.Comparator

java.util.concurrent.Callable

java.io.FileFilter

java.security.PrivilegedAction

java.beans.PropertyChangeListener

Java 8 a ajouté un nouveau package java.util.function, qui apporte des interfaces fonctionnelles couramment utilisées :

Functionb6755583b82c4a7cd48100c3f618d43e - Fonction : entrée T sortie R

BiFunction96b8c9ba1c8b330d622a8468a6113c2e - fonction : entrée T et U sortie R objet

Prédicat8742468051c85b06f0a0af9e3e506b5c Sortie booléenne

BiPredicateabbd655bd3f9f929be0207abcc18a2ef - Assertion/Jugement : Entrée T et U Sortie booléenne

Fournisseur8742468051c85b06f0a0af9e3e506b5c - Producteur : Aucune entrée, sortie T

Consommateur30ed0b842438c94a8fa238872cb60905 - Consommateur : entrée T, pas de sortie

BiConsumerabbd655bd3f9f929be0207abcc18a2ef - Consommateur : entrée T et U, pas de sortie

UnaryOperator8742468051c85b06f0a0af9e3e506b5c T

BinaryOperator8742468051c85b06f0a0af9e3e506b5c - Opération binaire : Entrée T et T Sortie T

De plus, des fonctions plus spécifiques sont ajoutées pour le traitement de type de base, qui sont des interfaces, notamment : BooleanSupplier , DoubleBinaryOperator, DoubleConsumer, DoubleFunction0f1763a9dfcc95d54eac98034f0cdcdd, DoublePredicate, DoubleSupplier, DoubleToIntFunction, DoubleToLongFunction, DoubleUnaryOperator, IntBinaryOperator, IntConsumer, IntFunction0f1763a9dfcc95d54eac98034f0cdcdd, IntPredicate, IntSupplier, IntToDoubleFunction, IntToLongFunction, Int UnaryOperator, LongConsumer, LongFunction

Créer une interface fonctionnelle

Parfois, nous devons implémenter nous-mêmes une interface fonctionnelle. La méthode est également très simple. Tout d'abord, vous devez vous assurer que cette interface ne peut avoir qu'une seule opération de fonction, puis ainsi de suite. le type d'interface Marquez-le simplement avec @FunctionalInterface.

Dérivation de type

La dérivation de type est la base des expressions Lambda, et le processus de dérivation de type est le processus de compilation des expressions Lambda. Prenons comme exemple le code suivant :

Function00c20620d278363633dd30e58ef30cbd strToInt = str -> Integer.parseInt(str);
编译期间，我理解的类型推导的过程如下：

先确定目标类型 Function

Function 作为函数式接口，其方法签名为：Integer apply(String t)

检测 str -> Integer.parseInt(str) 是否与方法签名匹配（方法的参数类型、个数、顺序 和返回值类型）

如果不匹配，则报编译错误

这里的目标类型是关键，通过目标类型获取方法签名，然后和 Lambda 表达式做出对比。

方法引用

方法引用(Method Reference)的基础同样是函数式接口，可以直接作为函数式接口的实现，与 Lambda 表达式有相同的作用，同样依赖于类型推导。方法引用可以看作是只调用一个方法的 Lambda 表达式的简化。

方法引用的语法为： Type::methodName 或者 instanceName::methodName , 构造函数对应的 methodName 为 new。

例如上面曾用到例子：

Function00c20620d278363633dd30e58ef30cbd strToInt = str -> Integer.parseInt(str);

对应的方法引用的写法为

Function00c20620d278363633dd30e58ef30cbd strToInt = Integer::parseInt;

根据方法的类型，方法引用主要分为一下几种类型，构造方法引用、静态方法引用、实例上实例方法引用、类型上实例方法引用等

构造方法引用

语法为： Type::new 。 如下面的函数为了将字符串转为数组

方法引用写法

Function00c20620d278363633dd30e58ef30cbd strToInt = Integer::new;

Lambda 写法

Function00c20620d278363633dd30e58ef30cbd strToInt = str -> new Integer(str);

传统写法

Function<String, Integer> strToInt = new Function<String, Integer>() {
  @Override
  public Integer apply(String str) {
    return new Integer(str);
  }
};

数组构造方法引用

语法为： Type[]::new 。如下面的函数为了构造一个指定长度的字符串数组

方法引用写法

Function440e1640c9faa3393c37ba0de3f32bfa fixedArray = String[]::new;

方法引用写法

Function440e1640c9faa3393c37ba0de3f32bfa fixedArray = length -> new String[length];

传统写法

Function<Integer, String[]> fixedArray = new Function<Integer, String[]>() {
  @Override
  public String[] apply(Integer length) {
    return new String[length];
  }
};

静态方法引用

语法为： Type::new 。 如下面的函数同样为了将字符串转为数组

方法引用写法

Function00c20620d278363633dd30e58ef30cbd strToInt = Integer::parseInt;

Lambda 写法

Function00c20620d278363633dd30e58ef30cbd strToInt = str -> Integer.parseInt(str);

传统写法

Function<String, Integer> strToInt = new Function<String, Integer>() {
  @Override
  public Integer apply(String str) {
    return Integer.parseInt(str);
  }
};

实例上实例方法引用

语法为： instanceName::methodName 。如下面的判断函数用来判断给定的姓名是否在列表中存在

Listf7e83be87db5cd2d9a8a0b8117b38cd4 names = Arrays.asList(new String[]{"张三", "李四", "王五"});
Predicatef7e83be87db5cd2d9a8a0b8117b38cd4 checkNameExists = names::contains;
System.out.println(checkNameExists.test("张三"));
System.out.println(checkNameExists.test("张四"));

类型上实例方法引用

语法为： Type::methodName 。运行时引用是指上下文中的对象，如下面的函数来返回字符串的长度

Function<String, Integer> calcStrLength = String::length;
System.out.println(calcStrLength.apply("张三"));
List<String> names = Arrays.asList(new String[]{"zhangsan", "lisi", "wangwu"});
names.stream().map(String::length).forEach(System.out::println);<br>

   

又比如下面的函数已指定的分隔符分割字符串为数组

BiFunction505cb6255f356d4ffe44ba9665547740 split = String::split;
String[] names = split.apply("zhangsan,lisi,wangwu", ",");
System.out.println(Arrays.toString(names));

Stream 对象

概念

什么是 Stream ? 这里的 Stream 不同于 io 中的 InputStream 和 OutputStream，Stream 位于包 java.util.stream 中， 也是 java 8 新加入的，Stream 只的是一组支持串行并行聚合操作的元素，可以理解为集合或者迭代器的增强版。什么是聚合操作？简单举例来说常见的有平均值、最大值、最小值、总和、排序、过滤等。

Stream 的几个特征：

单次处理。一次处理结束后，当前Stream就关闭了。
支持并行操作
常见的获取 Stream 的方式

从集合中获取

Collection.stream();
Collection.parallelStream();

静态工厂

Arrays.stream(array)
Stream.of(T …)
IntStream.range()
这里只对 Stream 做简单的介绍，下面会有具体的应用。要说 Stream 与 Lambda 表达式有什么关系，其实并没有什么特别紧密的关系，只是 Lambda 表达式极大的方便了 Stream 的使用。如果没有 Lambda 表达式，使用 Stream 的过程中会产生大量的匿名类，非常别扭。

举例

以下的demo依赖于 Employee 对象，以及由 Employee 对象组成的 List 对象。

public class Employee {
 
  private String name;
  private String sex;
  private int age;
 
  public Employee(String name, String sex, int age) {
    super();
    this.name = name;
    this.sex = sex;
    this.age = age;
  }
  public String getName() {
    return name;
  }
 
  public String getSex() {
    return sex;
  }
  public int getAge() {
    return age;
  }
  @Override
  public String toString() {
    StringBuilder builder = new StringBuilder();
    builder.append("Employee {name=").append(name).append(", sex=").append(sex).append(", age=").append(age)
        .append("}");
    return builder.toString();
  }
}
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("张三", "男", 25));
employees.add(new Employee("李四", "女", 24));
employees.add(new Employee("王五", "女", 23));
employees.add(new Employee("周六", "男", 22));
employees.add(new Employee("孙七", "女", 21));
employees.add(new Employee("刘八", "男", 20));

   

打印所有员工

Collection 提供了 forEach 方法，供我们逐个操作单个对象。

employees.forEach(e -> System.out.println(e)); 
或者
employees.stream().forEach(e -> System.out.println(e));

按年龄排序

Collections.sort(employees, (e1, e2) -> e1.getAge() - e2.getAge());
employees.forEach(e -> System.out.println(e));
或者
employees.stream().sorted((e1, e2) -> e1.getAge() - e2.getAge()).forEach(e -> System.out.println(e));
打印年龄最大的女员工

max/min 返回指定排序条件下最大/最小的元素

Employee maxAgeFemaleEmployee = employees.stream()
    .filter(e -> "女".equals(e.getSex()))
    .max((e1, e2) -> e1.getAge() - e2.getAge())
    .get();
System.out.println(maxAgeFemaleEmployee);

   

打印出年龄大于20 的男员工

filter 可以过滤出符合条件的元素

employees.stream()
        .filter(e -> e.getAge() > 20 && "男".equals(e.getSex()))
        .forEach(e -> System.out.println(e));
打印出年龄最大的2名男员工

limit 方法截取有限的元素

employees.stream()
    .filter(e -> "男".equals(e.getSex()))
    .sorted((e1, e2) -> e2.getAge() - e1.getAge())
    .limit(2)
    .forEach(e -> System.out.println(e));

   

打印出所有男员工的姓名，使用 , 分隔

map 将 Stream 中所有元素的执行给定的函数后返回值组成新的 Stream

String maleEmployeesNames = employees.stream()
    .map(e -> e.getName())
    .collect(Collectors.joining(","));
System.out.println(maleEmployeesNames);

   

统计信息

IntSummaryStatistics, DoubleSummaryStatistics, LongSummaryStatistics 包含了 Stream 中的汇总数据。

IntSummaryStatistics stat = employees.stream()
    .mapToInt(Employee::getAge).summaryStatistics();
System.out.println("员工总数：" + stat.getCount());
System.out.println("最高年龄：" + stat.getMax());
System.out.println("最小年龄：" + stat.getMin());
System.out.println("平均年龄：" + stat.getAverage());

   

总结

Lambda 表达式确实可以减少很多代码，能提高生产力，当然也有弊端，就是复杂的表达式可读性会比较差，也可能是还不是很习惯的缘故吧，如果习惯了，相信会喜欢上的。凡事都有两面性，就看我们如何去平衡这其中的利弊了，尤其是在一个团队中。

以上就是对Java8 JavaLambda 的资料整理，后续继续补充相关资料谢谢大家对本站的支持！

更多Java Lambda 表达式详解及示例代码相关文章请关注PHP中文网！