Java 语法

 摘下面具的一场对话,比穿上铠甲奔赴战场更需要勇气。

背景:今天写接口,看到项目组其他同学写的代码,发现了一些我从未使用的Java 语法,引以为戒。

一、三种Java 语法

1. 使用一对冒号 :: 表示方法引用;

2. Optional 可选值;

3. 静态of 方法代替构造函数。

二、具体使用方法

1、方法引用

方法引用是一种函数式接口的另一种书写方式,其通过一对双冒号:: 来表示,分为以下三种:

  • 静态方法引用,通过类名::静态方法名, 如 Integer::parseInt
  • 实例方法引用,通过实例对象::实例方法,如 str::substring
  • 构造方法引用,通过类名::new, 如 User::new

通过方法引用,可以将方法的引用赋值给一个变量,通过赋值给Function,说明方法引用也是一种函数式接口的书写方式,Lambda表达式也是一种函数式接口,Lambda表达式一般用于自己提供方法体,而方法引用一般直接引用现成的方法。

Java语法-LMLPHPJava语法-LMLPHP
 1 package com.tjt.jvm;
 2
 3 import java.util.function.BiFunction;
 4 import java.util.function.Function;
 5
 6 /**
 7  * @time:2020-08-21
 8  * @author apple
 9  */
10 public final class MethodReference {
11
12     public static void main(String[] args) {
13         // 使用双冒号::来构造静态函数引用
14         Function<String, Integer> function = Integer::parseInt;
15         Integer result = function.apply("18");
16         System.out.println("String 18 parseInt result is: " + result);
17
18         // 使用双冒号::来构造非静态函数引用
19         String content = "UKing in the North";
20         Function<Integer, String> function1 = content::substring;
21         String result1 = function1.apply(1);
22         System.out.println("content after substring result is: " + result1);
23
24         // 使用双冒号:: 构造函数引用
25         BiFunction<String, Integer, MethodReference> biFun = MethodReference::new;
26         MethodReference result2 = biFun.apply("维沃-vivo", 72087963);
27         System.out.println("method constructor result is: " + result2);
28
29         // 函数引用也是一种函数式接口,所以也可以将函数引用作为方法的参数
30         yellBabe(String::toLowerCase, "WHAT-THE-FUCK");
31     }
32
33     private static void yellBabe(Function<String, String> func, String param) {
34         System.out.println(func.apply(param));
35     }
36
37     private String workName;
38     private Integer workNumber;
39
40     public MethodReference(String workName, Integer workNumber) {
41         this.workName = workName;
42         this.workNumber = workNumber;
43     }
44
45     @Override
46     public String toString() {
47         return "MethodReference{" +
48                 "workName='" + workName + '\'' +
49                 ", workNumber=" + workNumber +
50                 '}';
51     }
52
53 }
View Code~拍一拍

运行结果如图所示

Java语法-LMLPHP

2、Optional可选值

在Google Guava 中就有Optional,在Swift语言中也有这样类似的语法,其将可选值作为一种数据类型,地位和基本类型差不多。

Java语法-LMLPHPJava语法-LMLPHP
 1 package com.tjt.jvm;
 2
 3 import java.util.Optional;
 4
 5 /**
 6  * @author apple
 7  * @time:2020-08-21
 8  */
 9 public class OptionalDemon {
10
11     /**
12      * Optional用来解决空指针异常,使代码更加严谨,
13      * 防止因为空指针NullPointerException对代码造成影响
14      *
15      * @param args
16      */
17     public static void main(String[] args) {
18         String msg = "try-and-stop-me";
19         Optional<String> optional = Optional.of(msg);
20         // 判断是否有值,不为空
21         boolean present = optional.isPresent();
22         System.out.println("msg is null: " + present);
23
24         // 如果有值,则返回值,如果等于空则抛异常
25         String value = optional.get();
26         System.out.println("value is: " + value);
27
28         // 如果为空,返回else指定的值
29         String result = optional.orElse("I am null");
30         System.out.println("result is: " + result);
31
32         // 如果值不为空,就执行Lambda表达式
33         optional.ifPresent(opt -> System.out.println(opt));
34
35     }
36 }
View Code-拍一拍

运行结果如下

3、of 方法

关于of 方法,就是提供一个static方法,方法名称叫of,方法的返回值返回当前类,并且把构造函数设置为私有private,用静态of方法来代替构造函数。

