Java8新特性之一：Lambda表达式

　　Java8是自java5之后最重大的一次更新，它给JAVA语言带来了很多新的特性（包括编译器、类库、工具类、JVM等），其中最重要的升级是它给我们带来了Lambda表达式和Stream API。

1、什么是Lambda表达式？

　　Lambda是一个匿名函数，可以理解为是一段可以传递的代码，可以将代码像传递参数、传递数据一样进行传输。使用Lambda表达式，可以写出更加紧凑、更加简洁、更加灵活的代码。

2、使用Lambda的限制条件

　　Lambda并不是任何地方都可以使用，Lambda表达式需要“函数式接口”的支持。

3、什么是函数式接口？

　　接口中只有一个抽象方法的接口，称为函数式接口，可以用@FunctionalInterface修饰一下，这里需要注意的是：未使用 @FunctionalInterfaces注解的接口未必就不是函数式接口，一个接口是不是函数式接口的条件只有一条，即接口中只有一个抽象方法的接口（Object类中的方法不算）。而使用@FunctionalInterface注解修饰了的接口就一定是函数式接口，添加@FunctionalInterface注解可以帮助我们检查是否是函数式接口。

JDK中常见的函数式接口有：

1 @FunctionalInterface
2 public interface Runnable {
3     void run();
4 }
1 @FunctionalInterface
2 public interface Callable<V> {
3     V call() throws Exception;
4 }

以下接口中虽然有两个方法，但因hashCode()是Object类中的方法，因此该接口也是函数式接口：

1 @FunctionalInterface
2 public interface FuncInterface {
3
4     void doSomething();
5
6     int hashCode();  // Object类中的方法
7 }

4、Lambda表达式示例

　　需求一：开启一个线程，在线程中打印出"Hello World"

　　未使用Lambda表达式时的写法：

 1 public class LambdaTest {
 2
 3     public void print() {
 4
 5         Thread thread = new Thread(new Runnable() {
 6             @Override
 7             public void run() {
 8                 System.out.println("Hello World");
 9             }
10         });
11
12         thread.start();
13     }14 }

　　使用Lambda时的写法：

1 public class LambdaTest {
2
3     public void print() {
4         Thread thread = new Thread(() -> System.out.println("Hello World"));
5     }
6 }

　　需求二：模拟一个计算器，使其可以进行简单的加、减、乘操作

　　（1）、计算器操作函数式接口

1 @FunctionalInterface
2 public interface Calculator<T> {
3     T operation(T t1,T t2);
4 }

　　（2）具体操作

 1 public class CalculatorTest {
 2
 3     public Integer operator(Integer v1,Integer v2,Calculator<Integer> calculator) {
 4         return calculator.operation(v1,v2);
 5     }
 6
 7     public Integer add(Integer v1,Integer v2) {
 8         return operator(v1,v2,(x,y) -> x + y);
 9     }
10
11     public Integer subtr(Integer v1,Integer v2) {
12         return operator(v1,v2,(x,y) -> x - y);
13     }
14
15     public Integer multi(Integer v1,Integer v2) {
16         return operator(v1,v2,(x,y) -> x * y);
17     }
18
19     public static void main(String[] args) {
20
21         CalculatorTest calculatorTest = new CalculatorTest();
22
23         // 加法
24         Integer add = calculatorTest.add(1,2);
25
26         // 减法
27         Integer sub = calculatorTest.subtr(100,82);
28
29         // 乘法
30         Integer multi = calculatorTest.multi(5,3);
31
32         System.out.println(add);
33         System.out.println(sub);
34         System.out.println(multi);
35     }
36 }

　　运行结果：

3
18
15

　　从需求一中，我们可以看出，使用Lambda比使用匿名内部类代码更加简洁，同时，也可以理解为什么Lambda必须需要函数式接口的支持。我们假设Runnable中有两个方法，那么，“() -> System.out.println(Thread.currentThread().getName())”应该去找哪个方法去实现？

