本文旨在提供高效且易于维护的方法，解决 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免费学习笔记（深入）”；
com.fasterxml.jackson.core jackson-databind 2.13.0
然后，创建包含 @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('\n');
buf.append(A2).append(DELIMITER).append(arg2).append('\n');
buf.append(FL).append(DELIMITER).append(flag).append('\n');
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 类。
无论选择哪种方法，都应该尽量避免硬编码映射关系，提高代码的可读性和可维护性。使用常量来定义字段名和分隔符，可以减少出错的可能性。同时，应该编写单元测试来验证序列化和反序列化逻辑的正确性。
