Java字符串与文本处理实例详解

// JDK 9+ 的 String 核心结构（简化）
public final class String implements CharSequence {
    // JDK8及以前：private final char[] value;
    // JDK9+：紧凑字符串，Latin1用1字节/字符，其余用2字节
    @Stable
    private final byte[] value;
    private final byte coder;      // 0=LATIN1, 1=UTF16
    private int hash;              // 缓存的hashCode，默认0
    // 没有任何方法修改value的内容
    // 所有"修改"操作都返回新String：
    public String toUpperCase() { /* 返回新对象 */ }
    public String replace(char a, char b) { /* 返回新对象 */ }
}

import java.util.HashMap;
import java.util.Map;
public class ImmutabilityDemo {
    public static void main(String[] args) {
        // 收益1：线程安全 —— 无需同步即可跨线程共享
        String shared = "线程安全";
        new Thread(() -> System.out.println(shared)).start();
        // 收益2：hashCode可缓存 —— HashMap键性能好
        String key = "java";
        key.hashCode(); // 第一次计算并缓存
        Map<String, String> map = new HashMap<>();
        map.put(key, "语言");
        System.out.println(map.get("java")); // 语言（哈希缓存加速）
        // 收益3："修改"返回新对象，原对象不变
        String s = "Hello";
        String upper = s.toUpperCase();
        System.out.println(s);      // Hello（原串不变）
        System.out.println(upper);  // HELLO（新对象）
    }
}

public class StringPoolDemo {
    public static void main(String[] args) {
        // 字面量：编译期入池，运行时直接引用池中对象
        String a = "abc";
        String b = "abc";
        System.out.println(a == b);             // true（同一池中对象）
        // new：强制在堆上创建新对象（其内部仍引用池中char/byte数组）
        String c = new String("abc");
        System.out.println(a == c);             // false（堆对象≠池对象）
        System.out.println(a.equals(c));        // true（内容相同）
        // 常量折叠：编译期 "a"+"b" 直接折叠为 "ab" 并入池
        String d = "a" + "b";
        System.out.println(a == d);             // true
        // 变量参与则运行期拼接，结果不入池
        String x = "a";
        String e = x + "b";
        System.out.println(a == e);             // false
        // final变量仍视为常量
        final String fx = "a";
        String f = fx + "b";
        System.out.println(a == f);             // true
    }
}

public class InternDemo {
    public static void main(String[] args) {
        // 场景1：池中已有 "java"（字面量类名等会提前入池）
        String s1 = new String("ja") + new String("va"); // 堆中"java"，不入池
        String s2 = s1.intern();  // 池无则入池（JDK7+存引用），返回池中串
        String s3 = "java";       // 字面量引用池中对象
        System.out.println(s1 == s2); // JDK7+: true（池中存的就是s1的引用）
        System.out.println(s1 == s3); // JDK7+: true
        // 场景2：对比 "j" 开头但池中没有的串（用动态构造避免提前入池）
        String t1 = new StringBuilder("go").append("od").toString();
        System.out.println(t1.intern() == t1);  // JDK7+: true
        String t2 = new StringBuilder("ja").append("va").toString();
        System.out.println(t2.intern() == t2);  // false（"java"已被池化）
    }
}

public class BuilderDemo {
    public static void main(String[] args) {
        // 预分配容量，避免扩容（默认16，扩容公式：旧容量*2+2）
        StringBuilder sb = new StringBuilder(64);
        sb.append("SELECT ").append("id, name ")     // 链式追加
          .append("FROM users ")
          .insert(0, "-- 查询语句：\n")                // 插入
          .append("WHERE age > ").append(18);
        System.out.println(sb);
        // -- 查询语句：
        // SELECT id, name FROM users WHERE age > 18
        sb.delete(0, 3);              // 删除区间 [0,3)
        sb.replace(0, 6, "QUERY");    // 替换区间
        sb.reverse();                 // 反转
        System.out.println(sb);
        String result = sb.toString(); // 每次调用都复制新数组
        System.out.println(result.length());
    }
}