　　从需求二的例子中，我们可以更加理解“一段可以传递的代码”这句话的含义。对数据的操作方法定义在Calculator接口中，而加、减、乘的具体实现代码在各自的方法中，并将这些实现作为参数传递给CalculatorTest类的operator()方法，最终返回操作结果。

5、Lambda表达式的语法

5.1 Lambda表达式的语法结构

(参数列表，对应的是接口中对应的抽象方法的参数列表) -> {对抽象方法的实现}

　　Lambda表达式语法分在3个部分：

  1. 左边的参数列表，对应的是函数式接口中抽象方法的参数列表；
  2. 中间的符号:->,为固定写法;
  3. 右边大括号内对函数接口抽象方法的实现。

　　Lambda表达式的在具体场景下可以有简略写法。

5.2 语法格式一：无参数，无返回值

1 Runnable runnable = () -> {System.out.println("Hello World");}
2 Runnable runnable = () -> System.out.println("Hello World");  // 简写形式

　　此时，如果右边的代码简单，只有一行代码时，{}可以省略。

5.2 语法格式二：有一个参数，无返回值

 1 public class CalculatorTest {
 2
 3     public void print(Consumer<String> msg) {
 4         System.out.println(msg);
 5     }
 6
 7     public void doPrint(String msg) {
 8         print((str) -> System.out.println(msg));
 9         print(str -> System.out.println(msg));  // 简写
10
11     }
12 }

　　此时，左边的()可以省略。

5.3 语法格式三：Lambda体内只有一条语句，且有返回值，return可省略

1 public Integer subtr(Integer v1,Integer v2) {
2     return operator(v1,v2,(x,y) -> x - y);
3 }

5.4 语法格式四：有两个以上参数，且Lambda体中有多条语句

1 public Integer add(Integer v1,Integer v2) {
2         return operator(v1,v2,(x,y) -> {
3             System.out.println("进行加法运算");
4             return x + y;
5         });
6     }

5.5 语法格式五：Lambda表达式的数据类型可以省略不写

　　JVM编译器通过上下文可以推断出数据类型，但要注意的是，当多个参数时，要么都写，要么都不写，不能有的写，有的不写：

1 public Integer subtr(Integer v1,Integer v2) {
2         return operator(v1,v2,(Integer x,y) -> x - y);   // 错误
3     }
4
5 public Integer subtr(Integer v1,Integer v2) {
6         return operator(v1,v2,(x,y) -> x - y);    // 正确
7     }

6、Java8四大内置核心函数式接口

 Consumer<T> : 消费型接口（无返回值，有去无回）
         void accept(T t);
 Supplier<T> : 供给型接口
         T get();

 Function<T,R> : 函数型接口
        R apply(T t);

 Predicate<T> : 断言型接口
        boolean test(T t);

四大核心接口的-->扩展子接口

　　示例：

 1 import lombok.Getter;
 2 import lombok.Setter;
 3
 4 import java.util.function.Consumer;
 5 import java.util.function.Function;
 6 import java.util.function.Predicate;
 7 import java.util.function.Supplier;
 8
 9 @Getter
