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

沒錯，本文LZ來教你！

1、集合初始化

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

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

<code>List<string> list = new ArrayList<string>() {{
    add("www.");
    add("javastack.");
    add("cn");
}};

Map<string> map = new HashMap<string>() {{
    put("1", "www.");
    put("2", "javastack.");
    put("3", "cn");
}};/<string>/<string>/<string>/<string>/<code>

哈哈，高大上的寫法，LZ以前寫過，寫法雖然是很裝X，然而並沒有什麼卵用。

2、算術

<code>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 = (byte)-128;
        for(int i = 0; i < size; i++) {
            c[i] = new Byte(value++);
        }
        archivedCache = c;
    }
    cache = archivedCache;
}/<code>

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

明明可以寫成：

<code>final int size = 256;/<code>

他非要寫成：

<code>final int size = -(-128) + 127 + 1;/<code>

這麼裝 B 的寫法來自 JDK 包裝類java.lang.Byte裡面的靜態方法。

為什麼要這麼寫呢？

這樣的寫法在 JDK 裡面有很多，大家看到這些寫法都會覺得很奇怪，曾有粉絲問我這是為什麼。

真正緣由無從考察，但LZ我覺得寫 JDK 的大神其實就想告訴你，Byte 的 256 個數是由 -128 ~ 127 這個範圍組成的，起到一個標識數字範圍的作用而已。至少 Byte 為什麼取這個範圍，為什麼byte取值-128~127??這篇文章可以解密。

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

3、移位

<code>/**
 * 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;/<code>

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

這是在告訴開發者，HashMap 的容量大小必須是 2 的冪次，不然會造成空間浪費。另外，HashMap 容量為什麼總是為 2 的次冪？這篇推薦看下。

4、複製變量

<code>transient Collection values;

public Collection values() {
    Collection vs = values;
    if (vs == null) {
        vs = new Values();
        values = vs;
    }
    return vs;
}/<code>

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

<code>transient Collection values;

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

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

這樣寫不是更簡單麼？

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

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

另外提一點，上面的複製變量再操作的方式讓我想到了CopyOnWriteArrayList，這也是讓當前變量不被其他線程改變保證當前線程變量一致性的一種方式。

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

5、泛型

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

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

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

常用的泛型含義：

• T - Type（類型）
• R - Result（結果）
• K - Key（鍵）
• V - Value（值）
• E - Element (元素)
• N - Number（數字）
• ? - 不確定類型

上面的泛型我們應該有常見到吧，邊界和通配符不懂的可以看下這篇文章吧：困擾我多年的Java泛型 和 ，終於搞清楚了。

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

6、Lambda

Lambda 表達式這是 Java 8 裡面添加的新特性，用來簡化匿名內部類以及結合函數式接口編程用的。

如下面創建線程的示例：

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

// 2
new Thread(() -> System.out.println("javastack.cn")).start();

// 3
new Thread(() -> clean()).start();/<code> 

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

如果你還不會用Lambda表達式，那真的 OUT 了，

下面是一個Lambada真實案例：

<code>@Bean
public CommandLineRunner commandLineRunner(NettyServer nettyServer) {
    return (args) -> {
        Thread thread = new Thread(() -> nettyServer.start());
        thread.setDaemon(true);
        thread.start();
    };
}/<code>

上述示例省去了 newCommandLineRunner的匿名內部類的過程。

7、函數式編程

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

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

<code>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);
}/<code>

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

上面的 from 和 to 方法分別用到了Supplier和Consumer函數式接口，還用到了雙冒號::結合使用，諱莫如深，還能結合Lambda表達式使用。

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

8、流關閉

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

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

不知道的可能上來就一頓罵了，你流關閉動作在哪，為什麼不關閉流，多跟著LZ學點新知識吧，哈哈。

9、類型推斷

老讀者應該都看過，Java 10 剛出來的時候，我寫過兩篇新特性文章：

• Java 10的10個新特性，將徹底改變你寫代碼的方式！
• Java 10 實戰第 1 篇：局部變量類型推斷

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

示例1：

<code>var javastack = "javastack";/<code>

示例2：

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

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

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

10、模式匹配

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

<code>if (object instanceof Kid kid) { 

    // ...
} else if (object instanceof Kiddle kiddle) {
    // ...
}/<code>

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

好了，今天我就裝到這了，關注Java技術劍頭條公眾號，LZ將繼續分享好玩的 Java 技術。

LZ整理不易，覺得文章不錯，

轉發分享給更多的朋友們，總能幫助有需要的人，大家一起流弊~

閱讀更多 JAVA技術劍 的文章

關鍵字: 寫法 吹牛 大裝