1. 将其他数据类型转换为字符串：将数字 123 转换为字符串 "123"。
2. 将字符串转换为其他数据类型：将字符串 "123" 转换为数字 123。

下面我将详细讲解这两种转换的各种方法和最佳实践。

将其他数据类型转换为字符串

这是最简单的一类转换，Java 提供了多种方式。

方法 1：使用 String.valueOf() (推荐)

这是最常用、最安全的方法，它是一个静态方法，可以接受所有基本数据类型和对象作为参数,并将其转换为字符串。

int num = 100;
double pi = 3.14159;
boolean flag = true;
char c = 'A';
Object obj = new Object(); // 任意对象
// 使用 String.valueOf()
String str1 = String.valueOf(num);        // "100"
String str2 = String.valueOf(pi);        // "3.14159"
String str3 = String.valueOf(flag);      // "true"
String str4 = String.valueOf(c);         // "A"
String str5 = String.valueOf(obj);       // 对象的字符串表示，如 "java.lang.Object@1b6d3586"
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);
System.out.println(str5);

优点：

• 代码简洁直观。
• 可以处理所有基本类型和对象，是 toString() 方法的便捷包装。
• 当参数为 null 时，它会返回字符串 "null"，而不会抛出 NullPointerException。

方法 2：使用 toString() 方法

每个 Java 对象都有一个 toString() 方法，用于返回该对象的字符串表示形式，基本数据类型没有 toString() 方法，但它们的包装类（如 Integer, Double）有。

int num = 200;
Integer numObj = 200;
double pi = 3.14;
Double piObj = 3.14;
// 对于基本类型，需要先装箱
String str1 = Integer.toString(num);   // "200"
String str2 = Double.toString(pi);    // "3.14"
// 对于对象，可以直接调用
String str3 = numObj.toString();      // "200"
String str4 = piObj.toString();      // "3.14"
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);
System.out.println(str4);

注意事项：

• 如果对象是 null，直接调用 toString() 会抛出 NullPointerException，这是 String.valueOf() 相比的一个劣势。

方法 3：使用空字符串连接 (简单但不够优雅)

这是最简单的一种方式，通过将任何类型与一个空字符串 连接起来，Java 会自动调用其 toString() 方法。

int num = 300;
String str1 = "" + num; // "300"
double pi = 3.14;
String str2 = "" + pi; // "3.14"
boolean flag = false;
String str3 = "" + flag; // "false"
System.out.println(str1);
System.out.println(str2);
System.out.println(str3);

缺点：

• 性能较差：在底层，这会创建一个 StringBuilder 对象来完成拼接，虽然现代 JVM 优化得很好，但在性能敏感的场景下，String.valueOf() 仍然是更好的选择。
• 可读性稍差：对于复杂的代码，String.valueOf() 的意图更明确。

方法 4：使用字符串格式化

当你需要将多个变量组合成一个格式化的字符串时，String.format() 非常强大。

String name = "Alice";
int age = 30;
double salary = 75000.50;
// 使用类似 C 的 printf 格式化
String info = String.format("Name: %s, Age: %d, Salary: %.2f", name, age, salary);
// info 的值是 "Name: Alice, Age: 30, Salary: 75000.50"
System.out.println(info);

这里的 %s, %d, %.2f 是格式说明符，String.format() 会用后面的变量依次替换它们。

将字符串转换为其他数据类型

这是更需要注意异常处理的一类转换,因为用户输入的字符串可能不符合目标类型的格式。

方法 1：使用包装类的 parseXxx() 或 valueOf() 方法

这是最标准的方法，每个基本数据类型的包装类（Integer, Double, Boolean 等）都提供了静态方法来解析字符串。

• parseXxx(String s)：解析字符串,返回对应的基本数据类型。
• valueOf(String s)：解析字符串,返回对应的包装类对象。

String numStr = "123";
String piStr = "3.14159";
String boolStr = "true";
String invalidStr = "abc";
// 转换为 int
int num = Integer.parseInt(numStr); // 123
// int num2 = Integer.parseInt(piStr); // 抛出 NumberFormatException
// int num3 = Integer.parseInt(invalidStr); // 抛出 NumberFormatException
// 转换为 double
double pi = Double.parseDouble(piStr); // 3.14159
// 转换为 boolean
boolean flag = Boolean.parseBoolean(boolStr); // true
// Boolean.parseBoolean("false") -> false
// Boolean.parseBoolean("anything else") -> false (注意这个特性)
// 使用 valueOf 返回包装类对象
Integer numObj = Integer.valueOf(numStr); // Integer(123)
Double piObj = Double.valueOf(piStr);     // Double(3.14159)

核心：异常处理 如果字符串的格式不正确（"abc" 无法解析为整数），这些方法会抛出 NumberFormatException。必须使用 try-catch 块来处理这种可能性。

public static int safeStringToInt(String str) {
    try {
        return Integer.parseInt(str);
    } catch (NumberFormatException e) {
        System.err.println("无法将字符串 '" + str + "' 转换为整数。");
        return 0; // 或者返回一个默认值，或者抛出自定义异常
    }
}
String input = "123a";
int result = safeStringToInt(input); // 会打印错误信息，并返回 0
System.out.println("转换结果: " + result);

方法 2：处理带千位分隔符的数字

在处理用户输入或国际化数据时，数字可能包含逗号（）作为千位分隔符，"1,000,000"，直接调用 Integer.parseInt() 会失败。

这时需要使用 NumberFormat 类。

import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
String numberWithCommas = "1,234,567";
String piWithCommas = "3,14159"; // 这种格式 Double.parse 也会失败
// 使用 NumberFormat 解析整数
NumberFormat integerFormat = NumberFormat.getIntegerInstance(Locale.US); // 使用美国格式
try {
    int num = integerFormat.parse(numberWithCommas).intValue();
    System.out.println("解析整数成功: " + num); // 1234567
} catch (ParseException e) {
    e.printStackTrace();
}
// 使用 NumberFormat 解析浮点数
NumberFormat decimalFormat = NumberFormat.getNumberInstance(Locale.US);
try {
    double pi = decimalFormat.parse(piWithCommas).doubleValue();
    System.out.println("解析浮点数成功: " + pi); // 314159.0 (注意，它把逗号当成了分隔符，这通常是错误的)
} catch (ParseException e) {
    e.printStackTrace();
}

注意：NumberFormat 对千位分隔符非常敏感，但对于小数点，最好还是确保输入是标准格式（如 14159），或者使用 DecimalFormat 进行更精细的控制。

总结与最佳实践

核心要点：

1. 转换到字符串：优先使用 String.valueOf()。
2. 转换到基本类型：优先使用 Integer.parseInt(), Double.parseDouble() 等，并始终将其包裹在 try-catch 块中,以优雅地处理无效输入。
3. null 值：String.valueOf(null) 返回 "null"，而 null.toString() 会直接导致程序崩溃。
4. 格式化：当需要生成结构化的、可读性强的字符串时，String.format() 是你的不二之选。