Java 和 Groovy 中的映射map都是非常通用的，它允許關(guān)鍵字key和值value為任意類型，只要繼承了 Object 類即可。

我最近在探索 Java 與 Groovy 在 創(chuàng)建并??初始化列表List?? 和 在??運(yùn)行時構(gòu)建列表List?? 方面的一些差異。我觀察到，就實(shí)現(xiàn)這些功能而言，Groovy 的簡潔和 Java 的繁復(fù)形成了鮮明對比。

在這篇文章中，我將實(shí)現(xiàn)在 Java 和 Groovy 中創(chuàng)建并初始化映射Map。映射為開發(fā)支持根據(jù) 關(guān)鍵字key 檢索的結(jié)構(gòu)提供了可能，如果找到了這樣一個關(guān)鍵字，它就會返回對應(yīng)的 值value。今天，很多編程語言都實(shí)現(xiàn)了映射，其中包括 Java 和 Groovy，也包括了 Python(它將映射稱為 字典dict)、Perl、awk 以及許多其他語言。另一個經(jīng)常被用來描述映射的術(shù)語是 關(guān)聯(lián)數(shù)組associative array，你可以在 這篇維基百科文章 中了解更多。Java 和 Groovy 中的映射都是非常通用的，它允許關(guān)鍵字和值為任意類型，只要繼承了 Object 類即可。

安裝 Java 和 Groovy

Groovy 基于 Java，因此你需要先安裝 Java。你的 Linux 發(fā)行版的倉庫中可能有最近的比較好的 Java 和 Groovy 版本?；蛘撸阋部梢栽诟鶕?jù)上面鏈接中的指示來安裝 Groovy。對于 Linux 用戶來說，SDKMan 是一個不錯的代替選項(xiàng)，你可以使用它來獲取多個 Java 和 Groovy 版本，以及許多其他的相關(guān)工具。在這篇文章中，我使用的 SDK 發(fā)行版是：

• Java: version 11.0.12-open of OpenJDK 11;
• Groovy: version 3.0.8.

言歸正傳

Java 提供了非常多的方式來實(shí)例化和初始化映射，并且從 Java 9 之后，添加了一些新的方式。其中最明顯的方式就是使用 java.util.Map.of() 這個靜態(tài)方法，下面介紹如何使用它：

    var m1 = Map.of(
        "AF", "Afghanistan",
        "AX", "?land Islands",
        "AL", "Albania",
        "DZ", "Algeria",
        "AS", "American Samoa",
        "AD", "Andorra",
        "AO", "Angola",
        "AI", "Anguilla",
        "AQ", "Antarctica");
    System.out.println("m1 = " + m1);
    System.out.println("m1 is an instance of " + m1.getClass());

事實(shí)證明，在此種情況下，Map.of() 有兩個重要的限制。其一，這樣創(chuàng)建出來的映射實(shí)例是不可變的immutable。其二，你最多只能提供 20 個參數(shù)，用來表示 10 個鍵值對key-value pair。

你可以嘗試著添加第 10 對和第 11 對，比方說 "AG", "Antigua and Barbuda" 和 "AR", "Argentina"，然后觀察會發(fā)生什么。你將發(fā)現(xiàn) Java 編譯器嘗試尋找一個支持 11 個鍵值對的 Map.of() 方法而遭遇失敗。

快速查看 java.util.Map 類的文檔，你就會找到上述第二個限制的原因，以及解決這個難題的一種方式：

    var m2 = Map.ofEntries(
        Map.entry("AF", "Afghanistan"),
        Map.entry("AX", "?land Islands"),
        Map.entry("AL", "Albania"),
        Map.entry("DZ", "Algeria"),
        Map.entry("AS", "American Samoa"),
        Map.entry("AD", "Andorra"),
        Map.entry("AO", "Angola"),
        Map.entry("AI", "Anguilla"),
        Map.entry("AQ", "Antarctica"),
        Map.entry("AG", "Antigua and Barbuda"),
        Map.entry("AR", "Argentina"),
        Map.entry("AM", "Armenia"),
        Map.entry("AW", "Aruba"),
        Map.entry("AU", "Australia"),
        Map.entry("AT", "Austria"),
        Map.entry("AZ", "Azerbaijan"),
        Map.entry("BS", "Bahamas"),
        Map.entry("BH", "Bahrain"),
        Map.entry("BD", "Bangladesh"),
        Map.entry("BB", "Barbados")
    );
           
    System.out.println("m2 = " + m2);
    System.out.println("m2 is an instance of " + m2.getClass());

