在 Java 中初始化HashMap

原文：https://www.studytonight.com/java-examples/initialize-hashmap-in-java

Hashtable用于存储键值对。在内部，它使用哈希来存储数据和获取数据。在本教程中，我们将学习如何在 Java 中初始化 HashMap。

使用 HashMap 的 put()方法

put()方法将键和值作为参数，并将键-值对添加到 HashMap 中。

import java.util.HashMap;
import java.util.Map;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> map = new HashMap<>();
        map.put(101, "Justin");
        map.put(102, "Jessica");
        map.put(103, "Simon");

        System.out.println(map);
    }
}

{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}

注意，我们只能在可变映射上使用这个方法。如果我们将此用于不可变映射，那么我们将获得不支持操作例外。

import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> mutableMap = new HashMap<>();
        mutableMap.put(101, "Justin");
        mutableMap.put(102, "Jessica");
        mutableMap.put(103, "Simon");

        Map<Integer, String> immutableMap = Collections.unmodifiableMap(mutableMap); 
        immutableMap.put(104, "Harry");//Error
    }
}

线程“main”Java . lang . unsupportedoperationexception 在 Java . base/Java . util . collections $ unmodifielemap . put(collections . Java:1473) 在 Demo.main(Demo.java:15)

创建单一映射

单值映射是一个不可变的映射，它存储一个单键值对。我们将使用collections . singletonmap()方法对其进行初始化。因为它是一个不可变的映射，所以我们不能向它添加多个条目。这将导致不支持操作例外。

import java.util.Collections;
import java.util.Map;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> singletonMap =  Collections.singletonMap(101, "Justin");
        System.out.print(singletonMap);
    }
}

{ 101 =贾斯汀}

创建空映射

我们可以使用 Collections.emptyMap() 方法创建一个空的、不可变的映射。

import java.util.Collections;
import java.util.Map;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> emptyMap =  Collections.emptyMap();
        System.out.print(emptyMap);
    }
}

{}

创建静态Hashtable

我们可以使用静态块在 Java 中创建和初始化一个静态 HashMap。下面的代码将创建一个静态可变映射。请注意，这种方法不是首选的，因为会创建额外的类，存储不需要的引用，并且可能会导致内存泄漏。

import java.util.HashMap;
import java.util.Map;

public class Demo
{
    public static Map<Integer, String> staticMap;
    static
    {
        staticMap = new HashMap<>();
        staticMap.put(101, "Justin");
        staticMap.put(102, "Jessica");
        staticMap.put(103, "Simon");
    }
    public static void main(String[] args)
    {
        System.out.print(staticMap);
    }
}

{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}

在 Java 中 9 的 Map.of()方法

Map.of()是一个工厂方法，使用提供的键和值返回一个不可变的映射。这种方法的一个缺点是我们最多只能在映射上添加 10 个条目。如果我们试图添加 10 个以上的键值对，我们将会得到一个编译错误。

import java.util.Map;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> emptyMap = Map.of();
        Map<Integer, String> singletonMap = Map.of(101, "Justin");
        Map<Integer, String> map = Map.of(
                101, "Justin",
                102, "Jessica",
                103, "Simon"
                );
        System.out.println(emptyMap);
        System.out.println(singletonMap);
        System.out.println(map);
    }
}

{ } { 101 =贾斯汀} { 101 =贾斯汀，102 =杰西卡，103 =西蒙}

在 Java 中 9 的 Map.ofEntries()方法

这种方法与()的 Map.of 基本相同。唯一不同的是，我们没有限制只有 10 个条目。就像 Map.of()方法一样，它返回一个不可变的映射。

import java.util.Map;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> emptyMap = Map.ofEntries();
        Map<Integer, String> singletonMap = Map.ofEntries(Map.entry(101, "Justin"));
        Map<Integer, String> map = Map.ofEntries(
                Map.entry(101, "Justin"),
                Map.entry(102, "Jessica"),
                Map.entry(103, "Simon")
                );
        System.out.println(emptyMap);
        System.out.println(singletonMap);
        System.out.println(map);
    }
}

{ } { 101 =贾斯汀} { 102 =杰西卡，103 =西蒙，101 =贾斯汀}

使用谷歌番石榴图书馆

