1. Map<String, String> map = new HashMap() {{
  2.     put("map1", "value1");
  3.     put("map2", "value2");
  4.     put("map3", "value3");
  5. }};
  6. map.forEach((k, v) -> {
  7.     System.out.println("key:" + k + " value:" + v);
  8. });

本来是用它来替代下面这段代码的：

  1. Map<String, String> map = new HashMap();
  2. map.put("map1", "value1");
  3. map.put("map2", "value2");
  4. map.put("map3", "value3");
  5. map.forEach((k, v) -> {
  6.     System.out.println("key:" + k + " value:" + v);
  7. });

两块代码的执行结果也是完全一样的：

key:map3 value:value3 key:map2 value:value2 key:map1 value:value1

双花括号初始化分析

首先，我们来看使用双花括号初始化的本质是什么？
以我们这段代码为例：

  1. Map<String, String> map = new HashMap() {{
  2.     put("map1", "value1");
  3.     put("map2", "value2");
  4.     put("map3", "value3");
  5. }};

这段代码其实是创建了匿名内部类，然后再进行初始化代码块。
这一点我们可以使用命令 javac 将代码编译成字节码之后发现，我们发现之前的一个类被编译成两个字节码（.class）文件，如下图所示：
不要使用双花括号初始化实例 - 图1

我们使用 Idea 打开 DoubleBracket$1.class 文件发现：

  1. import java.util.HashMap;
  2. class DoubleBracket$1 extends HashMap {
  3.     DoubleBracket$1(DoubleBracket var1) {
  4.         this.this$0 = var1;
  5.         this.put("map1", "value1");
  6.         this.put("map2", "value2");
  7.     }
  8. }

此时我们可以确认，它就是一个匿名内部类。那么问题来了，匿名内部类为什么会导致内存溢出呢？

匿名内部类的“锅”

在 Java 语言中非静态内部类会持有外部类的引用，从而导致 GC 无法回收这部分代码的引用，以至于造成内存溢出。

思考 1：为什么要持有外部类？

这个就要从匿名内部类的设计说起了，在 Java 语言中，非静态匿名内部类的主要作用有两个。
1、当匿名内部类只在外部类（主类）中使用时，匿名内部类可以让外部不知道它的存在，从而减少了代码的维护工作。
2、当匿名内部类持有外部类时，它就可以直接使用外部类中的变量了，这样可以很方便的完成调用，如下代码所示：

  1. public class DoubleBracket {
  2.     private static String userName = "磊哥";
  3.     public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
  4.         Map<String, String> map = new HashMap() {{
  5.             put("map1", "value1");
  6.             put("map2", "value2");
  7.             put("map3", "value3");
  8.             put(userName, userName);
  9.         }};
  10.     }
  11. }

从上述代码可以看出在 HashMap 的方法内部，可以直接使用外部类的变量 userName。

思考 2：它是怎么持有外部类的？

关于匿名内部类是如何持久外部对象的，我们可以通过查看匿名内部类的字节码得知，我们使用 javap -c DoubleBracket\$1.class 命令进行查看，其中 $1 为以匿名类的字节码，字节码的内容如下；

  1. javap -c DoubleBracket\$1.class
  2. Compiled from "DoubleBracket.java"
  3. class com.example.DoubleBracket$1 extends java.util.HashMap {
  4.   final com.example.DoubleBracket this$0;
  5.   com.example.DoubleBracket$1(com.example.DoubleBracket);
  6.     Code:
  7.        0: aload_0
  8.        1: aload_1
  9.        2: putfield      #1                  // Field this$0:Lcom/example/DoubleBracket;
  10.        5: aload_0
  11.        6: invokespecial #7                  // Method java/util/HashMap."<init>":()V
  12.        9: aload_0
  13.       10: ldc           #13                 // String map1
  14.       12: ldc           #15                 // String value1
  15.       14: invokevirtual #17                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
  16.       17: pop
  17.       18: aload_0
  18.       19: ldc           #21                 // String map2
  19.       21: ldc           #23                 // String value2
  20.       23: invokevirtual #17                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
  21.       26: pop
  22.       27: return
  23. }

其中，关键代码的在 putfield 这一行，此行表示有一个对 DoubleBracket 的引用被存入到 this$0 中，也就是说这个匿名内部类持有了外部类的引用。

如果您觉得以上字节码不够直观，没关系，我们用下面的实际的代码来证明一下：

  1. import java.lang.reflect.Field;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. public class DoubleBracket {
  5.     public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
  6.         Map map = new DoubleBracket().createMap();
  7.         // 获取一个类的所有字段
  8.         Field field = map.getClass().getDeclaredField("this$0");
  9.         // 设置允许方法私有的 private 修饰的变量
  10.         field.setAccessible(true);
  11.         System.out.println(field.get(map).getClass());
  12.     }
  13.     public Map createMap() {
  14.         // 双花括号初始化
  15.         Map map = new HashMap() {{
  16.             put("map1", "value1");
  17.             put("map2", "value2");
  18.             put("map3", "value3");
  19.         }};
  20.         return map;
  21.     }
  22. }

