Java类型转换 #

byte → short → int → long → float → double
         ↓
        char → int

// 自动类型转换
byte b = 10;
short s = b;    // byte → short
int i = s;      // short → int
long l = i;     // int → long
float f = l;    // long → float
double d = f;   // float → double

// char → int
char c = 'A';
int code = c;   // 65

// 正确：int → long
int num = 100;
long bigNum = num;

// 错误：long → int（需要强制转换）
// int small = bigNum;

byte a = 10;
byte b = 20;
// byte c = a + b;  // 错误：结果是int
int c = a + b;      // 正确

// 提升规则
byte + byte → int
short + short → int
int + long → long
float + double → double

// 整数常量赋值
byte b1 = 10;      // 常量在byte范围内，自动转换
short s1 = 100;    // 常量在short范围内，自动转换

// byte b2 = 128;  // 错误：超出byte范围
// short s2 = 32768; // 错误：超出short范围

// 浮点数赋值
// float f = 3.14;   // 错误：默认是double
float f = 3.14f;     // 正确：使用f后缀
double d = 3.14;     // 正确：默认double

目标类型 变量名 = (目标类型) 源值;

// 大类型到小类型
double d = 3.14;
int i = (int) d;    // 3（截断小数部分）

long l = 100L;
int n = (int) l;    // 100

// 强制转换可能丢失精度
double pi = 3.14159;
int intPi = (int) pi;  // 3

int big = 128;
byte small = (byte) big;
System.out.println(small);  // -128（溢出）

// 解释：
// 128的二进制: 00000000 00000000 00000000 10000000
// 强制转byte后: 10000000（补码表示-128）

double d1 = 3.9;
int i1 = (int) d1;  // 3（直接截断，不是四舍五入）

// 四舍五入
long rounded = Math.round(d1);  // 4

// 向下取整
double d2 = 3.9;
int floor = (int) Math.floor(d2);  // 3

// 向上取整
int ceil = (int) Math.ceil(d2);    // 4

// 小到大：安全
byte → short → int → long

// 大到小：可能溢出
long → int → short → byte

// 示例
int i = 130;
byte b = (byte) i;  // -126（溢出）

// 检查范围
if (i >= Byte.MIN_VALUE && i <= Byte.MAX_VALUE) {
    b = (byte) i;
}

// float → double：安全
float f = 3.14f;
double d = f;

// double → float：可能丢失精度
double d2 = 3.14159265358979;
float f2 = (float) d2;  // 3.1415927

// 整数 → 浮点：安全（但可能精度损失）
long l = 1234567890123456789L;
float f = l;  // 可能有精度损失
double d = l; // 精度更好

// 浮点 → 整数：截断小数
double d2 = 3.99;
int i = (int) d2;  // 3

// char → int：获取编码值
char c = 'A';
int code = c;  // 65

// int → char：获取字符
int code2 = 65;
char c2 = (char) code2;  // 'A'

// char与byte/short
char c3 = '中';
// byte b = c3;      // 错误：需要强制转换
byte b = (byte) c3;   // 可能溢出
short s = (short) c3; // 正确

byte a = 10;
byte b = 20;
byte c = (byte) (a + b);  // 需要强制转换

short s1 = 100;
short s2 = 200;
short s3 = (short) (s1 + s2);  // 需要强制转换

int i = 10;
long l = 20L;
long result = i + l;  // 提升为long

byte b = 10;
// b = b + 1;    // 错误：结果是int
b += 1;          // 正确：自动强制转换

// 等价于
b = (byte) (b + 1);

int i = 10;
long l = 20L;
float f = 3.14f;
double d = 2.5;

// 结果类型是double（最大类型）
double result = i + l + f + d;

// 整数精度丢失
long big = 1234567890123456789L;
float f = big;  // 1.23456794E18（精度丢失）
double d = big; // 1.23456789012345677E18（精度更好）

// 浮点精度问题
double d1 = 0.1;
double d2 = 0.2;
System.out.println(d1 + d2);  // 0.30000000000000004

int a = 2147483647;  // int最大值
int b = a + 1;
System.out.println(b);  // -2147483648（溢出）

// 使用long避免溢出
long c = (long) a + 1;
System.out.println(c);  // 2147483648

// 或者使用Math.addExact检测溢出
try {
    int d = Math.addExact(a, 1);
} catch (ArithmeticException e) {
    System.out.println("溢出");
}

// 浮点数比较
double d1 = 0.1 + 0.2;
double d2 = 0.3;
System.out.println(d1 == d2);  // false

// 正确方式：使用误差范围
System.out.println(Math.abs(d1 - d2) < 1e-10);  // true

// 或者使用BigDecimal
BigDecimal bd1 = new BigDecimal("0.1");
BigDecimal bd2 = new BigDecimal("0.2");
BigDecimal bd3 = bd1.add(bd2);
System.out.println(bd3.compareTo(new BigDecimal("0.3")) == 0);  // true

// 自动装箱
Integer i = 100;  // int → Integer
Double d = 3.14;  // double → Double

// 自动拆箱
int num = i;      // Integer → int
double value = d; // Double → double

// 字符串 → 基本类型
int i = Integer.parseInt("100");
double d = Double.parseDouble("3.14");
boolean b = Boolean.parseBoolean("true");

// 基本类型 → 字符串
String s1 = String.valueOf(100);
String s2 = String.valueOf(3.14);
String s3 = Integer.toString(100);
String s4 = 100 + "";  // 简单方式

// 不好的做法
int a = 10;
double b = a;  // 不必要的转换

// 好的做法
int a = 10;
int b = a;

public static int safeLongToInt(long value) {
    if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
        throw new IllegalArgumentException("值超出int范围");
    }
    return (int) value;
}

// 使用Math.round进行四舍五入
long rounded = Math.round(3.5);  // 4

// 使用Math.floor和Math.ceil
double floor = Math.floor(3.9);  // 3.0
double ceil = Math.ceil(3.1);    // 4.0