Java中的基本类型类型转换

        在 Java 中，基本类型的 转换是指在某些情况下，Java 编译器会将一种基本类型转换为另一种基本类型，以符合表达式或操作符的要求。这种转换通常发生在以下几种情况下：

1. 自动提升 (Widening Conversion)

• 定义: 这是将一个较小的类型自动转换为较大的类型，以避免数据丢失。自动提升是安全的，因为较大类型能够包含较小类型的所有值。
• 适用范围: 例如，将 int 转换为 long，将 float 转换为 double。
• 示例:

  int a = 42;
  long b = a;  // int 自动提升为 long
  float c = a; // int 自动提升为 float
  double d = c; // float 自动提升为 double
  

2. 算术运算中的自动提升

• 定义: 当在算术运算中使用多种类型时，较小的类型会自动提升为较大的类型，以确保计算的准确性。
• 规则: 在算术运算中，所有的 byte、short 和 char 类型首先会自动提升为 int。如果有更大的类型参与运算，较小的类型会被提升为与最大类型相同的类型。
• 示例:

  byte b = 10;
  char c = 'A';
  int result = b + c; // byte 和 char 都提升为 int，结果是 int 类型
  
  int i = 100;
  double d = 3.14;
  double result2 = i + d; // int 自动提升为 double，结果是 double 类型
  

3. 强制类型转换 (Narrowing Conversion)

• 定义: 这是将较大的类型转换为较小的类型。这种转换可能会导致数据丢失，因此需要通过显式类型转换来实现，不能自动完成。
• 适用范围: 例如，将 double 转换为 float，将 long 转换为 int。

double d = 9.78;
int i = (int) d; // 需要强制转换，结果为 9

4. 包装类型与基本类型之间的自动转换

• 自动装箱 (Autoboxing): 基本类型可以自动转换为其对应的包装类类型。
  • 示例:

    int i = 10;
    Integer wrapper = i; // 自动装箱，将 int 转换为 Integer
    

• 自动拆箱 (Unboxing): 包装类类型可以自动转换为其对应的基本类型。
  • 示例:

    Integer wrapper = 10;
    int i = wrapper; // 自动拆箱，将 Integer 转换为 int
    

5. 布尔类型

• boolean 类型与其他类型不兼容，不能通过自动转换为其他类型，也不能从其他类型自动转换为 boolean。

6.各个基础类型和String之间转换

6.1. 基本类型转换为 String

        将基本类型转换为 String 可以通过以下几种方法实现：

6.1.1 使用 String.valueOf() 方法

        这是最常用和最推荐的方法。String.valueOf() 方法可以将任何基本类型转换为对应的 String 表示。

int i = 42;
String s = String.valueOf(i); // "42"

double d = 3.14;
String s2 = String.valueOf(d); // "3.14"

boolean b = true;
String s3 = String.valueOf(b); // "true"

6.1.2 使用 Integer.toString()、Double.toString() 等方法

        各个包装类（如 Integer, Double 等）提供了 toString() 方法，专门用于将基本类型转换为字符串。

int i = 42;
String s = Integer.toString(i); // "42"

double d = 3.14;
String s2 = Double.toString(d); // "3.14"

6.1.3 通过字符串连接（隐式调用 toString() 方法）

        当你将基本类型与字符串进行连接时，Java 会隐式调用 String.valueOf() 方法，将基本类型转换为字符串。

int i = 42;
String s = i + ""; // "42"

double d = 3.14;
String s2 = d + ""; // "3.14"

6.2. String 转换为基本类型

        将 String 转换为基本类型，可以使用对应包装类的 parseXXX() 方法或 valueOf() 方法。

6.2.1 使用 parseXXX() 方法

        各个包装类提供了 parseInt()、parseDouble()、parseBoolean() 等方法，可以将字符串转换为对应的基本类型。

String s = "42";
int i = Integer.parseInt(s); // 42

String s2 = "3.14";
double d = Double.parseDouble(s2); // 3.14

String s3 = "true";
boolean b = Boolean.parseBoolean(s3); // true

6.2.2 使用 valueOf() 方法

        valueOf() 方法返回的是包装类对象。你可以通过拆箱将其转换为对应的基本类型。

String s = "42";
int i = Integer.valueOf(s); // 42

String s2 = "3.14";
double d = Double.valueOf(s2); // 3.14

String s3 = "true";
boolean b = Boolean.valueOf(s3); // true

注意事项
NumberFormatException: 如果字符串不符合对应基本类型的格式，调用 parseXXX() 方法时会抛出 NumberFormatException。
boolean 类型转换: 对于 boolean 类型，parseBoolean() 和 valueOf() 方法将字符串转换为 true 或 false。"true"（忽略大小写）返回 true，其他任意字符串返回 false。 

6.3. 示例总结

public class ConversionExample {
    public static void main(String[] args) {
        // 基本类型转换为 String
        int i = 42;
        String str1 = String.valueOf(i); // "42"
        String str2 = Integer.toString(i); // "42"
        String str3 = i + ""; // "42"

        // String 转换为基本类型
        String str4 = "42";
        int j = Integer.parseInt(str4); // 42
        int k = Integer.valueOf(str4); // 42

        String str5 = "true";
        boolean b = Boolean.parseBoolean(str5); // true

        // 错误处理
        try {
            String str6 = "42a";
            int l = Integer.parseInt(str6); // 会抛出 NumberFormatException
        } catch (NumberFormatException e) {
            System.out.println("无法将字符串转换为整数: " + e.getMessage());
        }
    }
}

6.4. 小结

基本类型转换为 String：
使用 String.valueOf() 方法。
使用对应包装类的 toString() 方法。
通过字符串连接进行隐式转换。
String 转换为基本类型:
使用对应包装类的 parseXXX() 方法（返回基本类型）。
使用对应包装类的 valueOf() 方法（返回包装类型，再拆箱为基本类型）。
这些转换方法让 Java 程序在处理数据时更加灵活和方便。

小结

• 自动提升: 小类型自动转换为大类型，确保数据不丢失。
• 算术运算中的自动提升: 在运算中，小类型会自动提升为合适的较大类型。
• 强制类型转换: 大类型转换为小类型，可能会丢失数据，因此需要显式转换。
• 自动装箱与拆箱: 基本类型与其对应的包装类型之间的自动转换。

这些自动转换机制让 Java 的类型处理更为灵活，同时也需要开发者理解不同类型之间的关系，避免潜在的错误。