当我们开启调试模式时，可以看出 map 中持有了外部对象 DoubleBracket，如下图所示：
不要使用双花括号初始化实例 - 图2
以上代码的执行结果为：

class com.example.DoubleBracket

从以上程序输出结果可以看出：匿名内部类持有了外部类的引用，因此我们才可以使用 $0 正常获取到外部类，并输出相关的类信息。

什么情况会导致内存泄漏？

当我们把以下正常的代码（无返回值）：

  1. public void createMap() {
  2.     Map map = new HashMap() {{
  3.         put("map1", "value1");
  4.         put("map2", "value2");
  5.         put("map3", "value3");
  6.     }};
  7.     // 业务处理....
  8. }

改为下面这个样子时（返回了 Map 集合），可能会造成内存泄漏：

  1. public Map createMap() {
  2.     Map map = new HashMap() {{
  3.         put("map1", "value1");
  4.         put("map2", "value2");
  5.         put("map3", "value3");
  6.     }};
  7.     return map;
  8. }

为什么用了「可能」而不是「一定」会造成内存泄漏？

这是因为当此 map 被赋值为其他类属性时，可能会导致 GC 收集时不清理此对象，这时候才会导致内存泄漏。可以关注我「Java中文社群」后面会专门写一篇关于此问题的文章。

如何保证内存不泄露？

要想保证双花扣号不泄漏，办法也很简单，只需要将 map 对象声明为 static 静态类型的就可以了，代码如下：

  1. public static Map createMap() {
  2.     Map map = new HashMap() {{
  3.         put("map1", "value1");
  4.         put("map2", "value2");
  5.         put("map3", "value3");
  6.     }};
  7.     return map;
  8. }

使用以上代码，我们重新编译一份字节码，查看匿名类的内容如下：

  1. javap -c  DoubleBracket\$1.class
  2. Compiled from "DoubleBracket.java"
  3. class com.example.DoubleBracket$1 extends java.util.HashMap {
  4.   com.example.DoubleBracket$1();
  5.     Code:
  6.        0: aload_0
  7.        1: invokespecial #1                  // Method java/util/HashMap."<init>":()V
  8.        4: aload_0
  9.        5: ldc           #7                  // String map1
  10.        7: ldc           #9                  // String value1
  11.        9: invokevirtual #11                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
  12.       12: pop
  13.       13: aload_0
  14.       14: ldc           #17                 // String map2
  15.       16: ldc           #19                 // String value2
  16.       18: invokevirtual #11                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
  17.       21: pop
  18.       22: aload_0
  19.       23: ldc           #21                 // String map3
  20.       25: ldc           #23                 // String value3
  21.       27: invokevirtual #11                 // Method put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;
  22.       30: pop
  23.       31: return
  24. }
  25. 复制代码

从这次的代码我们可以看出，已经没有 putfield 关键字这一行了，也就是说静态匿名类不会持有外部对象的引用了。

为什么静态内部类不会持有外部类的引用？

原因其实很简单，因为匿名内部类是静态的之后，它所引用的对象或属性也必须是静态的了，因此就可以直接从 JVM 的 Method Area（方法区）获取到引用而无需持久外部对象了。

双花括号的替代方案

即使声明为静态的变量可以避免内存泄漏，但依旧不建议这样使用，为什么呢？
原因很简单，项目一般都是需要团队协作的，假如那位老兄在不知情的情况下把你的 static 给删掉呢？这就相当于设置了一个隐形的“坑”，其他不知道的人，一不小心就跳进去了，所以我们可以尝试一些其他的方案，比如 Java8 中的 Stream API 和 Java9 中的集合工厂等。

替代方案 1：Stream

使用 Java8 中的 Stream API 替代，示例如下。原代码：

  1. List<String> list = new ArrayList() {{
  2.     add("Java");
  3.     add("Redis");
  4. }};

替代代码：

  1. List<String> list = Stream.of("Java", "Redis").collect(Collectors.toList());

替代方案 2：集合工厂

使用集合工厂的 of 方法替代，示例如下。原代码：

  1. Map map = new HashMap() {{
  2.     put("map1", "value1");
  3.     put("map2", "value2");
  4. }};

替代代码：

  1. Map map = Map.of("map1", "Java", "map2", "Redis");

显然使用 Java9 中的方案非常适合我们，简单又酷炫，只可惜我们还在用 Java 6…6…6… 心碎了一地。

总结

本文我们讲了双花括号初始化因为会持有外部类的引用，从而可以会导致内存泄漏的问题，还从字节码以及反射的层面演示了这个问题。
要想保证双花括号初始化不会出现内存泄漏的办法也很简单，只需要被 static 修饰即可，但这样做还是存在潜在的风险，可能会被某人不小心删除掉，于是我们另寻它道，发现了可以使用 Java8 中的 Stream 或 Java9 中的集合工厂 of 方法替代“{{”。

作者：Java中文社群 链接：https://juejin.im/post/5ec77f69f265da76eb7ffc1b 来源：掘金 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。