首页 > 文章 > java教程

Java对象与字符串的高效映射技巧

时间：2025-07-29 12:03:28 284浏览收藏

推广推荐

支持 PC / 移动端，安全直达

小伙伴们对文章编程感兴趣吗？是否正在学习相关知识点？如果是，那么本文《Java 对象与字符串的优雅映射方法》，就很适合你，本篇文章讲解的知识点主要包括。在之后的文章中也会多多分享相关知识点，希望对大家的知识积累有所帮助！

Java 对象与字符串的双向映射：更优雅的实现方案

本文针对 Java 对象与特定格式字符串之间的相互转换问题，提供了三种更具维护性和可读性的解决方案。避免了硬编码映射，分别利用 JSON 序列化、Properties 类以及 Scanner 类，实现了 Config 对象的序列化与反序列化，旨在帮助开发者选择最适合自身场景的方法，提高代码质量和开发效率。

在实际开发中，经常会遇到需要将 Java 对象转换为字符串，或者将字符串转换为 Java 对象的需求，例如将配置对象转换为 HTTP 请求参数，或者将 HTTP 响应数据转换为配置对象。一种常见的做法是使用硬编码的方式进行映射，但这种方式缺乏可维护性，容易出错。本文将介绍三种更优雅的实现方案，分别是使用 JSON 序列化、Properties 类以及 Scanner 类。

方案一：使用 JSON 序列化

JSON 序列化是一种常用的数据交换格式，具有良好的可读性和跨平台性。通过使用 Jackson 等 JSON 库，可以轻松地将 Java 对象序列化为 JSON 字符串，也可以将 JSON 字符串反序列化为 Java 对象。

示例代码：

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 (optional, but recommended)
        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;
        }
    }
}

代码解释：

引入 Jackson 库的依赖。
在 Config 类的字段上使用 @JsonProperty 注解，指定字段对应的 JSON 属性名。
使用 ObjectMapper 类的 writeValueAsString 方法将 Config 对象序列化为 JSON 字符串。
使用 ObjectMapper 类的 readValue 方法将 JSON 字符串反序列化为 Config 对象。

注意事项：

需要引入 Jackson 库的依赖。
可以使用 @JsonIgnore 注解忽略不需要序列化/反序列化的字段。
可以使用 @JsonFormat 注解指定日期/时间的格式。

方案二：使用 Properties 类

Properties 类是 Java 中用于处理配置文件的类，可以将 Java 对象转换为 Properties 文件格式的字符串，也可以将 Properties 文件格式的字符串反序列化为 Java 对象。

示例代码：

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("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 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;
        }
    }
}

代码解释：

定义 Config 类，包含需要序列化/反序列化的字段。
在 Config 类中定义 store 方法，用于将 Config 对象转换为 Properties 文件格式的字符串。
在 Config 类中定义 load 方法，用于将 Properties 文件格式的字符串反序列化为 Config 对象。
在 store 方法中，使用 Properties 类的 setProperty 方法设置属性值。
在 load 方法中，使用 Properties 类的 getProperty 方法获取属性值。

注意事项：

Properties 文件格式的字符串只能包含字符串类型的属性值。
可以使用 Properties 类的 store 方法将 Properties 对象保存到文件中。
可以使用 Properties 类的 load 方法从文件中加载 Properties 对象。

方案三：使用 Scanner 类

Scanner 类是 Java 中用于扫描输入流的类，可以将 Java 对象转换为特定格式的字符串，也可以将特定格式的字符串反序列化为 Java 对象。

示例代码：

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

            return config;
        }

        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;
        }
    }
}

代码解释：

定义 Config 类，包含需要序列化/反序列化的字段。
在 Config 类中定义 serialize 方法，用于将 Config 对象转换为特定格式的字符串。
在 Config 类中定义 deserialize 方法，用于将特定格式的字符串反序列化为 Config 对象。
在 serialize 方法中，使用 StringBuilder 类拼接字符串。
在 deserialize 方法中，使用 Scanner 类的 useDelimiter 方法设置分隔符。
在 deserialize 方法中，使用 Scanner 类的 next 方法获取属性值。

注意事项：

需要根据实际情况设置分隔符。
需要根据实际情况使用 Scanner 类的不同方法获取不同类型的属性值。
需要注意处理异常情况。

总结

本文介绍了三种更优雅的 Java 对象与字符串的双向映射方案，分别是使用 JSON 序列化、Properties 类以及 Scanner 类。每种方案都有其优缺点，开发者可以根据实际情况选择最适合自身场景的方案。

JSON 序列化： 优点是可读性好，跨平台性好，缺点是需要引入额外的依赖。
Properties 类： 优点是简单易用，缺点是只能处理字符串类型的属性值。
Scanner 类： 优点是灵活性高，可以处理各种格式的字符串，缺点是需要手动解析字符串。

选择合适的方案可以提高代码质量和开发效率，避免硬编码映射带来的问题。

今天关于《Java对象与字符串的高效映射技巧》的内容就介绍到这里了，是不是学起来一目了然！想要了解更多关于的内容请关注golang学习网公众号！