在Java中初始化哈希表？

在C#中，您可以使用如下代码初始化哈希表（以及许多其他类型的对象-

Hashtable table = new Hashtable {{1, 1}, {2, 2}};

Java中是否有类似的功能，或者您必须先声明哈希表，然后手动将项目逐个放入其中？

C#的一个特性，我非常喜欢它的初始化内联功能。不幸的是，Java没有这个特性

Java

哈希表

也没有任何允许此操作的构造函数。请参阅Java API文档中的构造函数列表：

---

这在Java中是不可能的。我们都会因此而痛苦。

这在其他地方得到了回答，但您可以使用匿名子类：

new HashMap<Integer, Integer>() {{ put(1, 1); put(2, 2); }};

newhashmap（）{{put（1,1）；put（2,2）；}；

很多锅炉板，但仍然是一个内衬：）。不幸的是，这也会抱怨缺少serialVersionUID常量，您可以添加该常量或忽略其上的警告

---

这称为实例初始值设定项块，更多信息。

有一种称为双括号初始化的东西，它不太好

Hashtable table = new Hashtable() {
    {
        table.put(1, 1);
        table.put(2, 2);
    }
};

您甚至可以使用匿名数组表示法进行指定，然后自己对其进行迭代，如下所示：

Hashtable table = new Hashtable() {
    {
        for (int[] entry : new int[][] { { 1, 1 }, { 2, 2 } }) {
            table.put(entry[0], entry[1]);
        }
    }
};

String[] names={"albert","john","michel"};
int[] id={1234,2345,3456};
Hashtable<int,String> persons = new Hashtable<int,String>();

for(int i=0;i<3;i++)
{
 persons.put(id[i],names[i]);
}

如果您真的缺少python，也许可以创建一个实用函数：）

试试以下方法：

Hashtable<Integer, String> ht = new Hashtable<Integer, String>(){
    {
        put(1,"One");
        put(2,"Two");
        put(3,"Three");
    }
};

Hashtable ht=new Hashtable（）{
{
付诸表决（1，“一”）；
付诸表决（2，“两”）；
付诸表决（3，“三”）；
}
};

如果需要初始化哈希映射（哈希表已过时），可以使用静态初始化块

例如：

private static Map<String, String> map;

static {
    map = new HashMap<String, String>();
    map.put("name1", "value1");
    map.put("name2", "value2");
    ....
}

私有静态映射；
静止的{
map=新的HashMap（）；
地图放置（“名称1”、“价值1”）；
地图放置（“名称2”、“价值2”）；
....
}

希望这有帮助，玩得开心

在中，如果需要不可变的映射，可以使用：

Map<K,V> m = ImmutableMap.of(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);

Map m=ImmutableMap.of（k1、v1、k2、v2、k3、v3、k4、v4、k5、v5）；

最多5个键/值对

除此之外，您还可以使用他们的类：

ImmutableMap WORD\u TO\u INT=ImmutableMap.builder（）
.put（“一”，1）
.put（“两个”，2）
.put（“三”，3）
.build（）；

仍然没有C#那么好，但是fluent API有点帮助。

另一个答案（除了明显的“不——没有母语的方式来做这件事”）：

使用静态工厂方法创建一个元组类，为简洁起见，该方法的名称为“u”：

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

class Tuple<T1,T2> {
    private T1 t1;
    private T2 t2;
    public Tuple(T1 t1, T2 t2) {
         this.t1 = t1; this.t2 = t2;
    }
    public T1 getT1() {return t1;}
    public T2 getT2() {return t2;}

    static public <X,Y> Tuple<X,Y> _(X t1, Y t2) { return new Tuple<X,Y>(t1,t2); }
    static public <X,Y> Map<X,Y> mapFor(Tuple<X,Y>... tuples) {
        Map<X,Y> map = new HashMap<X,Y>();
        for( Tuple<X,Y> tuple: tuples ) {
           map.put(tuple.getT1(), tuple.getT2());
        }
        return map;
    }

    public static void main(String[] args) {
        Map<String,Integer> map = Tuple.mapFor( _("A", 1), _("B", 2), _("C",3));
    }
}

import java.util.Map；
导入java.util.HashMap；
类元组{
私人T1；
私人T2；
公共元组（T1，T2）{
this.t1=t1；this.t2=t2；
}
公共T1 getT1（）{return T1；}
公共T2 getT2（）{return T2；}
静态公共元组X（t1，yt2）{返回新元组（t1，t2）；}
静态公共映射映射（元组…元组）{
Map Map=newhashmap（）；
for（元组：元组）{
put（tuple.getT1（），tuple.getT2（））；
}
返回图；
}
公共静态void main（字符串[]args）{
Map Map=Tuple.mapFor（（“A”，1），（“B”，2），（“C”，3））；
}
}

如果您想允许生成哪种类型的支持图，您可以将其传入：

    static public <X,Y> Map<X,Y> mapFor(Map<X,Y> map, Tuple<X,Y>... tuples) {
        for( Tuple<X,Y> tuple: tuples ) {
           map.put(tuple.getT1(), tuple.getT2());
        }
        return map;
    }

静态公共映射映射（映射映射、元组…元组）{
for（元组：元组）{
put（tuple.getT1（），tuple.getT2（））；
}
返回图；
}

一种安全的方法是使用番石榴的

ImmutableMap.of

，如果需要可变性，可以选择使用

newHashSet

包装：

Maps.newHashMap(ImmutableMap.of(k1, v1, ...));

这里有一个自编的内联地图生成器，例如

newMap（1，“1”，2，“2”，3，“3”）

公共静态映射newMap（最终K键、最终V值、最终对象…元素）{
先决条件。checkNotNull（键）；
前提条件.checkArgument（elements.length%2==0，“数组长度不能为”+elements.length）；
final HashMap map=Maps.newHashMap（）；
map.put（键、值）；
对于（int i=0；i

我建议这样做：

Hashtable table = new Hashtable() {
    {
        for (int[] entry : new int[][] { { 1, 1 }, { 2, 2 } }) {
            table.put(entry[0], entry[1]);
        }
    }
};

String[] names={"albert","john","michel"};
int[] id={1234,2345,3456};
Hashtable<int,String> persons = new Hashtable<int,String>();

for(int i=0;i<3;i++)
{
 persons.put(id[i],names[i]);
}

String[]name={“albert”、“john”、“michel”}；
int[]id={123423456}；
Hashtable persons=新的Hashtable（）；
对于（inti=0；iNo，Java没有对象初始值设定项。在C#和Java中，都有比
哈希表
类更好的选择：在C#中，首选
字典
，在Java中首选
哈希映射
。更一般地说，Java不支持成员初始化列表构造函数。+1，或者编写自己的实用程序：
makeMap>（A、B、Object…remaining）
然后手动迭代剩余的对象，将它们交替转换为A和B，并将它们添加到返回的映射中。不是类型安全而是简洁（可能对测试代码有用）。这不仅不会是类型安全的，而且您甚至无法强制执行正确的偶数arg计数。但是，是的，它在不太正式的设置（如测试代码）中可能很有用。不过，这里可能存在内存泄漏。因为您创建的是匿名类，所以它将引用其封闭类（即此代码出现的类）。这意味着只要这个
映射
仍然存在，那么封闭类也是如此。如果封闭类的生命周期比
映射
的生命周期短（例如，
映射
是长期存在的，而封闭类是负责创建
映射
的某个生成器）是的，其中一个“聪明但不推荐”的想法。DBI认为是有害的；-）
HashMap
完成了同样的事情。请仔细检查讨论这件事的帖子上已经给出的答案。这也会有@yshavit在评论中提到的同样的内存泄漏问题吗。