你可能没用过这种方式的集合!new HashMap<K,V>(){{put(K,V);}};

JAVA葵花宝典

共 2408字,需浏览 5分钟

 ·

2020-11-28 02:07

来源:https://blog.csdn.net/luman1991/article/details/53034602


一、HashMap的初始化

1、HashMap 初始化的文艺写法

HashMap 是一种常用的数据结构,一般用来做数据字典或者 Hash 查找的容器。普通青年一般会这么初始化:

  1. HashMap<String, String> map =

  2.        new HashMap<String, String>();

  3. map.put("Name", "June");

  4. map.put("QQ", "2572073701");

看完这段代码,很多人都会觉得这么写太啰嗦了,对此,文艺青年一般这么来了:

  1. HashMap<String, String> map =

  2.        new HashMap<String, String>() {

  3.            {

  4.                put("Name", "June");

  5.                put("QQ", "2572073701");

  6.            }

  7.        };

嗯,看起来优雅了不少,一步到位,一气呵成的赶脚。然后问题来了,有童鞋会问:纳尼?这里的双括号到底什么意思,什么用法呢?哈哈,其实很简单,看看下面的代码你就知道啥意思了。

  1. public class Test {

  2.    /*private static HashMap< String, String> map = new HashMap< String, String>() {

  3.     {

  4.      put("Name", "June");

  5.      put("QQ", "2572073701");

  6.     }

  7.    };*/

  8.    public Test() {

  9.        System.out.println("Constructor called:构造器被调用");

  10.    }

  11.    static {

  12.        System.out.println("Static block called:静态块被调用");

  13.    }

  14.    {

  15.        System.out.println("Instance initializer called:实例初始化块被调用");

  16.    }

  17.    public static void main(String[] args) {

  18.        new Test();

  19.        System.out.println("=======================");

  20.        new Test();

  21.    }

  22. }

输出:

  1. Static block called:静态块被调用

  2. Instance initializer called:实例初始化被调用

  3. Constructor called:构造器被调用

  4. =======================

  5. Instance initializer called:实例初始化被调用

  6. Constructor called:构造器被调用

也就是说第一层括弧实际是定义了一个匿名内部类 (Anonymous Inner Class),第二层括弧实际上是一个实例初始化块 (instance initializer block),这个块在内部匿名类构造时被执行。这个块之所以被叫做“实例初始化块”是因为它们被定义在了一个类的实例范围内。

上面代码如果是写在 Test 类中,编译后你会看到会生成 Test$1.class 文件,反编译该文件内容:

  1. D:eclipse_indigoworkspace_homeCDHJobsbinpvuv>jad -p Test$1.class


  2. // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

  3. // Jad home page: http://www.kpdus.com/jad.html

  4. // Decompiler options: packimports(3)

  5. // Source File Name: Test.java


  6. package pvuv.zhaopin;

  7. import java.util.HashMap;

  8. // Referenced classes of package pvuv.zhaopin:

  9. // Test

  10. class Test$1 extends HashMap // 创建了一个 HashMap 的子类

  11. {

  12. Test$1()

  13. { // 第二个 {} 中的代码放到了构造方法中去了

  14. put("Name", "June");

  15. put("QQ", "2572073701");

  16. }

  17. }


  18. D:eclipse_indigoworkspace_homeCDHJobsbinpvuv>

2、推而广之

这种写法,推而广之,在初始化 ArrayList、Set 的时候都可以这么玩,比如你还可以这么玩:

  1. List<String> names = new ArrayList<String>() {

  2.    {

  3.        for (int i = 0; i < 10; i++) {

  4.            add("A" + i);

  5.        }

  6.    }

  7. };

  8. System.out.println(names.toString()); // [A0, A1, A2, A3, A4, A5, A6, A7, A8, A9]

3、文艺写法的潜在问题

文章开头提到的文艺写法的好处很明显就是一目了然。这里来罗列下此种方法的坏处,如果这个对象要串行化,可能会导致串行化失败。

  • 此种方式是匿名内部类的声明方式,所以引用中持有着外部类的引用。所以当串行化这个集合时外部类也会被不知不觉的串行化,当外部类没有实现serialize接口时,就会报错。

  • 上例中,其实是声明了一个继承自HashMap的子类。然而有些串行化方法,例如要通过Gson串行化为json,或者要串行化为xml时,类库中提供的方式,是无法串行化Hashset或者HashMap的子类的,从而导致串行化失败。

