比尔云BierYun--阿里云最新优惠活动
阿里云优惠码丨阿里云代金券

Java8新特性之一:Lambda表达式

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

未经允许不得转载:阿里云代金券 » Java8新特性之一:Lambda表达式

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

强烈推荐

高性能SSD云服务器ECS抗攻击,高可用云数据库RDS