Java 10 大裝 B 寫法，裝逼常用代碼

想不想學習裝 B 式的 Java 騷操作花式寫法？

沒錯，本文堆疊長來教你！

1、集合初始化

集合的創建、賦值一步到位，想不想學？

來，上邊跟我一起畫個 List，在你下邊畫一個Map……

 List<String> list = new ArrayList<String>() {
{   
 add("www.");   
 add("javastack.");   
 add("cn");
}
};
Map<String, String> map = new HashMap<String, String>() {
{   
 put("1", "www.");    
put("2", "javastack.");    
put("3", "cn");
}
};

哈哈，高大上的寫法，堆疊長以前寫過，寫法雖然是很裝X，然而并沒有什么卵用，

2、算術

static {    
final int size = -(-128) + 127 + 1;    // Load and use the archived cache if it exists    VM.initializeFromArchive(ByteCache.class);    
if (archivedCache == null || archivedCache.length != size) {        Byte[] c = new Byte[size];        
byte value = https://www.cnblogs.com/coderhf/p/(byte)-128;       
for(int i = 0; i < size; i++) {           
 c[i] = new Byte(value++);       
 }       
 archivedCache = c;   
 }    
cache = archivedCache;}

注意到上面size的寫法沒有？

明明可以寫成：

 final int size = 256;

他非要寫成：

 final int size = -(-128) + 127 + 1;

這么裝 B 的寫法來自 JDK 包裝類java.lang.Byte里面的靜態方法，

為什么要這么寫呢？

這樣的寫法在 JDK 里面有很多，大家看到這些寫法都會覺得很奇怪，Java技術堆疊微信群里、知識星球里面有曾有粉絲問我這是為什么，

真正緣由無從考察，但堆疊長我覺得寫 JDK 的大神其實就想告訴你，Byte 的 256 個數是由 -128 ~ 127 這個范圍組成的，起到一個標識數字范圍的作用而已，

如果你知道其中的更多道道，歡迎留言分享！

3、移位

/** * The default initial capacity - MUST be a power of two. */
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16/** * The maximum capacity, used if a higher value is implicitly specified * by either of the constructors with arguments. * MUST be a power of two <= 1<<30. */static final int MAXIMUM_CAPACITY = 1 << 30;

這兩個變數來自java.util.HashMap原始碼，你可能也非常好奇為什么不直接寫成數字，要弄一個移位騷操作？

這是在告訴開發者，HashMap 的容量大小必須是 2 的冪次，不然會造成空間浪費，

以上同樣來自java.util.HashMap的原始碼，為什么不直接用values：

 transient Collection<V> values;public Collection<V> values() {   
 if (values == null) {       
 values = new Values(); 
   }  
  return values;
}

而要重新定義一個vs來繞一個彎呢？

這樣寫不是更簡單么？

JDK里面大量這樣的寫法，這是為什么呢？！

那是因為操作區域變數要比讀取全域變數要更快，另外，我個人覺得還有一個好處，再申明一下區域變數，可以很明顯的看到這個變數的型別，而不要翻到上面或者用滑鼠移上去來看變數型別，

另外提一點，上面的復制變數再操作的方式讓我想到了CopyOnWriteArrayList，這也是讓當前變數不被其他執行緒改變保證當前執行緒變數一致性的一種方式，

寫 JDK 原始碼的都是大神啊，透過原始碼，我們能學到太多東西！

5、泛型

來看一段泛型的靈活運用：

 public <R> Observable<R> compose(Transformer<? super T, ? extends R> transformer) {    
return ((Transformer<T, R>) transformer).call(this);
}

這個泛型方法寫得牛 X 吧，泛型 T、R、通配符（?）、上邊界（extends）和下邊界（super）都用上了！

常用的泛型含義：

• T - Type（型別）

• R - Result（結果）

• K - Key（鍵）

• V - Value（值）

• E - Element (元素)

• N - Number（數字）

• ? - 不確定型別

泛型要學會用，學好能裝B，

6、Lambda

Lambda 運算式這是 Java 8 里面添加的新特性，用來簡化匿名內部類以及結合函式式介面編程用的，

