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

public class StringToIntDemo {
    public static void main(String[] args) {
        // ========== 1. 核心方法對(duì)比 ==========
        // 【parseInt】返回基本類(lèi)型 int，適合計(jì)算
        // 內(nèi)部邏輯：逐個(gè)字符解析，遇到非數(shù)字立即拋異常
        int a = Integer.parseInt("100");           // 十進(jìn)制 100
        int b = Integer.parseInt("100", 8);        // 八進(jìn)制 100 = 64（十進(jìn)制）
        int c = Integer.parseInt("100", 16);       // 十六進(jìn)制 100 = 256（十進(jìn)制）
        // 【valueOf】返回 Integer 包裝類(lèi)，有緩存優(yōu)化（-128~127）
        // 內(nèi)部實(shí)際調(diào)用 parseInt，但會(huì)走緩存池
        Integer obj1 = Integer.valueOf("100");
        Integer obj2 = Integer.valueOf("100");
        System.out.println(obj1 == obj2);  // true（緩存命中，同一對(duì)象）
        // 【decode】支持 0x/0X/0/# 前綴自動(dòng)識(shí)別進(jìn)制
        int d = Integer.decode("0xFF");    // 255（自動(dòng)識(shí)別十六進(jìn)制）
        int e = Integer.decode("#FF");     // 255（#也是十六進(jìn)制標(biāo)記）
        int f = Integer.decode("010");     // 8（0開(kāi)頭識(shí)別為八進(jìn)制）
        // ========== 2. 異常處理（生產(chǎn)環(huán)境必看） ==========
        String risky = " 123 ";  // 帶空格
        try {
            // 【陷阱1】前后空格會(huì)導(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) {
            // 【最佳實(shí)踐】記錄日志并給出默認(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ùn)算符（編譯期常量?jī)?yōu)化）
String s = "Hello" + " " + "World";  // 編譯后直接為 "Hello World"
// 方式2：循環(huán)中禁用 +（會(huì)產(chǎn)生大量臨時(shí)對(duì)象）
String result = "";
for (int i = 0; i < 100; i++) {
    result += i;  // 每次循環(huán)都創(chuàng)建新的 StringBuilder 和 String 對(duì)象，極慢！
}
// 方式3：StringBuilder（單線(xiàn)程推薦）
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
    sb.append(i);
}
String result = sb.toString();
// 方式4：String.join（Java 8+，連接多個(gè)字符串）
String joined = String.join("-", "2024", "02", "23");  // "2024-02-23"

public class StringConcatDemo {
    public static void main(String[] args) {
        // ========== 1. 編譯期優(yōu)化（常量折疊） ==========
        // 【常量折疊】編譯器在編譯階段直接計(jì)算出結(jié)果
        String a = "Hello" + " " + "World";  // 編譯后：String a = "Hello World";
        // 【陷阱】變量參與時(shí)無(wú)法優(yōu)化
        String b = "Hello";
        String c = b + " World";  // 編譯后實(shí)際是：new StringBuilder().append(b).append(" World").toString()
        // ========== 2. 運(yùn)行時(shí)拼接的本質(zhì)（StringBuilder） ==========
        // 反編譯后等價(jià)代碼：
        // String temp = new StringBuilder().append(b).append(" World").toString();
        // ========== 3. 循環(huán)中的致命陷阱 ==========
        // 【低效代碼】O(n2) 復(fù)雜度，創(chuàng)建 n 個(gè) StringBuilder 和 n 個(gè) String 對(duì)象
        String bad = "";
        for (int i = 0; i < 1000; i++) {
            bad += i;  // 每次循環(huán)：new StringBuilder -> append -> toString
        }
        // 【高效代碼】O(n) 復(fù)雜度，只創(chuàng)建一個(gè) StringBuilder
        StringBuilder good = new StringBuilder(1000);  // 預(yù)估容量，避免擴(kuò)容
        for (int i = 0; i < 1000; i++) {
            good.append(i);
        }
        String result = good.toString();
        // 【性能對(duì)比】10000次拼接：
        // String+ 耗時(shí)：約 200-500ms
        // StringBuilder 耗時(shí)：約 1-2ms (差距200倍以上！)
        // ========== 4. 其他拼接方式 ==========
        // 【concat】String 自帶方法，內(nèi)部使用數(shù)組復(fù)制，比 + 快但不如 StringBuilder
        String s1 = "Hello".concat(" ").concat("World"); 
        // 【join】Java 8 新增，適合用分隔符合并多個(gè)字符串
        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]
    }
}