解决办法,重新初始化为一个HashMap对象:

  1. new HashMap(map);

这样就可以正常初始化了。

4、执行效率问题

当一种新的工具或者写法出现时,猿们都会来一句:性能怎么样?(这和男生谈论妹纸第一句一般都是:“长得咋样?三围多少?”一个道理:))

关于这个两种写法我这边笔记本上测试文艺写法、普通写法分别创建 10,000,000 个 Map 的结果是 1217、1064,相差 13%。

  1. public class Test {

  2.    public static void main(String[] args) {

  3.        long st = System.currentTimeMillis();

  4.      /*

  5.      for (int i = 0; i < 10000000; i++) {

  6.       HashMap< String, String> map = new HashMap< String, String>() {

  7.        {

  8.         put("Name", "June");

  9.         put("QQ", "2572073701");

  10.        }

  11.       };

  12.      }

  13.      System.out.println(System.currentTimeMillis() - st); // 1217

  14.      */

  15.        for (int i = 0; i < 10000000; i++) {

  16.            HashMap<String, String> map = new HashMap<String, String>();

  17.            map.put("Name", "June");

  18.            map.put("QQ", "2572073701");

  19.        }

  20.        System.out.println(System.currentTimeMillis() - st); // 1064

  21.    }

  22. }

5、由实例初始化块联想到的一些变量初始化问题

从代码上看,a 为什么可以不先声明类型?你觉得 a、b、c 的值分别是多少?能说明理由么?TIP:如果你对这块机制不了解,建议试着反编译一下字节码文件。

5.1 测试源码

  1. public class Test {


  2.    int e = 6;


  3.    Test() {

  4.        int c = 1;

  5.        this.f = 5;

  6.        int e = 66;

  7.    }


  8.    int f = 55;

  9.    int c = 11;

  10.    int b = 1;


  11.    {

  12.        a = 3;

  13.        b = 22;

  14.    }


  15.    int a =33;


  16.    static {

  17.        d = 4;

  18.    }


  19.    static int d = 44;


  20.    int g = 7;

  21.    int h = 8;


  22.    public int test() {

  23.        g = 77;

  24.        int h = 88;

  25.        System.out.println("h - 成员变量:" + this.h);

  26.        System.out.println("h - 局部变量: " + h);

  27.        return g;

  28.    }


  29.    public static void main(String[] args) {

  30.        System.out.println("a: " + new Test().a);

  31.        System.out.println("b: " + new Test().b);

  32.        System.out.println("c: " + new Test().c);

  33.        System.out.println("d: " + new Test().d);

  34.        System.out.println("f: " + new Test().f);

  35.        System.out.println("e: " + new Test().e);

  36.        System.out.println("g: " + new Test().test());

  37.    }

  38. }

5.2 字节码反编译:

  1. // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

  2. // Jad home page: http://www.kpdus.com/jad.html

  3. // Decompiler options: packimports(3)

  4. // Source File Name: Test.java


  5. import java.io.PrintStream;

  6. public class Test

  7. {

  8. Test()

  9. {

  10.  this.e = 6;

  11.  f = 55;

  12.  this.c = 11;

  13.  b = 1;

  14.  a = 3;

  15.  b = 22;

  16.  a = 33;

  17.  g = 7;

  18.  h = 8;

  19.  int c = 1;

  20.  f = 5;

  21.  int e = 66;

  22. }

  23. public int test()

  24. {

  25.  g = 77;

  26.  int h = 88;

  27.  System.out.println((new StringBuilder("h - u6210u5458u53D8u91CFuFF1A")).append(this.h).toString());

  28.  System.out.println((new StringBuilder("h - u5C40u90E8u53D8u91CF: ")).append(h).toString());

  29.  return g;

  30. }

  31. public static void main(String args[])

  32. {

  33.  System.out.println((new StringBuilder("a: ")).append((new Test()).a).toString());

  34.  System.out.println((new StringBuilder("b: ")).append((new Test()).b).toString());

  35.  System.out.println((new StringBuilder("c: ")).append((new Test()).c).toString());

  36.  new Test();

  37.  System.out.println((new StringBuilder("d: ")).append(d).toString());

  38.  System.out.println((new StringBuilder("f: ")).append((new Test()).f).toString());

  39.  System.out.println((new StringBuilder("e: ")).append((new Test()).e).toString());

  40.  System.out.println((new StringBuilder("g: ")).append((new Test()).test()).toString());

  41. }

  42. int e;

  43. int f;

  44. int c;

  45. int b;

  46. int a;

  47. static int d = 4;

  48. int g;

  49. int h;

  50. static

  51. {

  52.  d = 44;

  53. }

  54. }