如下面創建執行緒的示例：

 // 1Runnable runnable = () -> System.out.println("javastack.cn");
new Thread(runnable).start();// 2new Thread(() -> System.out.println("javastack.cn")).start();// 3new Thread(() -> clean()).start();

三個不同的寫法，我們再也不用寫new Runnable()的一大堆 的匿名內部類了，是不是很清爽了！

如果你還不會用Lambda運算式，那真的 OUT 了，可以關注微信公眾號：Java技術堆疊，在后臺回復：新特性，我已經寫了一大堆教程了，

下面是一個Lambada真實案例：

@Beanpublic CommandLineRunner commandLineRunner(NettyServer nettyServer) {    
return (args) -> {        
Thread thread = new Thread(() -> nettyServer.start());        thread.setDaemon(true);        
thread.start();   
 };
}

上述示例省去了 newCommandLineRunner的匿名內部類的程序，

7、函式式編程

上面有提到函式式編程，這是 Java 8 里面添加的新特性，我之前在公眾號里已經寫過很多 Java 新特性的教程，這也不是新玩法了，已經被玩爛了，

來看一個真實的案例，來自 Spring Boot 的郵件發送自動配置：

 private void applyProperties(JavaMailSenderImpl sender) {    PropertyMapper map = PropertyMapper.get();    map.from(this.properties::getHost).to(sender::setHost);    map.from(this.properties::getPort).whenNonNull().to(sender::setPort);    map.from(this.properties::getUsername).to(sender::setUsername);    map.from(this.properties::getPassword).to(sender::setPassword);    map.from(this.properties::getProtocol).to(sender::setProtocol);    map.from(this.properties::getDefaultEncoding).whenNonNull().as(Charset::name)            .to(sender::setDefaultEncoding);    map.from(this.properties::getProperties).whenNot(Map::isEmpty)            .as(this::asProperties).to(sender::setJavaMailProperties);}

第一次看到這段代碼的時候，我內心是拒絕的，很難理解，

上面的 from 和 to 方法分別用到了Supplier和Consumer函式式介面，還用到了雙冒號::結合使用，諱莫如深，還能結合Lambda運算式使用，

函式式編程很厲害，雖然會用，但到現在我也覺得很高深，可讀性和可理解性太差了，但是，裝 X 必學、必用，

8、流關閉

 MyInputStream mis = new MyInputStream();MyOutputStream mos = new MyOutputStream();try (mis; mos) {    mis.read("1.9");    mos.write("1.9");} catch (Exception e) {    e.printStackTrace();}

沒錯，你看到的這個關閉流騷操作是 Java 9 的新語法糖，較 Java 7 又簡化了try-with-resources用法，裝 X 的姿勢越來越多了，

9、型別推斷

關注Java技術堆疊公眾號的老讀者應該都看過，Java 10 剛出來的時候，我寫過兩篇新特性文章：

• Java 10的10個新特性，將徹底改變你寫代碼的方式！

• Java 10 實戰第 1 篇：區域變數型別推斷

來，我再挑兩個示例來欣賞下：

示例1：

 var javastack = "javastack";

示例2：

 private static void testLoop() {    for (var i = 0; i < 3; i++) {        for (var m = 10; m < 15; m++) {            System.out.println(i + m);        }    }}

這樣寫會不會被打？也太省事了！

型別推斷出來后，都說 Java 越來越像 Javascript 了，其實就是 Java 10 增加的一種語法糖而已，在編譯期間會自動推斷實際型別，其編譯后的位元組碼和實際型別一致，

10、模式匹配

instanceof模式是匹配這是 Java 14 推出來的新特性：

 if (object instanceof Kid kid) {    // ...} else if (object instanceof Kiddle kiddle) {    // ...}

匹配后直接創建物件和賦值直接拿來用，不需要再添加強制轉換的代碼，大大提高了可讀性和安全性，

更多學習內容請閱讀我的知乎專欄：打造全網Java高級工程師資料庫（總目錄）看完學的更加快，知識更牢固，你值得擁有（持續更新）~

標籤：Java

上一篇：一個老程式員在互聯網寒冬下的感悟

下一篇：JDK路徑設定無效問題解決