Question

在C＃中，你可以使用这样的代码初始化Hashtables（以及许多其他类型的对象） -

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

在Java中是否有这样的东西，或者您是否必须先声明Hashtable，然后逐个手动将项目放入其中？

Answer 1

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

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

很多锅炉板，但仍然是单线:)。不幸的是，这也会抱怨缺少serialVersionUID常量，你可以添加或忽略警告。

这称为实例初始化程序块，更多信息here。

Answer 2

在Google Guava中，如果你想要一个不可变的地图，你可以使用：

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

最多5个键/值对。

除此之外，您可以使用他们的ImmutableMap.Builder课程：

ImmutableMap<String, Integer> WORD_TO_INT = ImmutableMap.builder()
       .put("one", 1)
       .put("two", 2)
       .put("three", 3)
       .build();

仍然不如C＃好，但流畅的API有点帮助。

Answer 3

另一个答案（除了明显的“不 - 没有本地语言方式”）：

为了简洁起见，使用带有花式裤子“_”名称的静态工厂方法创建一个Tuple类：

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));
    }
}

如果您想允许制作哪种支持地图的变体，您可以改为传递它：

    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;
    }

Answer 4

试试这个：

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

Answer 5

有一种叫做双支撑初始化的东西，它不太好......

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]);
        }
    }
};

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

Answer 6

我非常喜欢C＃的一个特性就是能够像这样初始化内联。不幸的是，Java没有这个功能。

Java Hashtable没有任何允许这样做的构造函数。请参阅Java API文档中的构造函数列表：

http://docs.oracle.com/javase/1.4.2/docs/api/java/util/Hashtable.html

Answer 7

如果您需要初始化 HashMap （HashTable已过时），您可以使用静态初始化块。

示例：

private static Map<String, String> map;

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

希望这有帮助，玩得开心！

Answer 8

一种安全的方法是使用Guava中的ImmutableMap.of，如果需要可变性，可以选择用newHashSet包裹：

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

这是一个用于内联使用的自编写地图构建器，例如： newMap(1, "one", 2, "two", 3, "three")。

public static <K, V> Map<K, V> newMap(final K key, final V value, final Object... elements) {
    Preconditions.checkNotNull(key);
    Preconditions.checkArgument(elements.length % 2 == 0, "Array length can't be " + elements.length);

    final HashMap<Object, Object> map = Maps.newHashMap();
    map.put(key, value);
    for (int i = 0; i < elements.length; i += 2) {
        map.put(elements[i], elements[i + 1]);
    }
    return (Map<K, V>) map;
}

Answer 9

我建议这样的事情：

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]);
}

Answer 10

这在Java中是不可能的。我们都受此影响。

在Java中初始化Hashtables？

10 个答案: