本文旨在提供高效且易于维护的方法，解决 Java 对象与特定格式字符串之间的双向映射问题。在需要将 Java 对象的配置信息以特定格式（如 a1:0.1|a2:0.5|fl:true）传递或存储时，手动编写序列化和反序列化逻辑容易出错且难以维护。本文将介绍三种不同的方法：使用 JSON 库、利用 Properties 类以及借助 Scanner 类，来优雅地实现对象字段与字符串之间的双向映射，避免硬编码，提高代码的可读性和可维护性。
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
}
}说明：
优点：
缺点：
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
}
}说明：
优点：
缺点：
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
}
}说明：
优点：
缺点：
本文介绍了三种不同的方法来实现 Java 对象与字符串之间的双向映射。选择哪种方法取决于具体的应用场景和需求。
无论选择哪种方法，都应该尽量避免硬编码映射关系，提高代码的可读性和可维护性。使用常量来定义字段名和分隔符，可以减少出错的可能性。同时，应该编写单元测试来验证序列化和反序列化逻辑的正确性。
以上就是Java 对象与字符串的双向映射：高效配置序列化与反序列化指南的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
183
收藏
