Java 中 HashMap/List初始化时赋值

1、List 初始化

• 常规

import java.util.ArrayList;
import java.util.List;
 
/**
 * @Author: strggle_bin
 * @Date: 2023/12/8
 */
public class ListTest {
    public static void main(String[] args) {
        List<String> languages = new ArrayList<>();
        languages.add("Java");
        languages.add("vue");
        languages.add("python");
    }
}

• 匿名内部类

{{}} 双括号, 外层的 {} 定义了一个匿名内部类。内层的 {} 的定义了一个实例初始化代码块

import java.util.ArrayList;
import java.util.List;
 
/**
 * @Author: strggle_bin
 * @Date: 2023/12/8
 */
public class ListTest {
    static String str = "string";
    
    static List<String> list = new ArrayList<String>() {
        { // 这个大括号 就是 构造代码块 会在构造函数前 调用
            this.add("string1"); //this 可以省略
            add("string2");
            add(str);
        }
    };
 
    public static void main(String[] args) {
        System.out.println(list);
    }
}

• Arrays 工具类和Collections 工具类，不可变的 List

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
 
/**
 * @Author: strggle_bin
 * @Date: 2023/12/8
 */
public class ListTest {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("Java", "Jdk", "Jre");
        List<String> list2 = Collections.nCopies(3, "apple");
    }
}

这种得到的是不可变的 List, 不能增删，如果要可变，那就使用 ArrayList 再包装一下

List<String> list = new ArrayList<>(Arrays.asList("1", "2", "3"));
List<String> dogs = new ArrayList<>(Collections.nCopies(3, "dog"));

• JDK8 Stream，以下都是不常用的了

List<String> colors = Stream.of("blue", "red", "yellow").collect(toList());

• JDK 9 List.of

List<String> cups = List.of("A", "B", "C");

• guava

// 不可变集合
List<String> list = ImmutableList.of("Hollis", "hollis", "HollisChuang", "H");

2、HashMap 初始化

• 常规写法

HashMap<String, String> map = new HashMap<String, String>();
map.put("name", "test");  
map.put("age", "20");

• 匿名内部类

HashMap<String, String> map = new HashMap<String, String>() {
    {
        put("name", "test");  
        put("age", "20"); 
    }
};

这里的双括号”{{}}”到底什么意思，什么用法呢？
双括号”{{}}”,用来初始化，使代码简洁易读。
第一层括弧实际是定义了一个匿名内部类 (Anonymous Inner Class)，第二层括弧实际上是一个实例初始化块 (instance initializer block)，这个块在内部匿名类构造时被执行。

• 匿名内部类潜在问题

如果这个对象要串行化，可能会导致串行化失败。
1.此种方式是匿名内部类的声明方式，所以引用中持有着外部类的引用。所以当时串行化这个集合时外部类也会被不知不觉的串行化，当外部类没有实现serialize接口时，就会报错。
2.上例中，其实是声明了一个继承自HashMap的子类。然而有些串行化方法，例如要通过Gson串行化为json，或者要串行化为xml时，类库中提供的方式，是无法串行化Hashset或者HashMap的子类的，从而导致串行化失败。解决办法：重新初始化为一个HashMap对象：

new HashMap(map);
这样就可以正常初始化了。

• 执行效率问题

匿名内部类、普通写法分别创建 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 map = new HashMap() {
                {
                    put("name", "test");
                    put("age", "20");
                }
            };
        }
        System.out.println(System.currentTimeMillis() - st); // 1217
        */
        for (int i = 0; i < 10000000; i++) {
            HashMap<String, String> map = new HashMap<String, String>();
            put("name", "test");
            put("age", "20");
        }
        System.out.println(System.currentTimeMillis() - st); // 1064
    }
}