本文旨在提供高效且易于维护的方法，解决 Java 对象与特定格式字符串之间的双向映射问题。在需要将 Java 对象的配置信息以特定格式（如 a1:0.1|a2:0.5|fl:true）传递或存储时，手动编写序列化和反序列化逻辑容易出错且难以维护。本文将介绍三种不同的方法：使用 json 库、利用 Properties 类以及借助 Scanner 类，来优雅地实现对象字段与字符串之间的双向映射，避免硬编码，提高代码的可读性和可维护性。
方案一：使用 JSON 库
JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，非常适合用于序列化和反序列化 Java 对象。通过使用像 Jackson 这样的 JSON 库，可以轻松地将 Java 对象转换为 JSON 字符串，反之亦然。
示例代码：
首先，需要添加 Jackson 依赖到你的项目中。 如果使用 maven，可以在 pom.xml 文件中添加以下依赖：
立即学习“Java免费学习笔记（深入）”；
<dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>2.13.0</version> <!-- 请使用最新版本 --> </dependency>
然后，创建包含 @JsonProperty 注解的 Config 类：
import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.databind.ObjectMapper; public class Config { @JsonProperty("a1") private float arg1; @JsonProperty("a2") private float arg2; @JsonProperty("fl") private boolean flag; // Getters and setters (建议添加) public float getArg1() { return arg1; } public void setArg1(float arg1) { this.arg1 = arg1; } public float getArg2() { return arg2; } public void setArg2(float arg2) { this.arg2 = arg2; } public boolean isFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } public static void main(String... args) throws JsonProcessingException { Config config = new Config(); config.setArg1(0.1f); config.setArg2(0.5f); config.setFlag(true); ObjectMapper mapper = new ObjectMapper(); String json = mapper.writeValueAsString(config); System.out.println("JSON: " + json); // 输出: {"a1":0.1,"a2":0.5,"fl":true} Config res = mapper.readValue(json, Config.class); System.out.println("arg1: " + res.getArg1()); // 输出: arg1: 0.1 System.out.println("arg2: " + res.getArg2()); // 输出: arg2: 0.5 System.out.println("flag: " + res.isFlag()); // 输出: flag: true } }
说明：
- @JsonProperty(“a1”) 注解用于指定 JSON 字符串中字段 a1 对应于 Config 类的 arg1 字段。
- ObjectMapper 类负责将 Java 对象序列化为 JSON 字符串 (writeValueAsString)，以及将 JSON 字符串反序列化为 Java 对象 (readValue)。
- 务必包含 getter 和 setter 方法，Jackson 需要通过这些方法访问和设置字段值。
优点：
- 简洁易用，代码量少。
- 可读性强，JSON 格式清晰明了。
- 通用性强，JSON 是一种广泛使用的数据交换格式。
缺点：
- 需要引入额外的 JSON 库依赖。
- JSON 字符串可能比其他格式更冗长。
方案二：使用 Properties 类
Java 的 Properties 类提供了一种简单的方式来存储和加载键值对。可以将 Java 对象的字段作为键，字段值作为值，存储到 Properties 对象中，然后将其保存到文件或输出流中。
示例代码：
import java.io.*; import java.util.Properties; public class Config { private static final String A1 = "a1"; private static final String A2 = "a2"; private static final String FL = "fl"; private float arg1; private float arg2; private boolean flag; public float getArg1() { return arg1; } public void setArg1(float arg1) { this.arg1 = arg1; } public float getArg2() { return arg2; } public void setArg2(float arg2) { this.arg2 = arg2; } public boolean isFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } public void store(OutputStream out) throws IOException { Properties properties = new Properties(); properties.setProperty(A1, String.valueOf(arg1)); properties.setProperty(A2, String.valueOf(arg2)); properties.setProperty(FL, String.valueOf(flag)); properties.store(out, "Config data"); } public static Config load(InputStream in) throws IOException { Properties properties = new Properties(); properties.load(in); Config config = new Config(); config.setArg1(Float.parseFloat(properties.getProperty(A1, String.valueOf(0.f)))); config.setArg2(Float.parseFloat(properties.getProperty(A2, String.valueOf(0.f)))); config.setFlag(Boolean.parseBoolean(properties.getProperty(FL, String.valueOf(false)))); return config; } public static void main(String... args) throws IOException { Config config = new Config(); config.setArg1(0.1f); config.setArg2(0.5f); config.setFlag(true); File file = new File("foo.properties"); if (file.exists()) { file.delete(); } file.createNewFile(); try (OutputStream out = new FileOutputStream(file, false)) { config.store(out); } Config res = null; try (InputStream in = new FileInputStream(file)) { res = Config.load(in); } System.out.println("arg1: " + res.getArg1()); // 输出: arg1: 0.1 System.out.println("arg2: " + res.getArg2()); // 输出: arg2: 0.5 System.out.println("flag: " + res.isFlag()); // 输出: flag: true } }
说明：
- store(OutputStream out) 方法将 Config 对象的字段存储到 Properties 对象中，然后将 Properties 对象写入到输出流。
- load(InputStream in) 方法从输入流中读取 Properties 对象，然后将 Properties 对象中的值设置到 Config 对象的字段中。
- 使用常量来定义属性名称，提高代码可读性和可维护性。
- getProperty(key, defaultValue) 方法在属性不存在时提供默认值，避免空指针异常。
优点：
- 简单易用，无需引入额外的依赖。
- 可读性较好，Properties 文件格式清晰。
- 支持注释，可以添加描述信息。
缺点：
方案三：使用 Scanner 类
Scanner 类可以用于解析字符串，并将其转换为不同的数据类型。可以自定义序列化和反序列化逻辑，使用分隔符将 Java 对象的字段连接成字符串，然后使用 Scanner 类解析该字符串。
示例代码：
import java.io.IOException; import java.util.Locale; import java.util.Scanner; public class Config { private static final String A1 = "a1"; private static final String A2 = "a2"; private static final String FL = "fl"; private static final String DELIMITER = ":"; private float arg1; private float arg2; private boolean flag; public float getArg1() { return arg1; } public void setArg1(float arg1) { this.arg1 = arg1; } public float getArg2() { return arg2; } public void setArg2(float arg2) { this.arg2 = arg2; } public boolean isFlag() { return flag; } public void setFlag(boolean flag) { this.flag = flag; } public String serialize() throws IOException { StringBuilder buf = new StringBuilder(); buf.append(A1).append(DELIMITER).append(arg1).append(' '); buf.append(A2).append(DELIMITER).append(arg2).append(' '); buf.append(FL).append(DELIMITER).append(flag).append(' '); return buf.toString(); } public static Config deserialize(String str) { Scanner scan = new Scanner(str); scan.useDelimiter(DELIMITER + "|n"); scan.useLocale(Locale.ENGLISH); Config config = new Config(); while (scan.hasNext()) { switch (scan.next()) { case A1: config.setArg1(scan.nextFloat()); break; case A2: config.setArg2(scan.nextFloat()); break; case FL: config.setFlag(scan.nextBoolean()); break; } } return config; } public static void main(String... args) throws IOException { Config config = new Config(); config.setArg1(0.1f); config.setArg2(0.5f); config.setFlag(true); String str = config.serialize(); Config res = Config.deserialize(str); System.out.println("arg1: " + res.getArg1()); // 输出: arg1: 0.1 System.out.println("arg2: " + res.getArg2()); // 输出: arg2: 0.5 System.out.println("flag: " + res.isFlag()); // 输出: flag: true } }
说明：
- serialize() 方法使用 StringBuilder 将字段名和值拼接成字符串，使用 DELIMITER 分隔字段名和值，使用换行符分隔不同的字段。
- deserialize(String str) 方法使用 Scanner 类解析字符串，使用 DELIMITER + “|n” 作为分隔符，将字符串分割成字段名和值，然后将值设置到 Config 对象的字段中。
- scan.useLocale(Locale.ENGLISH) 确保浮点数解析使用英文格式，避免因本地化设置导致解析错误。
优点：
- 不需要引入额外的依赖。
- 可以自定义序列化和反序列化逻辑，灵活性高。
缺点：
- 代码量相对较多。
- 容易出错，需要仔细处理分隔符和数据类型转换。
- 可读性相对较差。
总结
本文介绍了三种不同的方法来实现 Java 对象与字符串之间的双向映射。选择哪种方法取决于具体的应用场景和需求。
- 如果需要处理复杂的数据结构，并且希望代码简洁易用，建议使用 JSON 库。
- 如果只需要存储简单的键值对，并且不需要引入额外的依赖，可以使用 Properties 类。
- 如果需要自定义序列化和反序列化逻辑，并且对性能有较高的要求，可以使用 Scanner 类。
无论选择哪种方法，都应该尽量避免硬编码映射关系，提高代码的可读性和可维护性。使用常量来定义字段名和分隔符，可以减少出错的可能性。同时，应该编写单元测试来验证序列化和反序列化逻辑的正确性。
© 版权声明
文章版权归作者所有，未经允许请勿转载。
THE END