public class ConcatDemo {
    public static void main(String[] args) {
        String name = "Java";
        int version = 21;
        // JDK5~8：编译为 new StringBuilder().append(name).append(version).toString()
        // JDK9+：编译为 invokedynamic 调用 StringConcatFactory
        String msg = "语言" + name + "版本" + version;
        System.out.println(msg); // 语言Java版本21
    }
}

public class LoopConcatDemo {
    public static void main(String[] args) {
        int n = 100000;
        // 反例：循环内+拼接
        // 每次循环都新建StringBuilder并复制已有内容 → O(n^2)
        long t1 = System.currentTimeMillis();
        String bad = "";
        for (int i = 0; i < n; i++) {
            bad = bad + i; // 编译器只在每轮循环内建一个Builder
        }
        long t2 = System.currentTimeMillis();
        System.out.println("+拼接耗时: " + (t2 - t1) + "ms");
        // 正例：循环外创建一个Builder → O(n)
        long t3 = System.currentTimeMillis();
        StringBuilder sb = new StringBuilder(n * 4);
        for (int i = 0; i < n; i++) {
            sb.append(i);
        }
        String good = sb.toString();
        long t4 = System.currentTimeMillis();
        System.out.println("Builder耗时: " + (t4 - t3) + "ms");
    }
}

import java.util.List;
import java.util.StringJoiner;
import java.util.stream.Collectors;
public class JoinDemo {
    public static void main(String[] args) {
        List<String> langs = List.of("Java", "Kotlin", "Scala");
        // 方式1：String.join（JDK8）
        System.out.println(String.join(", ", langs)); // Java, Kotlin, Scala
        // 方式2：StringJoiner，带前后缀
        StringJoiner joiner = new StringJoiner(", ", "[", "]");
        langs.forEach(joiner::add);
        System.out.println(joiner); // [Java, Kotlin, Scala]
        // 方式3：Stream收集器
        String csv = langs.stream().collect(Collectors.joining(" | "));
        System.out.println(csv); // Java | Kotlin | Scala
    }
}

public class CompareDemo {
    public static void main(String[] args) {
        String a = "abc";
        String b = new String("abc");
        String c = "abc";
        // 1. ==：比较引用（地址），不是内容！
        System.out.println(a == b);       // false
        System.out.println(a == c);       // true（同一池对象）
        // 2. equals：比较内容（推荐，且能处理null判断在左）
        System.out.println(a.equals(b));  // true
        System.out.println("abc".equals(b)); // 常量在左，避免NPE
        // 3. compareTo：字典序比较，返回差值，可用于排序
        System.out.println("apple".compareTo("banana")); // 负数
        System.out.println("abc".compareTo("abc"));      // 0
        // 4. equalsIgnoreCase / compareToIgnoreCase
        System.out.println("ABC".equalsIgnoreCase("abc")); // true
        // 5. contentEquals：与CharSequence比较（含StringBuilder）
        System.out.println("abc".contentEquals(new StringBuilder("abc"))); // true
    }
}

public class TextBlockDemo {
    public static void main(String[] args) {
        // 传统写法：转义+拼接，可读性差
        String oldJson = "{\n" +
                "  \"name\": \"Java\",\n" +
                "  \"version\": 21\n" +
                "}";
        // 文本块：三个引号，起始定界符后必须换行
        String json = """
                {
                  "name": "Java",
                  "version": 21
                }
                """;
        System.out.println(json);
        System.out.println(json.equals(oldJson)); // true
        // 缩进处理：结束定界符的位置决定"偶然缩进"去除量
        // 上例中结束"""与内容对齐，内容保留2空格缩进
        // SQL示例：天然保留换行与缩进
        String sql = """
                SELECT id, name, email
                FROM users
                WHERE status = 'ACTIVE'
                ORDER BY created_at DESC
                """;
        System.out.println(sql);
        // 转义技巧
        String escaped = """
                第一行 \
                接上一行 \
                最终一行
                """;   // \ 在行尾 → 去除换行（续行）
        System.out.println(escaped);
        String trailing = """
                保留尾部空格 \s
                下一行""";   // \s 显式保留空格
        System.out.println(trailing.length());
        // 配合formatted（JDK15）填充变量
        int age = 21;
        String info = """
                {
                  "name": "%s",
                  "age": %d
                }
                """.formatted("Java", age);
        System.out.println(info);
    }
}

