字符串里存的到底是什么信息？ 不同的信息格式需要不同的转换方法。

下面我将分几种最常见的情况,为你详细讲解如何将 String 转换为 Object，并提供完整的代码示例。

核心思想

String 本身就是一个 Object（String 类继承自 Object），最简单的“转换”就是直接使用，但通常我们说的“转换”，是指将一个包含结构化数据的字符串，转换成一个特定类型的 Java 对象。

• "123" -> 转换为 Integer 对象 123
• "2025-10-27T10:00:00" -> 转换为 java.util.Date 或 java.time.LocalDateTime 对象
• "{\"name\":\"张三\", \"age\":30}" -> 转换为一个包含 name 和 age 字段的 User 对象

转换为基础数据类型对象（如 Integer, Double, Boolean 等）

当字符串表示一个基本数据类型时,可以使用其对应的包装类的 parseXxx() 或 valueOf() 方法。

示例：将 "123" 转换为 Integer 对象

public class StringToObjectExample {
    public static void main(String[] args) {
        String strNumber = "123";
        // 方法1: 使用 Integer.parseInt()，返回的是基本类型 int
        // int primitiveInt = Integer.parseInt(strNumber); // int
        // 方法2: 使用 Integer.valueOf()，返回的是 Integer 对象 (推荐)
        Integer integerObject = Integer.valueOf(strNumber);
        System.out.println("原始字符串: " + strNumber);
        System.out.println("转换后的对象: " + integerObject);
        System.out.println("对象的类型: " + integerObject.getClass().getName());
        System.out.println("是否为 Integer 对象: " + (integerObject instanceof Integer));
    }
}

其他基础类型：

转换为日期时间对象

日期时间的格式非常多样,Java 8 引入的 java.time 包提供了强大且易用的 API。

示例1：使用 java.time (推荐)

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class StringToDateExample {
    public static void main(String[] args) {
        // ISO-8601 格式，可以直接解析
        String isoDateTimeStr = "2025-10-27T15:30:00";
        LocalDateTime dateTime = LocalDateTime.parse(isoDateTimeStr);
        System.out.println("ISO格式解析结果: " + dateTime);
        // 自定义格式
        String customDateTimeStr = "27/10/2025 15:30:00";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy HH:mm:ss");
        LocalDateTime customDateTime = LocalDateTime.parse(customDateTimeStr, formatter);
        System.out.println("自定义格式解析结果: " + customDateTime);
    }
}

示例2：使用旧的 java.util.Date 和 SimpleDateFormat (不推荐用于新代码)

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class StringToDateOldExample {
    public static void main(String[] args) {
        String dateStr = "2025-10-27 15:30:00";
        // 注意：SimpleDateFormat 不是线程安全的，不要在多线程环境下共享其实例
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            Date date = sdf.parse(dateStr);
            System.out.println("解析结果: " + date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

转换为 JSON 对象（最常见）

在现代应用中,字符串最常用于表示 JSON 格式的数据，我们需要使用 JSON 库来完成转换，这里以最流行的 Jackson 和 Gson 为例。

准备一个 POJO (Plain Old Java Object)

定义一个与 JSON 结构对应的 Java 类。

// User.java
public class User {
    private String name;
    private int age;
    private boolean isActive;
    // 必须有无参构造函数，以便 Jackson/Gson 反序列化
    public User() {
    }
    // Getters and Setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public boolean isActive() { return isActive; }
    public void setActive(boolean active) { isActive = active; }
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", isActive=" + isActive +
                '}';
    }
}

使用 Jackson 库

添加 Jackson 依赖到你的项目中 (Maven):

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

转换代码：

import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonJacksonExample {
    public static void main(String[] args) throws Exception {
        String jsonString = "{\"name\":\"李四\", \"age\":25, \"isActive\":true}";
        // 创建 ObjectMapper 实例 (推荐作为单例管理)
        ObjectMapper objectMapper = new ObjectMapper();
        // 将 JSON 字符串转换为 User 对象
        User user = objectMapper.readValue(jsonString, User.class);
        System.out.println("转换后的对象: " + user);
        System.out.println("名字: " + user.getName());
    }
}

使用 Gson 库

添加 Gson 依赖到你的项目中 (Maven):

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version> <!-- 使用最新版本 -->
</dependency>

转换代码：

import com.google.gson.Gson;
public class JsonGsonExample {
    public static void main(String[] args) {
        String jsonString = "{\"name\":\"王五\", \"age\":28, \"isActive\":false}";
        // 创建 Gson 实例 (推荐作为单例管理)
        Gson gson = new Gson();
        // 将 JSON 字符串转换为 User 对象
        User user = gson.fromJson(jsonString, User.class);
        System.out.println("转换后的对象: " + user);
        System.out.println("年龄: " + user.getAge());
    }
}

转换为 XML 对象

与 JSON 类似，转换 XML 也需要借助库，如 JAXB (Java Architecture for XML Binding, 内置于 JDK 6+) 或 Dom4j。

使用 JAXB (JDK 内置)

在 POJO 类上添加 JAXB 注解。

import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement // 表示这个类是 XML 的根元素
public class UserXml {
    private String name;
    private int age;
    // JAXB 需要通过无参构造函数和 setter 方法来创建和填充对象
    public UserXml() {
    }
    @XmlElement(name = "userName") // 可以指定 XML 中的元素名
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    @Override
    public String toString() {
        return "UserXml{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

转换代码：

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.StringReader;
public class XmlJaxbExample {
    public static void main(String[] args) throws JAXBException {
        String xmlString = "<userXml><userName=\"赵六\" age=\"32\"/></userXml>";
        // 创建 JAXBContext
        JAXBContext jaxbContext = JAXBContext.newInstance(UserXml.class);
        // 创建 Unmarshaller (用于 XML -> Object)
        Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
        // 从字符串进行转换
        UserXml user = (UserXml) unmarshaller.unmarshal(new StringReader(xmlString));
        System.out.println("转换后的对象: " + user);
    }
}

总结与最佳实践

核心步骤：

1. 明确目标：确定你希望得到的 Object 是什么类型。
2. 选择工具：根据字符串的格式（纯文本、JSON、XML）选择合适的解析方法或库。
3. 准备模型：如果是 JSON 或 XML，创建一个与之结构匹配的 Java 类（POJO）。
4. 调用解析方法：使用选定的库将字符串解析为目标对象。
5. 处理异常：始终将解析操作（如 parse, readValue）放在 try-catch 块中，以处理格式错误等异常情况。