首頁 > Java > java教程 > 主體

Java Lambda 表達式詳解及範例程式碼

高洛峰
發布: 2017-01-23 13:24:52
原創
1489 人瀏覽過

Java Lambda 表達式是Java 8 引入的一個新的功能,可以說是模擬函數式程式設計的一個語法糖,類似於Javascript 中的閉包,但又有些不同,主要目的是提供一個函數化的語法來簡化我們的編碼。

Lambda 基本語法

Lambda 的基本結構為(arguments) -> body,有以下幾種情況:

參數類型可推導時,不需要指定類型,如(a) -> System.out.println(參數類型可推導時,不需要指定類型,如(a) -> System.out.println( a)

當只有一個參數且類型可推導時,不強制寫(), 如a -> System.out.println(a)

參數指定類型時,必須有括號,如(int a) -> System.out.println(a)

參數可以為空,如() -> 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 以前存在一些介面已標註為函數式介面的:

java.lang.Runnable

java.util.Comparator

java.util.concurrent.Callable

java.io.FileFilterpid🜵

. beans.PropertyChangeListener

Java 8 中更是新增加了一個包java.util.function,帶來了常用的函數式介面:

Function - 函數:輸入T 輸出R

BiFunction< T, U, R> - 函數:輸入T 和U 輸出R 物件

Predicate - 斷言/判斷:輸入T 輸出boolean

BiPredicate - 斷言/判斷:輸入T 和U 輸出booleanT 和U 輸出boolean

Supplier - 生產者:無輸入,輸出T

Consumer - 消費者:輸入T,無輸出

BiConsumer - 消費者:輸入T 和U 無輸出

UnaryOperator - 單元運算:輸入T 輸出T

BinaryOperator - 二元運算:輸入T 和T 輸出T

另外還對基本類型的處理增加了更具體的函數是接口,包括: BooleanSupplier, DoubleBinaryOperator, DoubleConsumer, DoubleFunction, DoublePredicate, DoubleSupplier, DoubleToIntFunction, DoubleToLongFunction, DoubleUnaryOperator, IntBinaryOperator, IntConsumer, Intunc. IntUnaryOperator, LongBinaryOperator, LongConsumer,LongFunction, LongPredicate , LongSupplier, LongToDoubleFunction,LongToIntFunction, LongUnaryOperator, ToDoubleBiFunction, ToDoubleFunction,ToIntBiFunction, ToIntFunction, ToLongBiFunction, ToIntFunction, ToLongBiFunction, ToLunction

創建函數式接口

有時我們需要自己實現一個函數式接口,做法也很簡單,首先你要保證此接口只能有一個函數操作,然後在接口類型上標註註解 @FunctionalInterface 即可。

類型推導

類型推導是 Lambda 表達式的基礎,類型推導的過程就是 Lambda 表達式的編譯過程。以下面的程式碼為例:

Function 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。

例如上面曾用到例子:

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

对应的方法引用的写法为

Function strToInt = Integer::parseInt;

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

构造方法引用

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

方法引用写法

Function strToInt = Integer::new;

Lambda 写法

Function 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 fixedArray = String[]::new;

方法引用写法

Function 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 strToInt = Integer::parseInt;

Lambda 写法

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

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

BiFunction 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中文网!

相關標籤:
來源:php.cn
本網站聲明
本文內容由網友自願投稿,版權歸原作者所有。本站不承擔相應的法律責任。如發現涉嫌抄襲或侵權的內容,請聯絡admin@php.cn
最新問題
熱門教學
更多>
最新下載
更多>
網站特效
網站源碼
網站素材
前端模板
關於我們 免責聲明 Sitemap
PHP中文網:公益線上PHP培訓,幫助PHP學習者快速成長!