Java語法

Java 語法

 摘下面具的一場對話，比穿上鎧甲奔赴戰場更須要勇氣。

背景：今天寫接口，看到項目組其餘同窗寫的代碼，發現了一些我從未使用的Java 語法，引覺得戒。

1、三種Java 語法

1. 使用一對冒號 :: 表示方法引用；

2. Optional 可選值；

3. 靜態of 方法代替構造函數。

2、具體使用方法

一、方法引用

方法引用是一種函數式接口的另外一種書寫方式，其經過一對雙冒號:: 來表示，分爲如下三種：

• 靜態方法引用，經過類名::靜態方法名， 如 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<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~拍一拍

運行結果如圖所示：

二、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<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-拍一拍

運行結果以下：

三、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<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

 

 

摘下面具的一場對話

比穿上鎧甲奔赴戰場更須要勇氣