這就是一個比較好的解決方式，前提是我不在隨后的代碼里改變使用 Map.ofEntries() 創(chuàng)建并初始化的映射內(nèi)容。注意，我在上面使用了 Map.ofEntries() 來代替 Map.of()。

然而，假設(shè)我想要創(chuàng)建并初始化一個非空的映射，隨后往這個映射中添加數(shù)據(jù)，我需要這樣做：

var m3 = new HashMap<String,String>(Map.ofEntries(
    Map.entry("AF", "Afghanistan"),
    Map.entry("AX", "?land Islands"),
    Map.entry("AL", "Albania"),
    Map.entry("DZ", "Algeria"),
    Map.entry("AS", "American Samoa"),
    Map.entry("AD", "Andorra"),
    Map.entry("AO", "Angola"),
    Map.entry("AI", "Anguilla"),
    Map.entry("AQ", "Antarctica"),
    Map.entry("AG", "Antigua and Barbuda"),
    Map.entry("AR", "Argentina"),
    Map.entry("AM", "Armenia"),
    Map.entry("AW", "Aruba"),
    Map.entry("AU", "Australia"),
    Map.entry("AT", "Austria"),
    Map.entry("AZ", "Azerbaijan"),
    Map.entry("BS", "Bahamas"),
    Map.entry("BH", "Bahrain"),
    Map.entry("BD", "Bangladesh"),
    Map.entry("BB", "Barbados")
));
System.out.println("m3 = " + m3);
System.out.println("m3 is an instance of " + m3.getClass());
m3.put("BY", "Belarus");
System.out.println("BY: " + m3.get("BY"));

這里，我把使用 Map.ofEntries() 創(chuàng)建出來的不可變映射作為 HashMap 的一個構(gòu)造參數(shù)，以此創(chuàng)建了該映射的一個可變副本mutable copy，之后我就可以修改它 —— 比如使用 put() 方法。

讓我們來看看上述過程如何用 Groovy 來實(shí)現(xiàn)：

    def m1 = [
        "AF": "Afghanistan",
        "AX": "?land Islands",
        "AL": "Albania",
        "DZ": "Algeria",
        "AS": "American Samoa",
        "AD": "Andorra",
        "AO": "Angola",
        "AI": "Anguilla",
        "AQ": "Antarctica",
        "AG": "Antigua and Barbuda",
        "AR": "Argentina",
        "AM": "Armenia",
        "AW": "Aruba",
        "AU": "Australia",
        "AT": "Austria",
        "AZ": "Azerbaijan",
        "BS": "Bahamas",
        "BH": "Bahrain",
        "BD": "Bangladesh",
        "BB": "Barbados"]
    println "m1 = $m1"
    println "m1 is an instance of ${m1.getClass()}"
    m1["BY"] = "Belarus"
    println "m1 = $m1"

只看一眼，你就會發(fā)現(xiàn) Groovy 使用了 def 關(guān)鍵字而不是 var —— 盡管在最近模型late-model的 Groovy(version 3+)中，使用 var 關(guān)鍵字也是可行的。

你還會發(fā)現(xiàn)，你是通過在括號里添加了一個鍵值對列表來創(chuàng)建一個映射的。不僅如此，這樣創(chuàng)建的列表對象還非常有用，這里有幾個原因。其一，它是可變的;其二，它是一個 LinkedHashMap 的實(shí)例，內(nèi)部維持了數(shù)據(jù)的插入順序。所以，當(dāng)你運(yùn)行 Java 版本的代碼并打印出變量 m3，你會看到：

    m3 = {BB=Barbados, BD=Bangladesh, AD=Andorra, AF=Afghanistan, AG=Antigua and Barbuda, BH=Bahrain, AI=Anguilla, AL=Albania, AM=Armenia, AO=Angola, AQ=Antarctica, BS=Bahamas, AR=Argentina, AS=American Samoa, AT=Austria, AU=Australia, DZ=Algeria, AW=Aruba, AX=?land Islands, AZ=Azerbaijan}