10 @Setter
11 class User {
12     private String username;
13     private int age;
14
15     @Override
16     public String toString() {
17         return "User{" +
18                 "username=‘" + username + ‘\‘‘ +
19                 ", age=" + age +
20                 ‘}‘;
21     }
22 }
23
24 public class InnerInterface {
25
26     /**
27      * 打印user信息
28      */
29     public void print(User user,Consumer<User> userConsumer) {
30         userConsumer.accept(user);
31     }
32
33     /**
34      * 返回一个user
35      */
36     public User getUser(Supplier<User> userSupplier) {
37         return userSupplier.get();
38     }
39
40     /**
41      * 转换一个user
42      */
43     public User transformUser(User user,Function<User,User> function) {
44         return function.apply(user);
45     }
46
47     /**
48      * 检验User是否合法
49      */
50     public boolean checkUser(User user, Predicate<User> predicate) {
51         return predicate.test(user);
52     }
53
54     public static void main(String[] args) {
55
56         User userObj = new User();
57         userObj.setUsername("西门吹雪");
58         userObj.setAge(22);
59
60         // 测试Consumer
61         InnerInterface mainInst = new InnerInterface();
62         mainInst.print(userObj,user -> System.out.println(user));
63
64         // 测试Supplier
65         final User user1 = mainInst.getUser(() -> {
66             User user = new User();
67             user.setUsername("叶孤城");
68             user.setAge(22);
69             return user;
70         });
71         System.out.println(user1);
72
73         // 将西门吹雪的年龄改为25
74         final User user2 = mainInst.transformUser(userObj, (user -> {
75             user.setAge(25);
76             return user;
77         }));
78         System.out.println(user2);
79
80         // 判断User是否是西门吹雪
81         final boolean checkUser = mainInst.checkUser(userObj, (user -> user.getUsername().equals("西门吹雪")));
82         System.out.println(checkUser);
83     }
84 }

　　运行结果：

User{username=‘西门吹雪‘, age=22}
User{username=‘叶孤城‘, age=22}
User{username=‘西门吹雪‘, age=25}
true

　　以上四大核心内置接口是我们日常开发中经常要用到的，同时，它们还有一些变种，如：

　　BiConsumer，Consumer的增强版，接受两个参数：

1 @FunctionalInterface
2 public interface BiConsumer<T, U> {
3
4     void accept(T t, U u);
5 }

　　BiFunction类似，Function的增强版，接受两个参数，返回一个参数：

 1 @FunctionalInterface
 2 public interface BiFunction<T, U, R> {
 3
 4     R apply(T t, U u);
 5
 6     default <V> BiFunction<T, U, V> andThen(Function<? super R, ? extends V> after) {
 7         Objects.requireNonNull(after);
 8         return (T t, U u) -> after.apply(apply(t, u));
 9     }
10 }

　　其他的类似，这些函数式接口都在java.util.function包下，读者可去这个包下去查询。

原文地址：https://www.cnblogs.com/wuhenzhidu/p/lambda.html

时间： 2024-10-20 14:41:35

Java8新特性之一：Lambda表达式的相关文章

java8新特性之——lambda表达式的使用

lambda表达式简介 个人理解,lambda表达式就是一种新的语法,没有什么新奇的,简化了开发者的编码,其实底层还是一些常规的代码.Lambda 是一个匿名函数,我们可以把 Lambda 表达式理解为是一段可以传递的代码(将代码像数据一样进行传递).可以写出更简洁.更灵活的代码.作为一种更紧凑的代码风格,使Java的语言表达能力得到了提升. Lambda表达式的语法(记得要在jdk1.8及以上的jdk环境下实验) Lambda 表达式的基础语法:Java8中引入了一个新的操作符 "->&

好程序员分享java8新特性之Lambda表达式

?.Lambda表达式简介 什么是Lambda? Lambda表达式是Java 8推出的?个新特性.从本质上讲,Lambda表达式是?个匿名函数. 为什么要使?Lambda? 使?Lambda表达式可以对?个接?进??常简洁的实现. 之前我们在给?个接?引?赋值的时候,可以使?接?实现类,或者匿名内部类.但是有了 Lambda表达式,我们可以更加?便的实现这个需求. interface Comparator<T>?{ int compare(T o1, T o2); } class Progr

2020了你还不会Java8新特性？Lambda表达式及API（二）