5.3 输出结果:

  1. a: 33

  2. b: 22

  3. c: 11

  4. d: 44

  5. f: 5

  6. e: 6

  7. h - 成员变量:8

  8. h - 局部变量: 88

  9. g: 77


二、HashMap遍历方法示例

第一种:

  1. Map map = new HashMap();

  2. Iterator iter = map.entrySet().iterator();

  3. while (iter.hasNext()) {

  4.    Map.Entry entry = (Map.Entry) iter.next();

  5.    Object key = entry.getKey();

  6.    Object val = entry.getValue();

  7. }

效率高,以后一定要使用此种方式!

第二种:

  1. Map map = new HashMap();

  2. Iterator iter = map.keySet().iterator();

  3. while (iter.hasNext()) {

  4.    Object key = iter.next();

  5.    Object val = map.get(key);

  6. }

效率低,以后尽量少使用!

HashMap的遍历有两种常用的方法,那就是使用keyset及entryset来进行遍历,但两者的遍历速度是有差别的,下面请看实例:

  1. public class HashMapTest {

  2.    public static void main(String[] args) {

  3.        HashMap hashmap = new HashMap();

  4.        for (int i = 0; i < 1000; i++) {

  5.            hashmap.put("" + i, "thanks");

  6.        }

  7.        long bs = Calendar.getInstance().getTimeInMillis();

  8.        Iterator iterator = hashmap.keySet().iterator();

  9.        while (iterator.hasNext()) {

  10.            System.out.print(hashmap.get(iterator.next()));

  11.        }

  12.        System.out.println();

  13.        System.out.println(Calendar.getInstance().getTimeInMillis() - bs);

  14.        listHashMap();

  15.    }

  16.    public static void listHashMap() {

  17.        HashMap hashmap = new HashMap();

  18.        for (int i = 0; i < 1000; i++) {

  19.            hashmap.put("" + i, "thanks");

  20.        }

  21.        long bs = Calendar.getInstance().getTimeInMillis();

  22.        java.util.Iterator it = hashmap.entrySet().iterator();

  23.        while (it.hasNext()) {

  24.            java.util.Map.Entry entry = (java.util.Map.Entry) it.next();

  25.            // entry.getKey() 返回与此项对应的键

  26.            // entry.getValue() 返回与此项对应的值

  27.            System.out.print(entry.getValue());

  28.        }

  29.        System.out.println();

  30.        System.out.println(Calendar.getInstance().getTimeInMillis() - bs);

  31.    }

  32. }

对于keySet其实是遍历了2次,一次是转为iterator,一次就从hashmap中取出key所对于的value。而entryset只是遍历了第一次,他把key和value都放到了entry中,所以就快了。

注:Hashtable的遍历方法和以上的差不多!

更多精彩推荐

 微信第 1 行代码曝光!
☞ 14 个实用的数据库设计技巧,好用到爆
☞ 排名前 16 的 Java 工具类,哪个你没用过?
☞ Spring事务的那些坑,这里都给你总结好了!
☞ 这应该是全网最全的Git分支开发规范手册~

最后,推荐给大家一个有趣有料的公众号:写代码的渣渣鹏,7年老程序员教你写bug,回复 面试或资源 送一你整套开发笔记 有惊喜哦

浏览 7
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报
评论
图片
表情
推荐
点赞
评论
收藏
分享

手机扫一扫分享

分享
举报