Java 对象与 String 值的映射转换：多种实现方案详解-java教程-PHP中文网

Java 对象与 String 值的映射转换：多种实现方案详解

心靈之曲

发布： 2025-07-08 17:26:02

原创

834人浏览过

java 对象与 string 值的映射转换：多种实现方案详解

在 Java 开发中，经常会遇到需要将对象转换为字符串，或者将字符串转换为对象的情况。例如，在进行 HTTP 请求时，可能需要将配置对象作为参数传递，这时就需要将其序列化为字符串。反之，接收到 HTTP 响应后，可能需要将响应字符串反序列化为配置对象。本文将围绕 Config 类与特定格式字符串（如 a1:0.1|a2:0.5|fl:true）的双向转换展开，介绍几种实现方案，并分析它们的优缺点。

使用 JSON 进行序列化和反序列化

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。在 Java 中，可以使用 Jackson、Gson 等库来处理 JSON 数据。

以下是使用 Jackson 库实现 Config 对象与 JSON 字符串相互转换的示例代码：

import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;

public class ConfigJsonExample {

    public static void main(String... args) throws JsonProcessingException {
        Config config = new Config();
        config.arg1 = 0.1f;
        config.arg2 = 0.5f;
        config.flag = true;

        ObjectMapper mapper = new ObjectMapper();
        String json = mapper.writeValueAsString(config);
        System.out.println("Serialized JSON: " + json);

        Config res = mapper.readValue(json, Config.class);
        System.out.println("Deserialized Config: arg1=" + res.arg1 + ", arg2=" + res.arg2 + ", flag=" + res.flag);
    }

    public static class Config {
        @JsonProperty("a1")
        private float arg1;
        @JsonProperty("a2")
        private float arg2;
        @JsonProperty("fl")
        private boolean flag;

        // Getters and setters (omitted for brevity)
        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;
        }
    }
}

登录后复制

代码解释:

立即学习“Java免费学习笔记（深入）”；

依赖引入: 需要添加 Jackson 依赖到你的项目中。例如，在 Maven 中，可以添加以下依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version> <!-- 使用最新版本 -->
</dependency>

登录后复制

@JsonProperty 注解: 使用 @JsonProperty 注解将类字段与 JSON 属性名进行映射。例如，arg1 字段被映射到 JSON 属性 a1。
ObjectMapper: ObjectMapper 类是 Jackson 库的核心类，用于执行序列化和反序列化操作。
writeValueAsString(): 将 Config 对象序列化为 JSON 字符串。
readValue(): 将 JSON 字符串反序列化为 Config 对象。

优点:

简单易用，代码简洁。
可读性好，JSON 格式清晰明了。
灵活性高，可以通过注解进行更细粒度的控制。
广泛使用，拥有成熟的生态系统和丰富的文档。

缺点:

需要引入额外的依赖库。
JSON 格式可能比自定义格式更冗长。

使用 Properties 类进行序列化和反序列化

java.util.Properties 类可以用于存储和加载键值对，其中键和值都是字符串。可以将 Config 对象的字段存储为 Properties 对象的键值对，然后将其保存到文件中或从文件中加载。

以下是使用 Properties 类实现 Config 对象与 Properties 文件相互转换的示例代码：

import java.io.*;
import java.util.Properties;

public class ConfigPropertiesExample {

    public static void main(String... args) throws IOException {
        Config config = new Config();
        config.arg1 = 0.1f;
        config.arg2 = 0.5f;
        config.flag = true;

        File file = new File("foo.properties");
        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("Loaded Config: arg1=" + res.arg1 + ", arg2=" + res.arg2 + ", flag=" + res.flag);
    }

