Java 创建 List 和 Map 同时赋初值的 5 种方式

墨蓝 2023-06-30 04:24 66阅读 0赞

# 一、最常见的初始化方式 #

先创建，再添加元素

## List ##

从源码可以看出：

*  List 的默认长度为10
 *  递增后的长度为先前长度的 1.5 倍
 *  最大长度是 Integer.MAX\_VALUE，即 2,147,483,647 或 0x7f ff ff ff

List<String> list = new ArrayList<>();
    list.add("str1");
    list.add("str2");
    list.add("str3");

当元素是静态对象时，可以使用静态代码块在初始化时进行赋值

private static List<String> static_list = new ArrayList<>();
    static {
        static_list.add("str1");
        static_list.add("str2");
        static_list.add("str3");
    }

## Map ##

从源码可以看出：

*  hashMap 的初始长度为 16
 *  递增后的长度为之前的 2 倍
 *  最大长度是 1<<30 - 1，即 1,073,741,824‬ - 8 或 0x40 00 00 00 - 1

Map<String, String> map = newHashMap<>();
    map.put("key1", "value1");
    map.put("key2", "value2");
    map.put("key3", "value3");

当元素是静态对象时，可以使用静态代码块在初始化时进行赋值

private static Map<String, String> static_map = new HashMap<>();
    static {
        static_map.put("key1", "value1");
        static_map.put("key2", "value2");
        static_map.put("key3", "value3");
    }

# 二、使用双花括号在初始化的同时赋值 #

外层的 \{\} 定义了一个匿名内部类。内层的 \{\} 定义了一个实例初始化代码块。这个代码块在初始化内部类时执行。所以这里相当于定义了一个匿名内部类，并使用 add 添加元素来初始化。

但这种方式有几个缺点：

1.  使用匿名内部类，会有效率上的损失。当然在大多数情况下，这点效率都是可接受的。
2.  静态内部类持有所在外部类的引用。如果需要将 List 返回给到其他地方使用，可能造成内存泄漏。

## List ##

List<String> list = new ArrayList<String>() {
     {
            add("str1");
            add("str2");
            add("str3");
    }};

## Map ##

Map<String, String> map = new HashMap<String, String>() {
    {
            put("key1", "value1");
            put("key2", "value2");
            put("key3", "value3");
    }};

# 三、利用Arrays工具类 #

## List ##

Arrays.asList使用了静态内部类，该类继承自 AbstractList，实现了 RandomAccess，内部使用了一个数组来存储元素。注意：内部定义的 ArrayList 并没有实现 List 接口，所以也不支持修改元素。

ArrayList(E[] array) {
    	a = Objects.requireNonNull(array);
    }
    public static <T> List<T> asList(T... a) {
        return new ArrayList<>(a);
    }

查看源码可以发现，虽然 Arrays 和 ArrayList 都是在 java.utils 包下，但它们创建的 ArrayList 确是两个同名，但不同的东西。

Arrays 中声明了一个ArrayList 的内部类，但是该类不支持增删元素，如果使用了诸如 add 方法，在编译时不会报错，但运行时会报 UnsupportedOperationException  
![在这里插入图片描述][20200116134901849.png]  
由于 Arrays 的 asList 方法使用了 “变长参数列表”，因此即使直接使用多个字符串作为参数，在编译时也会被自动装包成数组。

List<String> list1 = Arrays.asList(new String[] {"str1 ", "str2", "str3"});
    
    List<String> list2 = Arrays.asList("str1 ", "str2", "str3");

# 四、利用Lists工具类 #

## List ##

List 工具类提供了一个 newArrayList 的静态方法，从源码可以看出，newArrayList 实际只是对 ArrayList 无参初始化方法的封装，然后通过遍历迭代器 Iterator，将迭代器中的所有元素加入 List 而已

public static <E> ArrayList<E> newArrayList(final Iterator<? extends E> iterator) {
    	final ArrayList<E> list = newArrayList();
    	Iterators.addAll(list, iterator);
    	return list;
    }
    public static <E> ArrayList<E> newArrayList() {
    	return new ArrayList<>();
    }
    public static <T> boolean addAll(final Collection<T> collection, final Iterator<? extends T> iterator) {
    	Objects.requireNonNull(collection);
    	Objects.requireNonNull(iterator);
    	boolean wasModified = false;
    	while (iterator.hasNext()) {
    	    wasModified |= collection.add(iterator.next());
    	}
    	return wasModified;
    }

