聊聊 Java 中 HashMap 初始化的另一種方式
如果你接觸過不同的語言，從語法和程式碼層面來說，Java 是一種不折不扣的“臃腫、囉嗦”的語言，從另一方面來說這種臃腫和囉嗦也體現了它嚴謹的一面，作為適合構建大型、複雜專案的理由之一。
1、HashMap 初始化的文藝寫法
HashMap 是一種常用的資料結構，一般用來做資料字典或者 Hash 查詢的容器。普通青年一般會這麼初始化：
HashMap<String, String> map = new HashMap<String, String>();
map.put("Name", "June");
map.put("QQ", "2572073701");看完這段程式碼，很多人都會覺得這麼寫太囉嗦了，對此，文藝青年一般這麼來了：
HashMap<String, String> map = new HashMap<String, String>() {
{
put("Name", "June");
put("QQ", "2572073701");
}
};嗯，看起來優雅了不少，一步到位，一氣呵成的趕腳。然後問題來了，有童鞋會問：納尼？這裡的雙括號到底什麼意思，什麼用法呢？哈哈，其實很簡單，看看下面的程式碼你就知道啥意思了。
public class Test { /*private static HashMap<String, String> map = new HashMap<String, String>() { { put("Name", "June"); put("QQ", "2572073701"); } };*/ public Test() { System.out.println("Constructor called：構造器被呼叫"); } static { System.out.println("Static block called：靜態塊被呼叫"); } { System.out.println("Instance initializer called：例項初始化塊被呼叫"); } public static void main(String[] args) { new Test(); System.out.println("======================="); new Test(); } }
output:
Static block called：靜態塊被呼叫
Instance initializer called：例項初始化被呼叫
Constructor called：構造器被呼叫
=======================
Instance initializer called：例項初始化被呼叫
Constructor called：構造器被呼叫Note：關於 static 的作用與用法如果不瞭解，請參考：
http://my.oschina.net/leejun2005/blog/193439#OSC_h3_1 為什麼 main 方法是 public static void？
http://my.oschina.net/leejun2005/blog/144349#OSC_h3_2 設計模式之：聊聊 java 中的單例模式（Singleton）
也就是說第一層括弧實際是定義了一個匿名內部類 (Anonymous Inner Class)，第二層括弧實際上是一個例項初始化塊 (instance initializer block)，這個塊在內部匿名類構造時被執行。這個塊之所以被叫做“例項初始化塊”是因為它們被定義在了一個類的例項範圍內。 上面程式碼如果是寫在 Test 類中，編譯後你會看到會生成 Test$1.class 檔案，反編譯該檔案內容：
D:eclipse_indigoworkspace_homeCDHJobsbinpvuv>jad -p Test$1.class
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: Test.java
package pvuv.zhaopin;
import java.util.HashMap;
// Referenced classes of package pvuv.zhaopin:
// Test
class Test$1 extends HashMap // 建立了一個 HashMap 的子類
{
Test$1()
{ // 第二個 {} 中的程式碼放到了構造方法中去了
put("Name", "June");
put("QQ", "2572073701");
}
}
D:eclipse_indigoworkspace_homeCDHJobsbinpvuv>2、推而廣之
這種寫法，推而廣之，在初始化 ArrayList、Set 的時候都可以這麼玩，比如你還可以這麼玩：
List<String> names = new ArrayList<String>() {
{
for (int i = 0; i < 10; i++) {
add("A" + i);
}
}
};
System.out.println(names.toString()); // [A0, A1, A2, A3, A4, A5, A6, A7, A8, A9]3、Java7：增加對 collections 的支援
在 Java 7 中你可以像 Ruby, Perl、Python 一樣建立 collections 了。
Note：這些集合是不可變的。
PS：由於原文[5]作者並沒有標出 java 7 哪個小版本號引入的這些新特性，對於留言報錯的同學，請嘗試大於 1.7.0_09 或者 java8 試試？
List<String> list = new ArrayList<String>();
list.add("item");
String item = list.get(0);
Set<String> set = new HashSet<String>();
set.add("item");
Map<String, Integer> map = new HashMap<String, Integer>();
map.put("key", 1);
int value = map.get("key");
// 現在你還可以：
List<String> list = ["item"];
String item = list[0];
Set<String> set = {"item"};
Map<String, Integer> map = {"key" : 1};
int value = map["key"];4、文藝寫法的潛在問題
文章開頭提到的文藝寫法的好處很明顯就是一目瞭然。這裡來羅列下此種方法的壞處，如果這個物件要序列化，可能會導致序列化失敗。 1.此種方式是匿名內部類的宣告方式，所以引用中持有著外部類的引用。所以當時序列化這個集合時外部類也會被不知不覺的序列化，當外部類沒有實現serialize介面時，就會報錯。 2.上例中，其實是聲明瞭一個繼承自HashMap的子類。然而有些序列化方法，例如要通過Gson序列化為json，或者要序列化為xml時，類庫中提供的方式，是無法序列化Hashset或者HashMap的子類的，從而導致序列化失敗。解決辦法：重新初始化為一個HashMap物件：
new HashMap(map);這樣就可以正常初始化了。
5、執行效率問題
當一種新的工具或者寫法出現時，猿們都會來一句：效能怎麼樣？（這和男生談論妹紙第一句一般都是：“長得咋樣？三圍多少？”一個道理:)） 關於這個兩種寫法我這邊筆記本上測試文藝寫法、普通寫法分別建立 10,000,000 個 Map 的結果是 1217、1064，相差 13%。
public class Test {
public static void main(String[] args) {
long st = System.currentTimeMillis();
/*
for (int i = 0; i < 10000000; i++) {
HashMap<String, String> map = new HashMap<String, String>() {
{
put("Name", "June");
put("QQ", "2572073701");
}
};
}
System.out.println(System.currentTimeMillis() - st); // 1217
*/
for (int i = 0; i < 10000000; i++) {
HashMap<String, String> map = new HashMap<String, String>();
map.put("Name", "June");
map.put("QQ", "2572073701");
}
System.out.println(System.currentTimeMillis() - st); // 1064
}
}6、由例項初始化塊聯想到的一些變數初始化問題
從程式碼上看，a 為什麼可以不先宣告型別？你覺得 a、b、c 的值分別是多少？能說明理由麼？
TIPS：如果你對這塊機制不瞭解，建議試著反編譯一下位元組碼檔案。
6.1 測試原始碼
public class Test {
int e = 6;
Test() {
int c = 1;
this.f = 5;
int e = 66;
}
int f = 55;
int c = 11;
int b = 1;
{
a = 3;
b = 22;
}
int a = 33;
static {
d = 4;
}
static int d = 44;
int g = 7;
int h = 8;
public int test(){
g = 77;
int h = 88;
System.out.println("h - 成員變數：" + this.h);
System.out.println("h - 區域性變數: " + h);
return g;
}
public static void main(String[] args) {
System.out.println("a: " + new Test().a);
System.out.println("b: " + new Test().b);
System.out.println("c: " + new Test().c);
System.out.println("d: " + new Test().d);
System.out.println("f: " + new Test().f);
System.out.println("e: " + new Test().e);
System.out.println("g: " + new Test().test());
}
}6.2 位元組碼反編譯：
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: Test.java
import java.io.PrintStream;
public class Test
{
Test()
{
this.e = 6;
f = 55;
this.c = 11;
b = 1;
a = 3;
b = 22;
a = 33;
g = 7;
h = 8;
int c = 1;
f = 5;
int e = 66;
}
public int test()
{
g = 77;
int h = 88;
System.out.println((new StringBuilder("h - u6210u5458u53D8u91CFuFF1A")).append(this.h).toString());
System.out.println((new StringBuilder("h - u5C40u90E8u53D8u91CF: ")).append(h).toString());
return g;
}
public static void main(String args[])
{
System.out.println((new StringBuilder("a: ")).append((new Test()).a).toString());
System.out.println((new StringBuilder("b: ")).append((new Test()).b).toString());
System.out.println((new StringBuilder("c: ")).append((new Test()).c).toString());
new Test();
System.out.println((new StringBuilder("d: ")).append(d).toString());
System.out.println((new StringBuilder("f: ")).append((new Test()).f).toString());
System.out.println((new StringBuilder("e: ")).append((new Test()).e).toString());
System.out.println((new StringBuilder("g: ")).append((new Test()).test()).toString());
}
int e;
int f;
int c;
int b;
int a;
static int d = 4;
int g;
int h;
static
{
d = 44;
}
}6.3 output：
a: 33
b: 22
c: 11
d: 44
f: 5
e: 6
h - 成員變數：8
h - 區域性變數: 88
g: 777、Refer:
[1]Double Brace Initialization In Java! http://viralpatel.net/blogs/double-brace-initialization-in-java/
[2]Double Brace Initialization Idiom and its Drawbacks http://java.dzone.com/articles/double-brace-initialization
[3]Hidden Features of Java http://stackoverflow.com/questions/15496/hidden-features-of-java
[4]Java 大括號語法糖 http://my.oschina.net/trydofor/blog/79222
[5]Java 7 的新特性：http://code.joejag.com/2009/new-language-features-in-java-7/
http://www.iteye.com/news/11490-java-7?page=5
[6]java map雙括號初始化方式的問題 http://blog.csdn.net/liubo2012/article/details/8591956
[7]Efficiency of Java “Double Brace Initialization”? http://stackoverflow.com/questions/924285/efficiency-of-java-double-brace-initialization
[8]初始化程式碼塊中的變數，為什麼可以不需要宣告資料型別？ http://segmentfault.com/q/1010000000580267
[9]Java 8速查表 http://www.importnew.com/12156.html
[10] Java 8新特性之旅：使用Stream API處理集合 http://www.importnew.com/16545.html