// 方式1：最常用（返回基本類型 int）
String str = "123";
int num = Integer.parseInt(str);  // 123
// 方式2：返回包裝類（有緩存優(yōu)化）
Integer numObj = Integer.valueOf(str);  // Integer 對象
// 異常處理（必加?。?
try {
    int badNum = Integer.parseInt("abc");  // 拋出 NumberFormatException
} catch (NumberFormatException e) {
    System.out.println("不是有效數(shù)字");
}
// 進制轉(zhuǎn)換（如十六進制）
int hex = Integer.parseInt("FF", 16);  // 255

public class StringToIntDemo {
    public static void main(String[] args) {
        // ========== 1. 核心方法對比 ==========
        // 【parseInt】返回基本類型 int，適合計算
        // 內(nèi)部邏輯：逐個字符解析，遇到非數(shù)字立即拋異常
        int a = Integer.parseInt("100");           // 十進制 100
        int b = Integer.parseInt("100", 8);        // 八進制 100 = 64（十進制）
        int c = Integer.parseInt("100", 16);       // 十六進制 100 = 256（十進制）
        // 【valueOf】返回 Integer 包裝類，有緩存優(yōu)化（-128~127）
        // 內(nèi)部實際調(diào)用 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（#也是十六進制標(biāo)記）
        int f = Integer.decode("010");     // 8（0開頭識別為八進制）
        // ========== 2. 異常處理（生產(chǎn)環(huán)境必看） ==========
        String risky = " 123 ";  // 帶空格
        try {
            // 【陷阱1】前后空格會導(dǎo)致解析失敗
            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) {
            // 【最佳實踐】記錄日志并給出默認(rèn)值或終止流程
            System.err.println("非法數(shù)字格式：" + ex.getMessage());
            int defaultVal = 0; 
        }
        // ========== 3. 大數(shù)與邊界 ==========
        // 【陷阱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：+ 運算符（編譯期常量優(yōu)化）
String s = "Hello" + " " + "World";  // 編譯后直接為 "Hello World"
// 方式2：循環(huán)中禁用 +（會產(chǎn)生大量臨時對象）
String result = "";
for (int i = 0; i < 100; i++) {
    result += i;  // 每次循環(huán)都創(chuàng)建新的 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. 編譯期優(yōu)化（常量折疊） ==========
        // 【常量折疊】編譯器在編譯階段直接計算出結(jié)果
        String a = "Hello" + " " + "World";  // 編譯后：String a = "Hello World";
        // 【陷阱】變量參與時無法優(yōu)化
        String b = "Hello";
        String c = b + " World";  // 編譯后實際是：new StringBuilder().append(b).append(" World").toString()
        // ========== 2. 運行時拼接的本質(zhì)（StringBuilder） ==========
        // 反編譯后等價代碼：
        // String temp = new StringBuilder().append(b).append(" World").toString();
        // ========== 3. 循環(huán)中的致命陷阱 ==========
        // 【低效代碼】O(n2) 復(fù)雜度，創(chuàng)建 n 個 StringBuilder 和 n 個 String 對象
        String bad = "";
        for (int i = 0; i < 1000; i++) {
            bad += i;  // 每次循環(huán)：new StringBuilder -> append -> toString
        }
        // 【高效代碼】O(n) 復(fù)雜度，只創(chuàng)建一個 StringBuilder
        StringBuilder good = new StringBuilder(1000);  // 預(yù)估容量，避免擴容
        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 自帶方法，內(nèi)部使用數(shù)組復(fù)制，比 + 快但不如 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，適合構(gòu)造帶前后綴的字符串（如 SQL）
        java.util.StringJoiner joiner = new java.util.StringJoiner(", ", "[", "]");
        joiner.add("A").add("B").add("C");
        System.out.println(joiner.toString());  // [A, B, C]
    }
}