番石榴是著名的 Java 库。它提供了在 Java 中初始化可变和不可变映射的方法。为了初始化不可变的映射，我们将使用 ImmutableMap.of()方法。

import java.util.Map;

import com.google.common.collect.ImmutableMap;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> map = ImmutableMap.of(
                101, "Justin",
                102, "Jessica",
                103, "Simon"
                );
        System.out.print(map);
    }
}

{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}

对于可变映射，我们将首先创建一个不可变映射。然后我们将它转换成一个可变的 HashMap。

import java.util.HashMap;
import java.util.Map;

import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;

public class Demo
{
    public static void main(String[] args)
    {
        Map<Integer, String> immutableMap = ImmutableMap.of(
                101, "Justin",
                102, "Jessica",
                103, "Simon"
                );
        HashMap<Integer, String> mutableMap = Maps.newHashMap(immutableMap);
        System.out.print(mutableMap);
    }

}

{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}

在 Java 中流初始化映射

Java 8 的流 API 提供了几种不同的方法来初始化映射。我们可以使用流创建可变和不可变的映射。但是，不建议使用以下初始化技术，因为它们会影响代码的整体性能并创建大量垃圾对象。

使用 Collectors.toMap()方法

我们可以使用一个二维对象数组(每行包含一个键值对)来创建一个流。然后，我们可以使用 toMap()方法将流式对象收集到我们的映射中。这将创建一个可变的映射。

import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo
{    
    public static void main(String[] args)
    {
        Map<Integer, String> map = Stream.of(new Object[][] { 
             {101, "Justin"}, 
             {102, "Jessica"},
             {103, "Simon"}
         }).collect(Collectors.toMap(data -> (Integer) data[0], data -> (String) data[1]));

        System.out.print(map);
    }
}

{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}

使用简单输入和简单置换输入

我们可以使用简单条目向映射添加键值条目。这将创建一个可变的映射。

import java.util.AbstractMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo
{    
    public static void main(String[] args)
    {
        Map<Integer, String> map = Stream.of(
                new AbstractMap.SimpleEntry<>(101, "Justin"),
                new AbstractMap.SimpleEntry<>(102, "Jessica"),
                new AbstractMap.SimpleEntry<>(103, "Simon")
         ).collect(Collectors.toMap(
                 Map.Entry::getKey,  
                 Map.Entry::getValue));

        System.out.print(map);

    }
}

{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}

同样，我们也可以使用 SimpleImmutableEntry。这种方法还会创建一个可变的映射。

import java.util.AbstractMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo
{    
    public static void main(String[] args)
    {
        Map<Integer, String> map = Stream.of(
                new AbstractMap.SimpleImmutableEntry<>(101, "Justin"),
                new AbstractMap.SimpleImmutableEntry<>(102, "Jessica"),
                new AbstractMap.SimpleImmutableEntry<>(103, "Simon")
         ).collect(Collectors.toMap(
                 Map.Entry::getKey,  
                 Map.Entry::getValue));

        System.out.print(map);

    }
}

{ 101 =贾斯汀，102 =杰西卡，103 =西蒙}

使用流初始化不可变映射

上面讨论的方法将创建一个可变的映射。但是我们也可以使用 Java 流来创建不可变的映射。这是通过使用collections . collectinganthen()来完成的。

import java.util.Collections;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class Demo
{    
    public static void main(String[] args)
    {
        Map<Integer, String> immutableMap = Stream.of(new Object[][] { 
        {101, "Justin"}, 
        {102, "Jessica"},
        {103, "Simon"}
    }).collect(Collectors.collectingAndThen(
        Collectors.toMap(data -> (Integer) data[0], data -> (String)data[1]), 
        Collections::<Integer, String> unmodifiableMap));

        System.out.println(immutableMap);

        immutableMap.put(104, "Harry");//Error
    }
}

{101=Justin，102=Jessica，103 = Simon } Java . lang . unsupportedoperationexception 在 Java . base/Java . util . collections $ unmodifielemap . put(collections . Java:1473) 在 Demo.main(Demo.java:20)

摘要

Java 中的映射以许多不同的方式初始化。初始化 HashMaps 最简单的方法是使用 put()方法。但是我们不能用它来初始化不可变的映射。我们可以使用 Map.of()和 Map.ofEntries()方法来创建不可变的映射。流也用于创建可变和不可变的映射，但是它们降低了性能。