    public static 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 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, "Some description");
        }

        public static Config load(InputStream in) throws IOException {
            Properties properties = new Properties();
            properties.load(in);

            Config config = new Config();
            config.arg1 = Float.parseFloat(properties.getProperty(A1, String.valueOf(0.f)));
            config.arg2 = Float.parseFloat(properties.getProperty(A2, String.valueOf(0.f)));
            config.flag = Boolean.parseBoolean(properties.getProperty(FL, String.valueOf(false)));

            return config;
        }

        // Getters and setters (omitted for brevity)
        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;
        }
    }
}

登录后复制

代码解释:

立即学习“Java免费学习笔记（深入）”；

常量定义: 定义常量来存储属性名，避免硬编码。
store() 方法: 将 Config 对象的字段存储到 Properties 对象中，然后将其写入到输出流。
load() 方法: 从输入流中加载 Properties 对象，然后将其转换为 Config 对象。

优点:

不需要引入额外的依赖库。
Properties 文件格式简单易懂。
可以方便地进行配置管理。

缺点:

只能存储字符串类型的键值对，需要进行类型转换。
Properties 文件格式相对简单，缺乏灵活性。
不适合存储复杂的数据结构。

使用 Scanner 进行自定义格式的序列化和反序列化

如果需要使用自定义的字符串格式，可以使用 java.util.Scanner 类来解析字符串，并将其转换为 Config 对象。

以下是使用 Scanner 类实现 Config 对象与自定义格式字符串相互转换的示例代码：

import java.io.IOException;
import java.util.Locale;
import java.util.Scanner;

public class ConfigScannerExample {

    public static void main(String... args) throws IOException {
        Config config = new Config();
        config.arg1 = 0.1f;
        config.arg2 = 0.5f;
        config.flag = true;

        String str = config.serialize();
        System.out.println("Serialized String: " + str);

        Config res = Config.deserialize(str);
        System.out.println("Deserialized Config: arg1=" + res.arg1 + ", arg2=" + res.arg2 + ", flag=" + res.flag);
    }

    public static 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 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.arg1 = scan.nextFloat(); break;
                    case A2: config.arg2 = scan.nextFloat(); break;
                    case FL: config.flag = scan.nextBoolean(); break;
                }
            }

            return config;
        }

        // Getters and setters (omitted for brevity)
        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;
        }
    }
}

登录后复制

代码解释:

立即学习“Java免费学习笔记（深入）”；

serialize() 方法: 使用 StringBuilder 构建自定义格式的字符串。
deserialize() 方法: 使用 Scanner 解析自定义格式的字符串。
- scan.useDelimiter(DELIMITER + "|\n"): 设置分隔符为 ":" 或换行符。
- scan.useLocale(Locale.ENGLISH): 设置 Locale 为 ENGLISH，确保浮点数解析正确。
- 使用 switch 语句根据属性名设置 Config 对象的字段值.

优点:

可以灵活地定义字符串格式。
不需要引入额外的依赖库。

缺点:

代码相对复杂，需要手动解析字符串。
容易出错，需要仔细处理各种边界情况。
可维护性较差，修改字符串格式需要修改代码。

总结

本文介绍了三种在 Java 中实现类字段与 String 值之间双向映射转换的方案：使用 JSON、Properties 类和 Scanner。

JSON: 简单易用，可读性好，灵活性高，但需要引入额外的依赖库。
Properties: 不需要引入额外的依赖库，Properties 文件格式简单易懂，但只能存储字符串类型的键值对，不适合存储复杂的数据结构。
Scanner: 可以灵活地定义字符串格式，但代码相对复杂，容易出错，可维护性较差。

在实际开发中，应根据具体的需求选择最合适的方案。如果需要存储复杂的数据结构，或者需要进行更细粒度的控制，建议使用 JSON。如果只需要存储简单的键值对，并且不需要引入额外的依赖库，可以使用 Properties 类。如果需要使用自定义的字符串格式，可以使用 Scanner，但需要仔细处理各种边界情况，并注意代码的可维护性。

以上就是Java 对象与 String 值的映射转换：多种实现方案详解的详细内容，更多请关注php中文网其它相关文章！