如何在Java中实现类似Python的多字典定义方式？

针对你需要把Python中多组字典迁移到Java、避免逐个手动初始化的需求，这里提供几种实用方案：

1. 静态初始化块+HashMap（最接近Python写法） #

把所有映射集中放在一个类里，用静态初始化块一次性填充数据，类加载时自动完成初始化，直接通过类名访问即可，和Python的字典文件逻辑完全一致：

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

public class Dictionary {
    // 提前定义所有静态Map常量
    public static final Map<String, String> convert_en_it = new HashMap<>();
    public static final Map<String, String> convert_number_month = new HashMap<>();
    public static final Map<String, String> conv_simb = new HashMap<>();
    public static final Map<String, String> conv_to_location = new HashMap<>();
    public static final Map<String, Double> sel_hour = new HashMap<>();
    public static final Map<String, String> which_table = new HashMap<>();

    // 静态块一次性填充所有映射
    static {
        // 填充convert_en_it
        convert_en_it.put("Mon", "Mon");
        convert_en_it.put("Tue", "Tue");
        convert_en_it.put("Wed", "Wed");
        convert_en_it.put("Thu", "Thurs");
        convert_en_it.put("Fri", "Fri");
        convert_en_it.put("Sat", "Sat");
        convert_en_it.put("Sun", "Sun");

        // 填充convert_number_month
        convert_number_month.put("1", "January");
        convert_number_month.put("2", "February");
        convert_number_month.put("3", "March");
        convert_number_month.put("4", "April");
        convert_number_month.put("5", "May");
        convert_number_month.put("6", "June");
        convert_number_month.put("7", "July");
        convert_number_month.put("8", "August");
        convert_number_month.put("9", "September");
        convert_number_month.put("10", "October");
        convert_number_month.put("11", "November");
        convert_number_month.put("12", "December");

        // 其他映射按Python原内容依次填充即可
        conv_simb.put("P", "P");
        conv_simb.put("M", "M");
        conv_simb.put("S", "S");
        // ... 剩余键值对
        conv_to_location.put("M", "M");
        conv_to_location.put("P", "P");
        // ... 剩余键值对
        sel_hour.put("M", 3.5);
        sel_hour.put("P", 5.0);
        // ... 剩余键值对
        which_table.put("Z", "biblio");
        which_table.put("Y", "show");
        // ... 剩余键值对
    }
}

使用时直接调用Dictionary.convert_en_it就能访问对应映射，无需手动初始化。

2. Java 9+用Map.ofEntries简化写法 #

如果不需要可变Map，用Map.ofEntries可以写出更接近Python字面量的简洁代码，结合静态导入后可读性更高：

import java.util.Map;
import static java.util.Map.entry;

public class Dictionary {
    public static final Map<String, String> convert_en_it = Map.ofEntries(
        entry("Mon", "Mon"),
        entry("Tue", "Tue"),
        entry("Wed", "Wed"),
        entry("Thu", "Thurs"),
        entry("Fri", "Fri"),
        entry("Sat", "Sat"),
        entry("Sun", "Sun")
    );

    public static final Map<String, String> convert_number_month = Map.ofEntries(
        entry("1", "January"),
        entry("2", "February"),
        entry("3", "March"),
        entry("4", "April"),
        entry("5", "May"),
        entry("6", "June"),
        entry("7", "July"),
        entry("8", "August"),
        entry("9", "September"),
        entry("10", "October"),
        entry("11", "November"),
        entry("12", "December")
    );

    // 其他映射依葫芦画瓢，用entry()逐个定义键值对
    public static final Map<String, String> conv_simb = Map.ofEntries(
        entry("P", "P"),
        entry("M", "M"),
        entry("S", "S"),
        entry("CM", "E"),
        // ... 剩余键值对
    );

    public static final Map<String, Double> sel_hour = Map.ofEntries(
        entry("M", 3.5),
        entry("P", 5.0),
        // ... 剩余键值对
    );
}

如果需要可变Map，只需套一层new HashMap<>(Map.ofEntries(...))即可。

3. 外部配置文件（适合频繁修改的场景） #

如果映射需要经常调整，不想硬编码到Java类里，可以用JSON/Properties等外部文件存储，再通过代码读取：

示例：JSON配置文件 #

创建dictionaries.json：

{
  "convert_en_it": {"Mon": "Mon", "Tue": "Tue", "Wed": "Wed"},
  "convert_number_month": {"1": "January", "2": "February"},
  "sel_hour": {"M": 3.5, "P": 5.0}
}

用Jackson库读取（需引入Jackson依赖）：

import com.fasterxml.jackson.databind.ObjectMapper;
import java.io.File;
import java.util.Map;

public class Dictionary {
    private static final Map<String, Map<String, Object>> ALL_DICTIONARIES;

    static {
        try {
            ObjectMapper mapper = new ObjectMapper();
            ALL_DICTIONARIES = mapper.readValue(
                new File("dictionaries.json"),
                new com.fasterxml.jackson.core.type.TypeReference<Map<String, Map<String, Object>>>() {}
            );
        } catch (Exception e) {
            throw new RuntimeException("加载字典文件失败", e);
        }
    }

    // 提供类型安全的访问方法
    public static Map<String, String> getConvertEnIt() {
        return (Map<String, String>) ALL_DICTIONARIES.get("convert_en_it");
    }

    public static Map<String, Double> getSelHour() {
        return (Map<String, Double>) ALL_DICTIONARIES.get("sel_hour");
    }
}

这种方式实现了数据与代码分离，修改映射无需重新编译Java代码。

4. 代码生成脚本（减少手动劳动） #

如果有几十组映射，手动转换太繁琐，可以写个Python脚本自动把原Python字典转换成Java代码：

import re

def dict_to_java(python_content, class_name="Dictionary"):
    # 匹配Python中的字典定义
    pattern = re.compile(r'(\w+)\s*=\s*({[^}]+})')
    matches = pattern.findall(python_content)
    
    java_code = f"import java.util.Map;\nimport static java.util.Map.entry;\n\npublic class {class_name} {{\n"
    
    for dict_name, dict_body in matches:
        # 提取键值对
        kv_pattern = re.compile(r'"([^"]+)"\s*:\s*([^,]+)')
        kv_pairs = kv_pattern.findall(dict_body)
        
        java_entries = []
        value_type = "String"
        for key, val in kv_pairs:
            # 处理字符串值
            if val.startswith(('"', "'")):
                clean_val = val.strip("'\"")
                java_entries.append(f"entry(\"{key}\", \"{clean_val}\")")
            else:
                # 处理数值类型
                value_type = "Double"
                java_entries.append(f"entry(\"{key}\", {val})")
        
        # 拼接当前Map的Java代码
        java_code += f"    public static final Map<String, {value_type}> {dict_name} = Map.ofEntries(\n"
        java_code += "        " + ",\n        ".join(java_entries) + "\n    );\n\n"
    
    java_code += "}"
    return java_code

# 读取原Python字典文件
with open("dictionary.py", "r", encoding="utf-8") as f:
    python_code = f.read()

# 生成Java代码并保存
java_output = dict_to_java(python_code)
with open("Dictionary.java", "w", encoding="utf-8") as f:
    f.write(java_output)

运行脚本就能直接得到完整的Java字典类，完全不需要手动敲代码。

内容的提问来源于stack exchange，提问作者user17565490