String 本身就是一个 Object，因为 String 类是 Object 类的直接子类，最简单的转换就是直接赋值。

String str = "Hello, World!";
// String 是 Object 的子类，所以可以直接赋值
Object obj = str; 
System.out.println(obj); // 输出: Hello, World!
System.out.println(obj.getClass().getName()); // 输出: java.lang.String

通常我们问这个问题,是想把一个 String 转换成其他特定类型的对象，Integer, Double, Date, 或者一个自定义类的实例。

下面我将分几种情况详细说明。

转换为 Java 包装类型（如 Integer, Double 等）

当你想把一个表示数字的字符串转换成数字对象时,可以使用各个包装类提供的 parseXxx() 或 valueOf() 静态方法。

关键点：

• 如果字符串格式不正确（"abc" 转换为 Integer），会抛出 NumberFormatException。
• parseXxx() 返回的是基本数据类型（如 int, double），需要手动装箱成包装类。
• valueOf() 直接返回包装类对象（Integer, Double），更常用。

示例：String -> Integer

String numberStr = "123";
// 方法1: 使用 Integer.parseInt() + 手动装箱
int primitiveInt = Integer.parseInt(numberStr);
Integer integerObj = Integer.valueOf(primitiveInt);
// 方法2: 直接使用 Integer.valueOf() (推荐)
Integer integerObj2 = Integer.valueOf(numberStr);
Object obj = integerObj2; // Object 可以接收任何对象
System.out.println(obj); // 输出: 123
System.out.println(obj.getClass().getName()); // 输出: java.lang.Integer

示例：String -> Double

String doubleStr = "98.76";
Double doubleObj = Double.valueOf(doubleStr);
Object obj = doubleObj;
System.out.println(obj); // 输出: 98.76
System.out.println(obj.getClass().getName()); // 输出: java.lang.Double

转换为自定义类的对象

这是非常常见的需求,例如将 JSON 字符串或数据库查询结果（字符串形式）转换为一个 JavaBean 对象，这通常需要分两步：

1. 解析字符串：根据字符串的格式（如 JSON, XML, CSV 等）提取出数据。
2. 构造对象：使用解析出的数据创建并填充自定义类的实例。

示例1：简单的手动转换（格式固定）

假设有一个 Person 类，和一个固定格式的字符串 "name:John,age:30"。

定义自定义类 Person.java

public class Person {
    private String name;
    private int age;
    // 构造方法、getter 和 setter
    public Person() {}
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    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 "Person{name='" + name + "', age=" + age + "}";
    }
}

编写转换逻辑

import java.util.Arrays;
import java.util.stream.Collectors;
public class StringToObjectConverter {
    public static void main(String[] args) {
        String str = "name:John,age:30";
        // 1. 解析字符串
        String[] parts = str.split(",");
        String namePart = parts[0]; // "name:John"
        String agePart = parts[1];  // "age:30"
        String name = namePart.split(":")[1];
        String ageStr = agePart.split(":")[1];
        // 2. 构造对象
        Person person = new Person();
        person.setName(name);
        int age = Integer.parseInt(ageStr); // 字符串转基本类型
        person.setAge(age);
        Object obj = person; // 转换为 Object
        System.out.println(obj); // 输出: Person{name='John', age=30}
    }
}

示例2：使用 JSON 库（现代标准做法）

在实际开发中,字符串通常是 JSON 格式，使用成熟的 JSON 库（如 Jackson, Gson）是最高效、最可靠的方式。

添加 Jackson 依赖 (Maven)

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

使用 Jackson 进行转换

假设 JSON 字符串为 "{\"name\":\"Jane\", \"age\":25}"。

import com.fasterxml.jackson.databind.ObjectMapper;
public class JsonStringToObject {
    public static void main(String[] args) throws Exception {
        String jsonStr = "{\"name\":\"Jane\", \"age\":25}";
        // 创建 ObjectMapper 实例
        ObjectMapper objectMapper = new ObjectMapper();
        // 直接将 JSON 字符串映射为 Person 对象
        Person person = objectMapper.readValue(jsonStr, Person.class);
        Object obj = person; // 转换为 Object
        System.out.println(obj); // 输出: Person{name='Jane', age=25}
    }
}

这种方法非常简洁,并且能处理复杂的嵌套对象和数组。

转换为 Date 对象

将日期字符串转换为 java.util.Date 或 java.time 包下的日期时间对象，这通常需要使用 SimpleDateFormat（旧版）或 DateTimeFormatter（新版）来定义日期格式。

注意： SimpleDateFormat 不是线程安全的，在多线程环境下应使用 ThreadLocal 或 Java 8 的新 API。

示例：String -> java.util.Date (旧方式)

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class StringToDate {
    public static void main(String[] args) throws ParseException {
        String dateStr = "2025-10-27 10:00:00";
        String pattern = "yyyy-MM-dd HH:mm:ss";
        SimpleDateFormat sdf = new SimpleDateFormat(pattern);
        Date date = sdf.parse(dateStr);
        Object obj = date;
        System.out.println(obj); // 输出: Fri Oct 27 10:00:00 CST 2025
        System.out.println(obj.getClass().getName()); // 输出: java.util.Date
    }
}

示例：String -> java.time.LocalDateTime (推荐的新方式)

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
public class StringToJavaTime {
    public static void main(String[] args) {
        String dateStr = "2025-10-27T10:00:00";
        String pattern = "yyyy-MM-dd'T'HH:mm:ss";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(pattern);
        LocalDateTime dateTime = LocalDateTime.parse(dateStr, formatter);
        Object obj = dateTime;
        System.out.println(obj); // 输出: 2025-10-27T10:00
        System.out.println(obj.getClass().getName()); // 输出: java.time.LocalDateTime
    }
}

最佳实践建议：

1. 明确目标类型：首先确定你想要的 Object 具体是什么类型。
2. 使用标准库：对于数字和日期，优先使用 Java 标准库提供的 valueOf 和 parse 方法。