// 注意：以下代码仅在JDK21/22预览模式下可编译
// 编译参数：--enable-preview --source 21
// String name = "Java";
// int version = 21;
// String msg = STR."语言\{name}版本\{version}";
// 输出：语言Java版本21
// 多行模板：
// String json = STR."""
//     {
//       "name": "\{name}",
//       "version": \{version}
//     }
//     """;

import java.nio.charset.Charset;
import java.nio.charset.StandardCharsets;
import java.util.Arrays;
public class CharsetDemo {
    public static void main(String[] args) throws Exception {
        String text = "Java字符串";
        // 编码：String → byte[]，必须显式指定字符集！
        byte[] utf8 = text.getBytes(StandardCharsets.UTF_8);
        byte[] gbk  = text.getBytes(Charset.forName("GBK"));
        System.out.println("UTF-8字节数: " + utf8.length); // 13
        System.out.println("GBK字节数: " + gbk.length);    // 9
        // 解码：byte[] → String，字符集必须与编码时一致
        System.out.println(new String(utf8, StandardCharsets.UTF_8)); // 正常
        System.out.println(new String(gbk, StandardCharsets.UTF_8));  // 乱码！
        // JDK18+ 默认即UTF-8
        System.out.println("默认字符集: " + Charset.defaultCharset());
        // 判断是否支持某编码
        System.out.println(Charset.isSupported("GB2312")); // true
        // 列出所有可用编码
        System.out.println("可用编码数量: " + Charset.availableCharsets().size());
    }
}

import java.util.Date;
import java.util.Locale;
public class FormatDemo {
    public static void main(String[] args) {
        String name = "Java";
        double score = 98.5678;
        Date now = new Date();
        // %s字符串 %d整数 %f浮点 %n平台换行 %%百分号
        String s1 = String.format("语言:%s, 评分:%.2f%n", name, score);
        System.out.print(s1); // 语言:Java, 评分:98.57
        // 索引参数：复用同一参数
        String s2 = String.format("%1$s 与 %1$s 重复引用", name);
        System.out.println(s2); // Java 与 Java 重复引用
        // 日期格式：%t 前缀
        String s3 = String.format("今天: %1$tF %1$tT", now);
        System.out.println(s3); // 今天: 2025-01-01 12:00:00
        // Locale敏感：千分位
        String s4 = String.format(Locale.US, "%,d", 1234567);
        System.out.println(s4); // 1,234,567
        // printf直接输出到控制台（内部同一套Formatter）
        System.out.printf("保留1位小数: %.1f, 十六进制: %#x, 布尔: %b%n",
                score, 255, true);
        // 对齐与宽度：%-10s左对齐占10位，%05d补零5位
        System.out.printf("|%-10s|%05d|%n", "左对齐", 42);
    }
}

public class StringTrap {
    public static void main(String[] args) {
        // 陷阱1：+拼接与==
        String a = "a" + new String("b"); // new参与，运行期拼接，不入池
        System.out.println(a == "ab");     // false
        // 陷阱2：无参getBytes依赖平台编码 → 跨平台乱码
        // byte[] bad = "中文".getBytes(); // 禁用
        // 陷阱3：String.format 的 % 与 Locale
        // String.format("%f", 1.5) 在德语Locale下用逗号小数点
        // 陷阱4：StringBuilder.toString()后继续修改
        StringBuilder sb = new StringBuilder("abc");
        String s = sb.toString();
        sb.append("d");
        System.out.println(s); // abc（toString已复制，不受影响）
        // 陷阱5：空串判断
        String empty = "";
        System.out.println(empty.isEmpty());   // true
        System.out.println("  ".isBlank());    // true（JDK11，含空白字符）
    }
}