Java:Double Brace Initialization

  在我刚刚接触现在这个产品的时候,我就在我们的代码中接触到了对Double Brace Initialization的使用。那段代码用来初始化一个集合:

1 final Set<String> exclusions = new HashSet<String>() {{
2     add(‘Alice’);
3     add(‘Bob’);
4     add(‘Marine’);
5 }};

  相信第一次看到这种使用方式的读者和我当时的感觉一样:这是在做什么?当然,通过在函数add()的调用处加上断点,您就会了解到这实际上是在使用add()函数向刚刚创建的集合exclusions中添加元素。

Double Brace Initialization简介

  可为什么我们要用这种方式来初始化集合呢?作为比较,我们先来看看通常情况下我们所编写的具有相同内容集合的初始化代码:

1 final Set<String> exclusions = new HashSet<String>();
2 exclusions.add(‘Alice’);
3 exclusions.add(‘Bob’);
4 exclusions.add(‘Marine’);

  这些代码很繁冗,不是么?在编写这些代码的时候,我们需要重复键入很多次exclusions。同时,这些代码在软件开发人员需要检查到底向该集合中添加了哪些元素的时候也非常恼人。反过来,使用Double Brace Initialization对集合进行初始化就十分简单明了:

1 final Set<String> exclusions = new HashSet<String>() {{
2     add(‘Alice’);
3     add(‘Bob’);
4     add(‘Marine’);
5 }};

  因此对于一个熟悉该使用方法的人来说,Double Brace Initialization清晰简洁,代码可读性好维护性高,自然是初始化集合时的不二选择。而对于一个没有接触过该使用方法而且基础不是很牢靠的人来说,Double Brace Initialization实在是有些晦涩难懂。

  从晦涩到熟悉实际上非常简单,那就是了解它的工作原理。如果将上面的Double Brace Initialization示例稍微更改一下格式,相信您会看出一些端倪:

1 final Set<String> exclusions = new HashSet<String>() {
2     {
3         add(‘Alice’);
4         add(‘Bob’);
5         add(‘Marine’);
6     }
7 };

  现在您能看出来到底Double Brace Initialization是如何运行的了吧?Double Brace Initialization一共包含两层花括号。外层的花括号实际上表示当前所创建的是一个派生自HashSet<String>的匿名类:

1 final Set<String> exclusions = new HashSet<String>() {
2     // 匿名派生类的各个成员
3 };

  而内层的花括号实际上是在匿名派生类内部所声明的instance initializer:

1 final Set<String> exclusions = new HashSet<String>() {
2     {
3         // 由于匿名类中不能添加构造函数,因此这里的instance initializer
4         // 实际上等于构造函数,用来执行对当前匿名类实例的初始化
5     }
6 };

  在通过Double Brace Initialization创建一个集合的时候,我们所得到的实际上是一个从集合类派生出的匿名类。在该匿名类初始化时,它内部所声明的instance initializer就会被执行,进而允许其中的函数调用add()来向刚刚创建好的集合添加元素。

  其实Double Brace Initialization并不仅仅局限于对集合类型的初始化。实际上,任何类型都可以通过它来执行预初始化:

1 NutritionFacts cocaCola = new NutritionFacts() {{
2     setCalories(100);
3     setSodium(35);
4     setCarbohydrate(27);
5 }};

  看到了吧。这和我另一篇文章中所提及的Fluent Interface模式有异曲同工之妙。

Double Brace Initialization的优缺点

  下一步,我们就需要了解Double Brace Initialization的优缺点,从而更好地对它进行使用。

  Double Brace Initialization的优点非常明显:对于熟悉该使用方法的人而言,它具有更好的可读性以及更好的维护性。

  但是Double Brace Initialization同样具有一系列问题。最严重的可能就是Double Brace Initialization会导致内存泄露。在使用Double Brace Initialization的时候,我们实际上创建了一个匿名类。匿名类有一个性质,那就是该匿名类实例将拥有一个包含它的类型的引用。如果我们将该匿名类实例通过函数调用等方式传到该类型之外,那么对该匿名类的保持实际上会导致外层的类型无法被释放,进而造成内存泄露。

  例如在Joshua Bloch版的Builder类实现中(详见这篇博文),我们可以在build()函数中使用Double Brace Initialization来生成产品实例:

 1 public class NutritionFacts {
 2     ……
 3
 4     public static class Builder {
 5         ……
 6         public NutritionFacts build() {
 7             return new NutritionFacts() {{
 8                 setServingSize(100);
 9                 setServings(3);
10                 ……
11             }};
12         }
13     }
14 }

  而在用户通过该Builder创建一个产品实例的时候,他将会使用如下代码:

1 NutritionFacts facts = new NutritionFacts.Builder.setXXX()….build();

  上面的代码没有保持任何对NutritionFacts.Builder的引用,因此在执行完这段代码后,该段程序所实际使用的内存应该仅仅增加了一个NutritionFacts实例,不是么?答案是否定的。由于在build()函数中使用了Double Brace Initialization,因此在新创建的NutritionFacts实例中会包含一个NutritionFacts.Builder类型的引用。

  另外一个缺点则是破坏了equals()函数的语义。在为一个类型实现equals()函数的时候,我们可能需要判断两个参与比较的类型是否一致:

1 @Override
2 public boolean equals(Object o) {
3     if (o != null && o.getClass().equals(getClass())) {
4         ……
5     }
6
7     return false;
8 }

  这种实现有一定的争议。争议点主要在于Joshua Bloch在Effective Java的Item 8中说它违反了里氏替换原则。反驳这种观点的人则主要认为维护equals()函数返回结果正确性的责任需要由派生类来保证。而且从语义上来说,如果两个类的类型都不一样,那么它们之间还彼此相等本身就是一件荒谬的事情。因此在某些类库的实现中,它们都通过检查类型的方式强行要求参与比较的两个实例的类型需要是一致的。

  而在使用Double Brace Initialization的时候,我们则创建了一个从目标类型派生的匿名类。就以刚刚所展示的build()函数为例:

 1 public class NutritionFacts {
 2     ……
 3
 4     public static class Builder {
 5         ……
 6         public NutritionFacts build() {
 7             return new NutritionFacts() {{
 8                 setServingSize(100);
 9                 setServings(3);
10                 ……
11             }};
12         }
13     }
14 }

  在build()函数中,我们所创建的实际上是从NutritionFacts派生的匿名类。如果我们在该段代码之后添加一个断点,我们就可以从调试功能中看到该段代码所创建实例的实际类型是NutritionFacts$1。因此,如果NutritionFacts的equals()函数内部实现判断了参与比较的两个实例所具有的类型是否一致,那么我们刚刚通过Double Brace Initialization所得到的NutritionFacts$1类型实例将肯定与其它的NutritionFacts实例不相等。

  好,既然我们刚刚提到了匿名类在调试器中的表示,那么我们就需要慎重地考虑这个问题。原因很简单:在较为复杂的Double Brace Initialization的使用中,这些匿名类的表示会非常难以阅读。就以下面的代码为例:

 1 Map<String, Object> characterInfo = new HashMap<String, Object>() {{
 2     put("firstName", "John");
 3     put("lastName", "Smith");
 4     put("children", new HashSet<HashMap<String, Object>>() {{
 5         add(new HashMap<String, Object>() {{
 6             put("firstName", "Alice");
 7             put("lastName", "Smith");
 8         }});
 9         add(new HashMap<String, Object>() {{
10             put("firstName", "George");
11             put("lastName", "Smith");
12         }});
13     }});
14 }};

  而在使用调试器进行调试的时候,您会看到以下一系列类型:

Sample.class

Sample$1.class

Sample$1$1.class

Sample$1$1$1.class

Sample$1$1$2.class

  在查看这些数据的时候,我们常常无法直接理解这些数据到底代表的是什么。因此软件开发人员常常需要查看它们的基类到底是什么,并根据调用栈去查找这些数据的初始化逻辑,才能了解这些数据所具有的真正含义。在这种情况下,Double Brace Initialization所提供的不再是较高的维护性,反而变成了维护的负担。

  同时由于Double Brace Initialization需要创建一个目标类型的派生类,因此我们不能在一个由final修饰的类型上使用Double Brace Initialization。

  而且值得一提的是,在某些IDE中,Double Brace Initialization的格式实际上显得非常奇怪。这使得Double Brace Initialization丧失了其最大优势。

  而且在使用Double Brace Initialization之前,我们首先要问自己:我们是否在使用一系列常量来初始化集合?如果是,那么为什么要将数据和应用逻辑混合在一起?如果这两个问题中的任意一个是否定的,那么就表示我们应该使用独立的文件来记录应用所需要的数据,如*.properties文件等,并在应用运行时加载这些数据。

适当地使用Double Brace Initialization

  可以说,Double Brace Initialization虽然在表意上具有突出优势,它的缺点也非常明显。因此软件开发人员需要谨慎地对它进行使用。

  在前面的介绍中我们已经看到,Double Brace Initialization最大的问题就是在表达复杂数据的时候反而会增加的维护成本,在equals()函数方面不清晰的语义以及潜在的内存泄露。

  第一个缺点非常容易避免,那就是在创建一个复杂的数据集合时,我们不再考虑使用Double Brace Initialization,而是将这些数据存储在一个专门的数据文件中,并在应用运行时加载。

  而后两个缺点则可以通过限制该部分数据的使用范围来完成。

  那在需要初始化复杂数据的时候,我们应该怎么办?为此业内也提出了一系列解决方案。这些方案不仅可以提高代码的表意性,还可以避免由于使用Double Brace Initialization所引入的一系列问题。

  最常见的一种解决方案就是使用第三方类库。例如由Apache Commons类库提供的ArrayUtils.toMap()函数就提供了一种非常清晰的创建Map的实现:

1 Map<Integer, String> map = (Map) ArrayUtils.toMap(new Object[][] {
2         {1, "one"},
3         {2, "two"},
4         {3, "three"}
5 });

  如果说您不喜欢引入第三方类库,您也可以通过创建一个工具函数来完成类似的事情:

Map<Integer, String> map = Utils.toMap(new Object[][] {
    {1, "one"},
    {2, "two"},
    {3, "three"}
});

public Map<Integer, String> toMap(Object[][] mapData) {
    ……
}

转载请注明原文地址并标明转载:http://www.cnblogs.com/loveis715/p/4593962.html

商业转载请事先与我联系:[email protected]

时间: 2024-10-13 14:12:43

Java:Double Brace Initialization的相关文章

深入理解Java:注解(Annotation)自己定义注解入门

深入理解Java:注解(Annotation)自己定义注解入门 要深入学习注解.我们就必须能定义自己的注解,并使用注解,在定义自己的注解之前.我们就必须要了解Java为我们提供的元注解和相关定义注解的语法. 元注解: 元注解的作用就是负责注解其它注解. Java5.0定义了4个标准的meta-annotation类型.它们被用来提供对其它 annotation类型作说明.Java5.0定义的元注解: [email protected], [email protected], [email pro

java使double保留两位小数的多方法 java保留两位小数

这篇文章主要介绍了java使double类型保留两位小数的方法,大家参考使用吧 复制代码 代码如下: mport java.text.DecimalFormat; DecimalFormat    df   = new DecimalFormat("######0.00"); double d1 = 3.23456  double d2 = 0.0;double d3 = 2.0;df.format(d1); df.format(d2); df.format(d3); 3个结果分别为:

Kotlin中变量不同于Java: var 对val(KAD 02)

原文标题:Variables in Kotlin, differences with Java. var vs val (KAD 02) 作者:Antonio Leiva 时间:Nov 28, 2016 原文链接:http://antonioleiva.com/variables-kotlin/ Kotlin系列课程的第二课:Kotlin中变量不同于Java: var 对val. 在这第二章节中,我们将了解Kotlin中变量是怎样工作的,什么是val和var,什么时间使用它们. 我从这开始,是因

Java:类与继承(隐藏和覆盖的问题)

盒子先生金金 Java:类与继承(隐藏和覆盖的问题) Java:类与继承 Java:类与继承 对于面向对象的程序设计语言来说,类毫无疑问是其最重要的基础.抽象.封装.继承.多态这四大特性都离不开类,只有存在类,才能体现面向对象编程的特点,今天我们就来了解一些类与继承的相关知识.首先,我们讲述一下与类的初始化相关的东西,然后再从几个方面阐述继承这一大特性.以下是本文的目录大纲: 一.你了解类吗? 二.你了解继承吗? 三.常见的面试笔试题 若有不正之处,请多多谅解并欢迎批评指正. 请尊重作者劳动成果

java:第五章

第五章 循环结构 1.while循环 while(条件){ //代码块 } 解释:如果条件的结果为true,那么执行代码块, 当代码块执行完后,又会执行条件, 依次循环,直到结果为false,整个循环结束. 2.程序调试 第一步:设置断点(左键双击) 第二步:debug方式好执行代码 第三步:逐条执行代码调试(F6) 第四步:检查代码(看变量值的变化) 注意:在右上角可以切换java视图和debug视图. 3.do while循环 do{ //代码块 }while(条件) 解释:先执行代码块,然

java中double变量保留小数问题

(转载自玄影池扁舟) 做java项目的时候可能经常会遇到double类型变量保留小数的问题,下面便把我的经验做个简短的总结: java中double类型变量保留小数问题大体分两种情况: (一):小数点后面位数过长,四舍五入保留指定位数: 可以用以下代码实现: public class TestDemo { public static void main(String[] args) {     double a=15.32743859;     double b=Math.round(a*100

关于java中Double类型的运算精度问题

标题     在Java中实现浮点数的精确计算    AYellow(原作) 修改    关键字     Java 浮点数 精确计算   问题的提出:如果我们编译运行下面这个程序会看到什么?public class Test{    public static void main(String args[]){        System.out.println(0.05+0.01);        System.out.println(1.0-0.42);        System.out.

Effective Java 71 Use lazy initialization judiciously

Lazy initialization - It decreases the cost of initializing a class or creating an instance, at the expense of increasing the cost of accessing the lazily initialized field. Depending on what fraction of lazily initialized fields eventually require i

[2]注解(Annotation)-- 深入理解Java:注解(Annotation)自定义注解入门

转载 http://www.cnblogs.com/peida/archive/2013/04/24/3036689.html 深入理解Java:注解(Annotation)自定义注解入门 要深入学习注解,我们就必须能定义自己的注解,并使用注解,在定义自己的注解之前,我们就必须要了解Java为我们提供的元注解和相关定义注解的语法. 元注解: 元注解的作用就是负责注解其他注解.Java5.0定义了4个标准的meta-annotation类型,它们被用来提供对其它 annotation类型作说明.J