Java Lambda 表达式详解及示例代码_java

Java Lambda 表达式是 Java 8 引入的一个新的功能，可以说是模拟函数式编程的一个语法糖，类似于 Javascript 中的闭包，但又有些不同，主要目的是提供一个函数化的语法来简化我们的编码。

Lambda 基本语法

Lambda 的基本结构为 (arguments) -> body，有如下几种情况：

  1. 参数类型可推导时，不需要指定类型，如 (a) -> System.out.println(a)
  2. 当只有一个参数且类型可推导时，不强制写 (), 如 a -> System.out.println(a)
  3. 参数指定类型时，必须有括号，如 (int a) -> System.out.println(a)
  4. 参数可以为空，如 () -> System.out.println(“hello”)

body 需要用 {} 包含语句，当只有一条语句时 {} 可省略

常见的写法如下：

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

函数式接口 FunctionalInterface

概念

Java Lambda 表达式以函数式接口为基础。什么是函数式接口（FunctionalInterface）？ 简单说来就是只有一个方法（函数）的接口，这类接口的目的是为了一个单一的操作，也就相当于一个单一的函数了。常见的接口如：Runnable, Comparator 都是函数式接口，并且都标注了注解 @FunctionalInterface 。

举例

以 Thread 为例说明很容易理解。Runnable 接口是我们线程编程时常用的一个接口，就包含一个方法 void run()，这个方法就是线程的运行逻辑。按照以前的语法，我们新建线程一般要用到 Runnable 的匿名类，如下：

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

}).start();

如果写多了，是不是很无聊，而基于 Lambda 的写法则变得简洁明了，如下：

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

注意 Thread 的参数，Runnable 的匿名实现就通过一句就实现了出来，写成下面的更好理解

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

当然 Lambda 的目的不仅仅是写起来简洁，更高层次的目的等体会到了再总结。

再看一个比较器的例子，按照传统的写法，如下：

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

Lambda 表达式写法如下：

Integer[] a = {1, 8, 3, 9, 2, 0, 5};
Arrays.sort(a, (o1, o2) -> o1 - o2);

JDK中的函数式接口

为了现有的类库能够直接使用 Lambda 表达式，Java 8 以前存在一些接口已经被标注为函数式接口的：

  1. java.lang.Runnable
  2. java.util.Comparator
  3. java.util.concurrent.Callable
  4. java.io.FileFilter
  5. java.security.PrivilegedAction
  6. java.beans.PropertyChangeListener

Java 8 中更是新增加了一个包 java.util.function，带来了常用的函数式接口：

  1. Function<T, R> - 函数：输入 T 输出 R
  2. BiFunction<T, U, R> - 函数：输入 T 和 U 输出 R 对象
  3. Predicate<T> - 断言/判断：输入 T 输出 boolean
  4. BiPredicate<T, U> - 断言/判断：输入 T 和 U 输出 boolean
  5. Supplier<T> - 生产者：无输入，输出 T
  6. Consumer<T> - 消费者：输入 T，无输出
  7. BiConsumer<T, U> - 消费者：输入 T 和 U 无输出
  8. UnaryOperator<T> - 单元运算：输入 T 输出 T
  9. BinaryOperator<T> - 二元运算：输入 T 和 T 输出 T

另外还对基本类型的处理增加了更加具体的函数是接口，包括：BooleanSupplier, DoubleBinaryOperator, DoubleConsumer, DoubleFunction<R>, DoublePredicate, DoubleSupplier, DoubleToIntFunction, DoubleToLongFunction, DoubleUnaryOperator, IntBinaryOperator, IntConsumer, IntFunction<R>, IntPredicate, IntSupplier, IntToDoubleFunction, IntToLongFunction, IntUnaryOperator, LongBinaryOperator, LongConsumer,LongFunction<R>, LongPredicate, LongSupplier, LongToDoubleFunction,LongToIntFunction, LongUnaryOperator, ToDoubleBiFunction<T, U>, ToDoubleFunction<T>,ToIntBiFunction<T, U>, ToIntFunction<T>, ToLongBiFunction<T, U>, ToLongFunction<T> 。结合上面的函数式接口，对这些基本类型的函数式接口通过类名就能一眼看出接口的作用。

创建函数式接口

有时候我们需要自己实现一个函数式接口，做法也很简单，首先你要保证此接口只能有一个函数操作，然后在接口类型上标注注解 @FunctionalInterface 即可。

类型推导

类型推导是 Lambda 表达式的基础，类型推导的过程就是 Lambda 表达式的编译过程。以下面的代码为例：

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

  1. 先确定目标类型 Function
  2. Function 作为函数式接口，其方法签名为：Integer apply(String t)
  3. 检测 str -> Integer.parseInt(str) 是否与方法签名匹配（方法的参数类型、个数、顺序 和返回值类型）
  4. 如果不匹配，则报编译错误

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

方法引用

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

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

例如上面曾用到例子：

Function<String, Integer> strToInt = str -> Integer.parseInt(str);

对应的方法引用的写法为

Function<String, Integer> strToInt = Integer::parseInt;

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

构造方法引用

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

方法引用写法

Function<String, Integer> strToInt = Integer::new;

Lambda 写法

Function<String, Integer> 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 。如下面的函数为了构造一个指定长度的字符串数组