而當(dāng)你運(yùn)行 Groovy 版本的代碼，你會看到：

    m1 = [AF:Afghanistan, AX:?land Islands, AL:Albania, DZ:Algeria, AS:American Samoa, AD:Andorra, AO:Angola, AI:Anguilla, AQ:Antarctica, AG:Antigua and Barbuda, AR:Argentina, AM:Armenia, AW:Aruba, AU:Australia, AT:Austria, AZ:Azerbaijan, BS:Bahamas, BH:Bahrain, BD:Bangladesh, BB:Barbados]

再一次，你將看到 Groovy 是如何簡化事情的。這樣的語法非常直觀，有點(diǎn)像 Python 里的字典，并且，即使你有一個超過 10 個鍵值對的初始列表，你也不需要去記住各種必要的別扭方式。注意我們使用的表達(dá)式：

m1[“BY”] = “Belarus”

而在 Java 中，你需要這樣做：

m1.put(“BY”, “Belarus”)

還有，這個映射默認(rèn)是可變的，這么做的利弊很難評判，還是得取決于你的需求是什么。我個人覺得，Java 在這種情況下的 “默認(rèn)不可變” 機(jī)制，最讓我困擾的地方是，它沒有一個類似于 Map.mutableOfMutableEntries() 的方法。這迫使一些剛學(xué)會如何聲明和初始化一個映射的程序員，不得不轉(zhuǎn)念去思考該如何把他們手中不可變的映射，轉(zhuǎn)換為可變的。同時我也想問，創(chuàng)建一個不可變的對象然后再舍棄它，這樣真的好嗎?

另一個值得考慮的事情是，Groovy 使用方括號代替 Java 中的 put() 和 get() 方法來進(jìn)行關(guān)鍵字查找。因此你可以這樣寫：

m1[“ZZ”] = m1[“BY”]

而不需要這樣寫：

m1.put(“ZZ”,m1.get(“BY”))

有時候，就像使用某個類的實(shí)例變量一樣來使用映射中的關(guān)鍵字和值是一個好辦法。設(shè)想你現(xiàn)在有一堆想要設(shè)置的屬性，在 Groovy 中，它們看起來就像下面這樣：

    def properties = [
          verbose: true,
          debug: false,
          logging: false]

然后，你可以改變其中的某個屬性，就像下面這樣：

properties.verbose = false

之所以這樣能工作，是因?yàn)?，只要關(guān)鍵字符合特定的規(guī)則，你就可以省略引號，然后直接用點(diǎn)操作符來代替方括號。盡管這個功能非常有用，也非常好用，它也同時也意味著，如果你要把一個變量作為一個映射的關(guān)鍵字來使用，你就必須把這個變量包裹在圓括號里，就像下面這樣：

def myMap = [(k1): v1, (k2): v2]

是時候告訴勤奮的讀者 Groovy 是一門為編寫腳本而量身定制的語言了。映射通常是腳本中的關(guān)鍵元素，它為腳本提供了查找表lookup table，并且通常起到了作為內(nèi)存數(shù)據(jù)庫的作用。我在這里使用的例子是 ISO 3166 規(guī)定的兩個字母的國家代碼和國家名稱。對在世界上各個國家的互聯(lián)網(wǎng)使用者來說，這些代碼是很熟悉的。此外，假設(shè)我們要編寫一個從日志文件中查找互聯(lián)網(wǎng)主機(jī)名，并借此來了解用戶的地理位置分布的腳本工具，那么這些代碼會是十分有用的部分。

Groovy 相關(guān)資源

Apache Groovy 網(wǎng)站 上有非常多的文檔。另一個很棒的 Groovy 資源是 ??Mr. Haki??。??Baeldung ??網(wǎng)站 提供了大量 Java 和 Groovy 的有用教程。學(xué)習(xí) Groovy 還有一個很棒的原因，那就是可以接著學(xué)習(xí) ???Grails??，后者是一個優(yōu)秀的、高效率的全棧 Web 框架。它基于許多優(yōu)秀組件構(gòu)建而成，比如有 Hibernate、Spring Boot 和 Micronaut 等。