Java字符串转整数与拼接实战指南

// 方式1：最常用（返回基本类型 int）
String str = "123";
int num = Integer.parseInt(str);  // 123
// 方式2：返回包装类（有缓存优化）
Integer numObj = Integer.valueOf(str);  // Integer 对象
// 异常处理（必加！）
try {
    int badNum = Integer.parseInt("abc");  // 抛出 NumberFormatException
} catch (NumberFormatException e) {
    System.out.println("不是有效数字");
}
// 进制转换（如十六进制）
int hex = Integer.parseInt("FF", 16);  // 255

public class StringToIntDemo {
    public static void main(String[] args) {
        // ========== 1. 核心方法对比 ==========
        // 【parseInt】返回基本类型 int，适合计算
        // 内部逻辑：逐个字符解析，遇到非数字立即抛异常
        int a = Integer.parseInt("100");           // 十进制 100
        int b = Integer.parseInt("100", 8);        // 八进制 100 = 64（十进制）
        int c = Integer.parseInt("100", 16);       // 十六进制 100 = 256（十进制）
        // 【valueOf】返回 Integer 包装类，有缓存优化（-128~127）
        // 内部实际调用 parseInt，但会走缓存池
        Integer obj1 = Integer.valueOf("100");
        Integer obj2 = Integer.valueOf("100");
        System.out.println(obj1 == obj2);  // true（缓存命中，同一对象）
        // 【decode】支持 0x/0X/0/# 前缀自动识别进制
        int d = Integer.decode("0xFF");    // 255（自动识别十六进制）
        int e = Integer.decode("#FF");     // 255（#也是十六进制标记）
        int f = Integer.decode("010");     // 8（0开头识别为八进制）
        // ========== 2. 异常处理（生产环境必看） ==========
        String risky = " 123 ";  // 带空格
        try {
            // 【陷阱1】前后空格会导致解析失败
            int fail = Integer.parseInt(risky);  // NumberFormatException
            // 【正确做法】先 trim
            int success = Integer.parseInt(risky.trim());  // 123
            // 【陷阱2】空字符串和 null
            // Integer.parseInt("");    // NumberFormatException（空串）
            // Integer.parseInt(null);  // NullPointerException（注意：不是 NumberFormatException！）
        } catch (NumberFormatException ex) {
            // 【最佳实践】记录日志并给出默认值或终止流程
            System.err.println("非法数字格式：" + ex.getMessage());
            int defaultVal = 0; 
        }
        // ========== 3. 大数与边界 ==========
        // 【陷阱3】超出 int 范围（-2147483648 ~ 2147483647）
        // Integer.parseInt("2147483648");  // NumberFormatException（超出上限）
        // 【解决方案】用 Long
        long big = Long.parseLong("2147483648");
        // 【解决方案】更大用 BigInteger（任意精度）
        java.math.BigInteger huge = new java.math.BigInteger("99999999999999999999");
    }
}

// 方式1：+ 运算符（编译期常量优化）
String s = "Hello" + " " + "World";  // 编译后直接为 "Hello World"
// 方式2：循环中禁用 +（会产生大量临时对象）
String result = "";
for (int i = 0; i < 100; i++) {
    result += i;  // 每次循环都创建新的 StringBuilder 和 String 对象，极慢！
}
// 方式3：StringBuilder（单线程推荐）
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
    sb.append(i);
}
String result = sb.toString();
// 方式4：String.join（Java 8+，连接多个字符串）
String joined = String.join("-", "2024", "02", "23");  // "2024-02-23"

public class StringConcatDemo {
    public static void main(String[] args) {
        // ========== 1. 编译期优化（常量折叠） ==========
        // 【常量折叠】编译器在编译阶段直接计算出结果
        String a = "Hello" + " " + "World";  // 编译后：String a = "Hello World";
        // 【陷阱】变量参与时无法优化
        String b = "Hello";
        String c = b + " World";  // 编译后实际是：new StringBuilder().append(b).append(" World").toString()
        // ========== 2. 运行时拼接的本质（StringBuilder） ==========
        // 反编译后等价代码：
        // String temp = new StringBuilder().append(b).append(" World").toString();
        // ========== 3. 循环中的致命陷阱 ==========
        // 【低效代码】O(n²) 复杂度，创建 n 个 StringBuilder 和 n 个 String 对象
        String bad = "";
        for (int i = 0; i < 1000; i++) {
            bad += i;  // 每次循环：new StringBuilder -> append -> toString
        }
        // 【高效代码】O(n) 复杂度，只创建一个 StringBuilder
        StringBuilder good = new StringBuilder(1000);  // 预估容量，避免扩容
        for (int i = 0; i < 1000; i++) {
            good.append(i);
        }
        String result = good.toString();
        // 【性能对比】10000次拼接：
        // String+ 耗时：约 200-500ms
        // StringBuilder 耗时：约 1-2ms (差距200倍以上！)
        // ========== 4. 其他拼接方式 ==========
        // 【concat】String 自带方法，内部使用数组复制，比 + 快但不如 StringBuilder
        String s1 = "Hello".concat(" ").concat("World"); 
        // 【join】Java 8 新增，适合用分隔符合并多个字符串
        String[] parts = {"Java", "Python", "C++"};
        String lang = String.join("、", parts);  // "Java、Python、C++"
        // 【formatted】Java 15+
        String info = "姓名：%s，年龄：%d".formatted("张三", 20);
        // 【StringJoiner】Java 8，适合构造带前后缀的字符串（如 SQL）
        java.util.StringJoiner joiner = new java.util.StringJoiner(", ", "[", "]");
        joiner.add("A").add("B").add("C");
        System.out.println(joiner.toString());  // [A, B, C]
    }
}