lambda表达式 为什么要使用lambda表示式 在Java中无法将函数座位参数传递给一个方法,也无法返回一个函数的方法. 在js中,函数的参数是一个函数.返回值是另一个函数的情况是非常常见的.是一门经典的函数式语言. Java匿名内部类. 匿名内部类的介绍 Gradle的使用.可以完全使用maven的中央仓库. 进行安卓的开发时,gradle已经成为标配了. lambda: 匿名内部类 my_jButton.addActionListener(new ActionListener() { @

Java8新特性03 Lambda表达式

一. Lambda表达式概述 Lambda表达式是Java8中最大的变化.它允许我们将一个函数当作方法的参数,或者说把一段代码当作数据使用.很多基于JVM平台的语言一开始就支持Lambda表达式,比如Scala,但是Java语言一直只能使用匿名内部类来替代Lambda表达式,直到Java8才使用Lambda表达式. 二.定义 Lambda表达式是一个匿名函数,它是一个函数式接口的具体实现方式:使用Lambda语法可以用来代替Java8之前的匿名内部类,从而简化代码. 任意只包含一个抽象方法的接口

Java8新特性之lambda表达式

lambda表达式 简化实例化函数式接口(functional interface)的过程 lambda表达式的优势 简化代码的实现 lambda表达式的语法 一个 Lambda 表达式可以有零个或多个参数 参数的类型既可以明确声明,也可以根据上下文来推断.例如:(int a)与(a)效果相同 所有参数需包含在圆括号内,参数之间用逗号相隔.例如:(a, b) 或 (int a, int b) 或 (String a, int b, float c) 空圆括号代表参数集为空.例如:() -> 42

C++11 新特性之 Lambda表达式

lambda表达式可以用于创建并定义匿名的函数对象,以简化编程工作 Lambda的语法如下: [函数对象参数](操作符重载函数参数)->返回值类型{函数体} []内的参数指的是Lambda表达式可以取得的变量.(2)函数中的param就是指函数可以得到在Lambda表达式外的全局变量, 如果在[]中传入=的话,即是可以取得所有的外部变量,如(1)和(3)Lambda表达式 ()内的参数是每次调用函数时传入的参数. ->后加上的是Lambda表达式返回值的类型,如(3)中返回了一个int类型的变

C++11新特性(3) lambda表达式(1)

C++11添加了一项名为lambda表达式的新功能.通过这项功能能编写内嵌的匿名函数,而不必编写独立函数或函数对象,使得代码更加理解. lambda表达式包含以下部分. [capture_block](parameters) mutable exception_specification->return_type {body} 现在分析各个部分的内容: (capture_block)捕捉块:指定如何捕捉所在作用域的变量,并供给lambda主体部分使用. (parameter)参数(可选):lam

JDK1.8新特性(二): Lambda表达式 (参数列表) -&gt; { } 和函数式接口@FunctionalInterface

Lambda表达式 二:简介 JDK的升级的目的有以下几个:增加新的功能.修复bug.性能优化.简化代码等几个方面,Lambda表达式就是属于简化代码,用于简化匿名实现类,提供一种更加简洁的写法.Lambda表达式在Swift语言中称之为代码块,Lambda表达式可以认为是一种特殊的接口,该接口必须只有一个抽象方法. 语法 (参数类型 参数名, 数参数类型 参数名2...) -> { // code }; 小括号()中的内容就是方法中的参数列表包括参数类型.参数名,其中参数类型是可以省略的,当参

Java8新特性之lambda

本系列文章翻译自@shekhargulati的java8-the-missing-tutorial Java8中最重要的特性之一就是引入了lambda表达式.这能够使你的代码更加简练,并允许你将行为传递到各处.一段时间以来,Java因为自身的冗长和缺少函数式编程的能力而受到批评.随着函数式编程变得越来越流行和有价值,Java也在努力接受函数式编程.否则,Java将会变得没有价值. Java8在使世界上最受欢迎的编程语言之一在接纳函数式编程的过程中向前迈了一大步.为了支持函数式编程,编程语言必须将

java8新增特性之lambda表达式

java 1.8 为了顺应函数式编程的大势,简化编码工作量,新增加了lambda 表达式. 由于在java中,函数并不是一等公民,不能独立存在,所以,在java中lambda 也必须依托对象存在,其用得最多的地方,是简化匿名内部类的写法. 1 public class LambdaTest { 2 3 private static MathOperation sayHi = name -> { 4 System.out.println("hi!, "+ name); 5 }; 6