基本类型与包装类

// 源码（你写的）
Integer i = 100;        // 自动装箱
int j = i;              // 自动拆箱
Integer k = i + j;      // 先拆箱相加，再装箱

// 编译后（等价于）
Integer i = Integer.valueOf(100);
int j = i.intValue();
Integer k = Integer.valueOf(i.intValue() + j);

/**
 * 飞翔科技 - 包装类与缓存机制演示
 * 场景：飞翔科技的员工绩效分存入List，并演示Integer缓存陷阱
 */
import java.util.ArrayList;
import java.util.List;

public class WrapperDemo {
    public static void main(String[] args) {
        System.out.println("========== 包装类的集合应用 ==========");
        // 基本类型不能存入List
        // List<int> scores = new ArrayList<>();  // 编译错误！
        
        // 使用包装类 Integer
        List<Integer> performanceScores = new ArrayList<>();
        performanceScores.add(100);     // 自动装箱：int → Integer
        performanceScores.add(95);
        performanceScores.add(88);
        performanceScores.add(72);
        
        // 遍历并自动拆箱参与运算
        int sum = 0;
        for (Integer score : performanceScores) {
            sum += score;  // 自动拆箱：Integer → int
        }
        double average = (double) sum / performanceScores.size();
        
        System.out.println("绩效分列表：" + performanceScores);
        System.out.println("总分：" + sum);
        System.out.println("平均分：" + String.format("%.1f", average));
        
        System.out.println("\n========== 字符串解析为基本类型 ==========");
        // 包装类的 parseXxx 静态方法
        int quantity = Integer.parseInt("1000");
        long orderId = Long.parseLong("20251201123456");
        float price = Float.parseFloat("188.88");
        double moonDistance = Double.parseDouble("384400.12345");
        boolean isPaid = Boolean.parseBoolean("true");
        
        System.out.println("数量：" + quantity);
        System.out.println("订单号：" + orderId);
        System.out.println("单价：¥" + price);
        System.out.println("地月距离：" + moonDistance + " km");
        System.out.println("支付状态：" + isPaid);
    }
}

/**
 * 飞翔科技 - Integer 缓存陷阱演示
 * 场景：大翔的基本工资用Integer存储，== 比较引发线上BUG
 */
public class IntegerCacheDemo {
    public static void main(String[] args) {
        System.out.println("========== Integer 缓存陷阱 ==========");
        
        // 缓存范围内（-128 ~ 127）：同一对象
        Integer salary1 = 100;      // Integer.valueOf(100) → 缓存命中
        Integer salary2 = 100;      // Integer.valueOf(100) → 缓存命中
        System.out.println("100 == 100 : " + (salary1 == salary2));     // true!
        System.out.println("100 equals 100 : " + salary1.equals(salary2)); // true
        
        // 缓存范围外（128）：每次创建新对象
        Integer salary3 = 200;      // new Integer(200)
        Integer salary4 = 200;      // new Integer(200)
        System.out.println("200 == 200 : " + (salary3 == salary4));     // false!
        System.out.println("200 equals 200 : " + salary3.equals(salary4)); // true
        
        // 飞翔科技场景：大翔的工资
        // 基本工资8888和绩效18888都超出缓存范围
        Integer basicSalary = 8888;
        Integer performanceBonus = 18888;
        Integer expectedTotal = 27776;  // 8888 + 18888 = 27776
        Integer actualTotal = basicSalary + performanceBonus;  // 拆箱相加 → 重新装箱
        
        System.out.println("\n====== 大翔的工资陷阱 ======");
        System.out.println("基本工资：" + basicSalary);
        System.out.println("绩效奖金：" + performanceBonus);
        System.out.println("期望总额：" + expectedTotal);
        System.out.println("实际总额：" + actualTotal);
        
        // ❌ 危险！用 == 比较
        System.out.println("== 比较：" + (actualTotal == expectedTotal));  // false!
        // ✅ 正确！用 .equals()
        System.out.println("equals比较：" + actualTotal.equals(expectedTotal));  // true
        
        System.out.println("\n====== 经验教训 ======");
        System.out.println("Integer用==比较的是引用地址，不是值！");
        System.out.println("在缓存范围[-128,127]内可能'碰巧'相等");
        System.out.println("必须用equals()或先拆箱为int再用==");
    }
}

// ❌ 经典线上BUG：Integer用==比较
Integer a = 100;
Integer b = 100;
System.out.println(a == b);  // true（缓存内，碰巧相等）

Integer c = 200;
Integer d = 200;
System.out.println(c == d);  // false（超出缓存，不同对象）

// ✅ 正确做法
System.out.println(a.equals(b));  // true（值比较）
System.out.println(c.equals(d));  // true（值比较）
// 或者：先拆箱为int
System.out.println((int)c == (int)d);  // true（基本类型比较）

// ❌ 危险：包装类为null时自动拆箱抛空指针
Integer score = null;
int s = score;  // NullPointerException！自动拆箱调用score.intValue()
if (score > 60) {  // NullPointerException！score拆箱为null

// ✅ 正确：先判空
if (score != null && score > 60) {
    // 安全
}
// 或使用Optional（JDK 8）
// Optional.ofNullable(score).filter(s -> s > 60).isPresent();

// ❌ 危险：三目运算符的类型提升导致NPE
Integer value = null;
// int result = true ? value : 0;  
// NullPointerException！因为三目运算符两个分支类型不同，
// value被自动拆箱为int，null.intValue()抛异常

// ✅ 正确
Integer result = true ? value : Integer.valueOf(0);  // 返回Integer，可以null

// ❌ 性能问题：循环中频繁装箱
Integer sum = 0;
for (int i = 0; i < 100000; i++) {
    sum += i;  // 每次循环：sum拆箱 → 相加 → 装箱 → 新的Integer对象
}

// ✅ 正确：用基本类型计算，最后装箱
int sumPrimitive = 0;
for (int i = 0; i < 100000; i++) {
    sumPrimitive += i;
}
Integer result = sumPrimitive;  // 只装箱一次