Java语法-LMLPHPJava语法-LMLPHP
 1 package com.tjt.jvm;
 2
 3 /**
 4  * @author apple
 5  * @time:2020-08-21
 6  */
 7 public class OfDemon {
 8
 9     private String nickName;
10     private long money;
11
12     public OfDemon(String nickName, long money) {
13         this.nickName = nickName;
14         this.money = money;
15     }
16
17     private OfDemon() {
18     }
19
20     public static OfDemon of() {
21         return new OfDemon();
22     }
23
24     public static OfDemon of(String nickName, long money) {
25         return new OfDemon(nickName, money);
26     }
27
28
29 }
View Code-拍一拍

下面是Optional 的源码:

Java语法-LMLPHPJava语法-LMLPHP
  1 package java.util;
  2
  3 import java.util.function.Consumer;
  4 import java.util.function.Function;
  5 import java.util.function.Predicate;
  6 import java.util.function.Supplier;
  7
  8 /**
  9  * @since 1.8
 10  */
 11 public final class Optional<T> {
 12     private static final Optional<?> EMPTY = new Optional<>();
 13
 14     private final T value;
 15
 16     private Optional() {
 17         this.value = null;
 18     }
 19
 20     // 返回一个空的 Optional实例
 21     public static<T> Optional<T> empty() {
 22         @SuppressWarnings("unchecked")
 23         Optional<T> t = (Optional<T>) EMPTY;
 24         return t;
 25     }
 26
 27     private Optional(T value) {
 28         this.value = Objects.requireNonNull(value);
 29     }
 30
 31     // 返回具有 Optional的当前非空值的Optional
 32     public static <T> Optional<T> of(T value) {
 33         return new Optional<>(value);
 34     }
 35
 36     // 返回一个 Optional指定值的Optional,如果非空,则返回一个空的 Optional
 37     public static <T> Optional<T> ofNullable(T value) {
 38         return value == null ? empty() : of(value);
 39     }
 40
 41     // 如果Optional中有一个值,返回值,否则抛出 NoSuchElementException 。
 42     public T get() {
 43         if (value == null) {
 44             throw new NoSuchElementException("No value present");
 45         }
 46         return value;
 47     }
 48
 49     // 返回true如果存在值,否则为 false
 50     public boolean isPresent() {
 51         return value != null;
 52     }
 53
 54     // 如果存在值,则使用该值调用指定的消费者,否则不执行任何操作。
 55     public void ifPresent(Consumer<? super T> consumer) {
 56         if (value != null)
 57             consumer.accept(value);
 58     }
 59
 60     // 如果一个值存在,并且该值给定的谓词相匹配时,返回一个 Optional描述的值,否则返回一个空的 Optional
 61     public Optional<T> filter(Predicate<? super T> predicate) {
 62         Objects.requireNonNull(predicate);
 63         if (!isPresent())
 64             return this;
 65         else
 66             return predicate.test(value) ? this : empty();
 67     }
 68
 69     // 如果存在一个值,则应用提供的映射函数,如果结果不为空,则返回一个 Optional结果的 Optional 。
 70     public<U> Optional<U> map(Function<? super T, ? extends U> mapper) {
 71         Objects.requireNonNull(mapper);
 72         if (!isPresent())
 73             return empty();
 74         else {
 75             return Optional.ofNullable(mapper.apply(value));
 76         }
 77     }
 78
 79     // 如果一个值存在,应用提供的 Optional映射函数给它,返回该结果,否则返回一个空的 Optional 。
 80     public<U> Optional<U> flatMap(Function<? super T, Optional<U>> mapper) {
 81         Objects.requireNonNull(mapper);
 82         if (!isPresent())
 83             return empty();
 84         else {
 85             return Objects.requireNonNull(mapper.apply(value));
 86         }
 87     }
 88
 89     // 如果值存在,就返回值,不存在就返回指定的其他值
 90     public T orElse(T other) {
 91         return value != null ? value : other;
 92     }
 93
 94
 95     public T orElseGet(Supplier<? extends T> other) {
 96         return value != null ? value : other.get();
 97     }
 98
 99     public <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier) throws X {
100         if (value != null) {
101             return value;
102         } else {
103             throw exceptionSupplier.get();
104         }
105     }
106 }
View Code

摘下面具的一场对话

比穿上铠甲奔赴战场更需要勇气

08-21 13:16