Lists 提供了两个方法：一个是创建一个空列表；一个是创建空列表的同时遍历迭代器，将它的值添加到列表中。

List<String> list = Lists.newArrayList();
    list1.add("str1");
    list1.add("str2");
    list1.add("str3");

注意：这里并不能用双花括号表达式直接添加元素

List<String> list = Lists.newArrayList(list.iterator());

# 五、利用Collections工具类 #

## List ##

创建一个固定长度的 CopiesList，List 长度不能改变，且元素都一样，且也是不可改变的。Java在实现时，仅使用了一个空间，用来存存放元素，当N足够大时，可以节省空间和性能。

同样，和 Arrays 创建的 List 一样，都没有实现 List 接口，因此使用add方法，同样会在编译时报错java.lang.UnsupportedOperationException  
![在这里插入图片描述][20200116141616516.png]

CopiesList<String> list1 = Collections.nCopies(5, "str");

此外，Collections 还提供了一个为 List 一次性添加所有元素的方法，弥补了原先 List 只能添加 Collections，而不支持数组的缺憾。

List<String> list2 = new ArrayList<>();
    Collections.addAll(list1, new String[]{"str1", "str2", "str3"});
    Collections.addAll(list1, "str4", "str5", "str6");

# 六、流式转化 #

流是 Java8 的新特性，提供了一种类似 SQL 语句从数据库中查询数据的方式，通过封装好的函数和链式调用，高阶抽象并简化操作。

它可以对传入流内部的元素进行筛选、排序、聚合等中间操作（intermediate operate），最后由最终操作（terminal operation）得到前面处理的结果。

通过静态的 Stream.of 方法接收元素，然后通过 collect 方法处理得到最终结果。

## List ##

List<String> list1 = Stream.of("str1", "str2", "str3").collect(Collectors.toList());

## Map ##

`Collectors.toMap()` 知识点：  
![在这里插入图片描述][20200116144951243.png]

*  Java 8 中我们可以通过 `::` 关键字来访问类的构造方法，对象方法，静态方法。
 *  Java8 允许在接口中加入具体方法，接口中的具体方法有两种，default 方法和 static 方法，identity () 就是 Function 接口的一个静态方法。`Function.identity()` 是一个返回一个跟输入一样的 Lambda 表达式对象，形式为 `t -> t` 。  
    ![在这里插入图片描述][20200116144555687.png]
 *  第三个参数是合并函数，如果不指定 mergeFunction，当存在两个 key 相同的元素时，会报 `java.lang.IllegalStateException: Duplicate key g1 at java.util.stream.Collectors.lambda$throwingMerger` 错误。
    
    1.  key相同时当前值替换原始值  
        (oldVal, currVal) -> currVal
    2.  key相同时保留原始值  
        (oldVal, currVal) -> oldVal

**Test.java**

Map<String, Book> map = books.stream()
    	.sorted(Comparator.comparing(Book::getISBN))
    	.collect(Collectors.toMap(Book::getISBN, Function.identity(), (oldVal, currVal) -> oldVal));

**Book.java**

public class Book {
        public String name;
        public String author;
        public float price;
        public String ISBN;
    
        public Book(String name, String author, float price, String ISBN) {
            this.name = name;
            this.author = author;
            this.price = price;
            this.ISBN = ISBN;
        }
    
        public String getAuthor() {
            return author;
        }
    
        public void setAuthor(String author) {
            this.author = author;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public float getPrice() {
            return price;
        }
    
        public void setPrice(float price) {
            this.price = price;
        }
    
        public String getISBN() {
            return ISBN;
        }
    
        public void setISBN(String ISBN) {
            this.ISBN = ISBN;
        }
    }

[20200116134901849.png]: https://img-blog.csdnimg.cn/20200116134901849.png
[20200116141616516.png]: https://img-blog.csdnimg.cn/20200116141616516.png
[20200116144951243.png]: https://img-blog.csdnimg.cn/20200116144951243.png
[20200116144555687.png]: https://img-blog.csdnimg.cn/20200116144555687.png