Java语法

Java 语法

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

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

一、三种Java 语法

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

2. Optional 可选值；

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

二、具体使用方法

1、方法引用

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

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

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

 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 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 function1 = content::substring;
21         String result1 = function1.apply(1);
22         System.out.println("content after substring result is: " + result1);
23 
24         // 使用双冒号:: 构造函数引用
25         BiFunction 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 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~拍一拍

运行结果如图所示：

2、Optional可选值

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

 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 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方法来代替构造函数。

 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 的源码：

  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 {
 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 Optional empty() {
 22         @SuppressWarnings("unchecked")
 23         Optional t = (Optional) 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  Optional of(T value) {
 33         return new Optional<>(value);
 34     }
 35 
 36     // 返回一个 Optional指定值的Optional，如果非空，则返回一个空的 Optional
 37     public static  Optional 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(Consumersuper T> consumer) {
 56         if (value != null)
 57             consumer.accept(value);
 58     }
 59 
 60     // 如果一个值存在，并且该值给定的谓词相匹配时，返回一个 Optional描述的值，否则返回一个空的 Optional
 61     public Optional filter(Predicatesuper 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 Optional map(Functionsuper 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 Optional flatMap(Functionsuper T, Optional> 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(Supplierextends T> other) {
 96         return value != null ? value : other.get();
 97     }
 98 
 99     public extends Throwable> T orElseThrow(Supplierextends X> exceptionSupplier) throws X {
100         if (value != null) {
101             return value;
102         } else {
103             throw exceptionSupplier.get();
104         }
105     }
106 }

View Code

 

 

摘下面具的一场对话

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