方法引用写法

Function<Integer, String[]> fixedArray = String[]::new;

方法引用写法

Function<Integer, String[]> 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 。 如下面的函数同样为了将字符串转为数组

方法引用写法

Function<String, Integer> strToInt = Integer::parseInt;

Lambda 写法

Function<String, Integer> 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 。如下面的判断函数用来判断给定的姓名是否在列表中存在

List<String> names = Arrays.asList(new String[]{"张三", "李四", "王五"});
Predicate<String> 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);

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

BiFunction<String, String, String[]> 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
表达式
c lambda表达式详解、lambda表达式详解、java lambda表达式、java8 lambda表达式、java中lambda表达式，以便于您获取更多的相关知识。

时间： 2024-08-03 23:33:18

Java Lambda 表达式详解及示例代码_java的相关文章

java 多线程-锁详解及示例代码_java

自 Java 5 开始,java.util.concurrent.locks 包中包含了一些锁的实现,因此你不用去实现自己的锁了.但是你仍然需要去了解怎样使用这些锁. 一个简单的锁 让我们从 java 中的一个同步块开始: public class Counter{ private int count = 0; public int inc(){ synchronized(this){ return ++count; } } } 可以看到在 inc()方法中有一个 synchronized(th

java Signleton模式详解及示例代码_java

Singleton模式是创建模式. 这种模式只涉及一个类是负责创建自己的对象. 该类确保只有一个对象获得创建. 这个类提供了一种方法来访问它的唯一对象. 例如,当设计一个用户界面,我们只能有一个主应用程序的窗口.我们可以使用Singleton模式,以确保有是MainApplicationWindow对象的一个​​实例. 下面的代码将创建一个主窗口类. MainWindow类有其私有的构造,并有其自身的静态实例. 主窗口类提供了一个静态方法来获取其静态实例外面的世界. 我们的演示类将使用主窗口类来

Java 中的注解详解及示例代码_java

在Java中,注解(Annotation)引入始于Java5,用来描述Java代码的元信息,通常情况下注解不会直接影响代码的执行,尽管有些注解可以用来做到影响代码执行. 注解可以做什么 Java中的注解通常扮演以下角色 编译器指令 构建时指令 运行时指令 其中 Java内置了三种编译器指令,本文后面部分会重点介绍 Java注解可以应用在构建时,即当你构建你的项目时.构建过程包括生成源码,编译源码,生成xml文件,打包编译的源码和文件到JAR包等.软件的构建通常使用诸如Apache Ant和Mav

Java 反射机制详解及实例代码_java

Java反射详解 本篇文章依旧采用小例子来说明,因为我始终觉的,案例驱动是最好的,要不然只看理论的话,看了也不懂,不过建议大家在看完文章之后,在回过头去看看理论,会有更好的理解. 下面开始正文. [案例1]通过一个对象获得完整的包名和类名 package Reflect; /** * 通过一个对象获得完整的包名和类名 * */ class Demo{ //other codes... } class hello{ public static void main(String[] args) {

Java transient 关键字详解及实例代码_java

Java transient 关键字 1. transient的作用及使用方法 我们都知道一个对象只要实现了Serilizable接口,这个对象就可以被序列化,java的这种序列化模式为开发者提供了很多便利,我们可以不必关系具体序列化的过程,只要这个类实现了Serilizable接口,这个类的所有属性和方法都会自动序列化. 然而在实际开发过程中,我们常常会遇到这样的问题,这个类的有些属性需要序列化,而其他属性不需要被序列化,打个比方,如果一个用户有一些敏感信息(如密码,银行卡号等),为了安全起见

Java 数组详解及示例代码_java

下面是stackoverflow中关于数组方法的相关问题中,获得最多票数的12个数组操作方法. 1.  声明一个数组 String[] aArray = new String[5]; String[] bArray = {"a","b","c", "d", "e"}; String[] cArray = new String[]{"a","b","c&quo

java Arrays类详解及实例代码_java

最近做项目 用到Arrays 类,这里整理下,希望大家能够掌握Arrays . 1.Arrays类概述   针对数组进行操作的工具类.   提供了排序,查找等功能. 2.成员方法   public static String toString(int[] a)   public static void sort(int[] a)   public static int binarySearch(int[] a,int value) package com; import java.util.Ar

Java 方法签名详解及实例代码_java

java 方法签名,我想做java 开发的朋友也知道,方法签名的重要性,是方法重载的一个比较好的解释,尤其是在后续优化方面,这里记录下,有看到的朋友也可看下, 方法签名的意义 对于同名不同类.同类不同名的方法,方法签名的意义并不是很大,但是对于重载方法来说,方法签名的意义就十分巨大了.由于重载方法之间的方法名是相同的,那么我们势必要从构成方法的其他几个要素中找到另一个要素与方法名组成能够唯一标示方法的签名,方法体当然不予考虑.那么就是形参列表和返回值了,但是由于对于调用方法的人来说,方法的形参数

java split用法详解及实例代码_java

public String[] split(String regex) 默认limit为0 public String[] split(String regex, int limit) 当limit>0时,则应用n-1次 public static void main(String[] args) { String s = "boo:and:foo"; String[] str = s.split(":",2); System.out.print(str[0]