Java 基于“创建”动态创建哈希映射；模板"；带有干净代码的hashmap

我有一组哈希表的数据部分，如下所示：

    static {
       A_map.put(KEY_1, value0);  
       A_map.put(KEY_2, value1);  
       A_map.put(KEY_3, value2);  
       A_map.put(KEY_4, value3);  
       ...
       A_map.put(KEY_N, valueN);  

       B_map.put(KEY_1, Xvalue0);  
       B_map.put(KEY_2, Xvalue1);  
       B_map.put(KEY_3, Xvalue2);  
       B_map.put(KEY_4, Xvalue3);  
       ...
       B_map.put(KEY_N, XvalueN);  


       C_map.put(KEY_1, Yvalue0);  
       C_map.put(KEY_2, Yvalue1);  
       C_map.put(KEY_3, Yvalue2);  
       C_map.put(KEY_4, Yvalue3);  
       ...
       C_map.put(KEY_N, YvalueN);  

    ....etc  
}

即，所有哈希中的键都相同，但每个哈希映射的值不同。
我选择在运行时使用哪个哈希映射，因为我已经将这些哈希映射作为值放到另一个哈希映射中

但我认为这可以更干净。我的意思是，所有hashmap中的键都是相同的，只有值应该根据我在运行时选择的hashmap类型而有所不同。

---

什么是干净设计的好方法？

通常您会在它自己的文件（例如.ini）中提取此类信息。Java为此有自己的类，称为

如果您试图国际化您的应用程序（使用不同语言的键和值的哈希映射），我建议您看看ResourceBundle

如果您真的想坚持使用代码，可以将每个键的所有值写入一个数组，然后通过迭代数组自动创建哈希映射

编辑：

String[]keys={“KEY_1”、“KEY_2”、“KEY_3”}；
字符串[]值={
{“VALUE_1_表示密钥_1”，“VALUE_2_表示密钥_1”，“VALUE_3_表示密钥_1”}，
{“VALUE_1_FOR_KEY_2”，“VALUE_2_FOR_KEY_2”，“VALUE_3_FOR_KEY_2”}，
{“键3的值1”、“键3的值2”、“键3的值3”}，
}
int valueToChoose=1；
HashMap=newHashMap（）；
for（int i=0；i

使用列表而不是HashMap怎么样，因为每个表中的键都是常量和相同的

你可以这样做：

enum Keys {
    _1(0), _2(1), _3(2), _4(3);

    private int id = -1;

    private Keys(int i) {
        this.id = i;
    }

    int index() {
        return id;
    }
}

static {
    aList = new ArrayList<String>(Keys.values().length);
    aList.set(Keys._1.index(), "a1");
    aList.set(Keys._2.index(), "a2");
    aList.set(Keys._3.index(), "a3");
    aList.set(Keys._4.index(), "a4");

    bList = new ArrayList<String>(Keys.values().length);
    bList.set(Keys._1.index(), "b1");
    bList.set(Keys._2.index(), "b2");
    bList.set(Keys._3.index(), "b3");
    bList.set(Keys._4.index(), "b4");

}

枚举键{
_1(0), _2(1), _3(2), _4(3);
私有int id=-1；
私钥（int i）{
这个id=i；
}
int索引（）{
返回id；
}
}
静止的{
aList=新的ArrayList（Keys.values（）.length）；
列表集（键1.index（），“a1”）；
列表集（键2.index（），“a2”）；
列表集（键3.index（），“a3”）；
列表集（键4.index（），“a4”）；
bList=新的ArrayList（Keys.values（）.length）；
bList.set（key._1.index（），“b1”）；
bList.set（key._2.index（），“b2”）；
bList.set（key._3.index（），“b3”）；
bList.set（键4.index（），“b4”）；
}

我认为它非常适合您的用例。

表

是类似于

映射

的结构的极好替代品，而这恰好是您的用例

从概念上讲，您可以使用散列的名称作为行键（示例中的A、B、C等），使用实际键作为列键（示例中的键1、键2、键3等）

当您实际处理哈希表时，我建议您使用：

---

请记住，此结构针对行进行了优化，这意味着仅基于列获取数据将需要一些迭代。

是的，我希望在代码中执行此操作，因为它是关于功能测试的。但是如果我迭代数组，我将如何选择适当的数组？代码示例不起作用，但我明白了您的意思为什么选择valueToChoose init序列化为1？是的，我没有测试它，如果您更清楚地描述预期用途，sryIt可能会有所帮助。假设所有值都具有相同的类型：这是某种“2D HashMap”吗？@Marco13:没有。我正在测试一个服务器API，我有一组特定的值要发送到服务器进行测试。我想要一种比我现有的更干净的方法，即一个接一个地使用所有这些哈希映射。我也需要密钥。如果密钥没有更改，并且在编译时已知，则可以在我的示例中的密钥枚举中添加它们的字符串表示形式另一方面，如果密钥是在运行时确定的，那么我认为@Magnamag的答案是最好的选择。

enum Keys {
    _1(0), _2(1), _3(2), _4(3);

    private int id = -1;

    private Keys(int i) {
        this.id = i;
    }

    int index() {
        return id;
    }
}

static {
    aList = new ArrayList<String>(Keys.values().length);
    aList.set(Keys._1.index(), "a1");
    aList.set(Keys._2.index(), "a2");
    aList.set(Keys._3.index(), "a3");
    aList.set(Keys._4.index(), "a4");

    bList = new ArrayList<String>(Keys.values().length);
    bList.set(Keys._1.index(), "b1");
    bList.set(Keys._2.index(), "b2");
    bList.set(Keys._3.index(), "b3");
    bList.set(Keys._4.index(), "b4");

}

Table<String, String, String> table = 
    HashBasedTable.create(M, N); // M maps, N keys per map

table.put(A, KEY_1, value0);  
table.put(A, KEY_2, value1);  
table.put(A, KEY_3, value2);  
table.put(A, KEY_4, value3);  
...
table.put(A, KEY_N, valueN);  

table.put(B, KEY_1, Xvalue0);  
table.put(B, KEY_2, Xvalue1);  
table.put(B, KEY_3, Xvalue2);  
table.put(B, KEY_4, Xvalue3);  
...
table.put(B, KEY_N, XvalueN);  

...
...

table.put(M, KEY_1, Yvalue0);  
table.put(M, KEY_2, Yvalue1);  
table.put(M, KEY_3, Yvalue2);  
table.put(M, KEY_4, Yvalue3);  
...
table.put(M, KEY_N, YvalueN);

Map<String, String> mapA = table.row(A);