java快速学习速查（3）

这个部分涉及的方面是循环结构，条件语句，switch case,Number&Math,Character,String,StringBuffer几个方面，对照查询学习

Java循环结构全面解析

循环是编程中控制流程的重要结构，Java提供了多种循环方式以满足不同场景的需求。下面我将系统地讲解Java中的循环结构及其应用。

循环的四大条件：

初始化：循环变量的初始值

条件判断：循环是否继续执行的条件

循环体：每次循环执行的代码块

更新：循环变量的变化值

一、循环结构类型

1. while循环

语法结构：

1
2
3

while (条件表达式) {
    // 循环体
}

特点：

先判断条件，后执行循环体
可能一次都不执行
适合不确定循环次数的场景

示例：

// 计算1-100的和
int sum = 0;
int i = 1;
while (i <= 100) {
    sum += i;
    i++;
}
System.out.println("Sum: " + sum);

// 读取用户输入直到输入quit
Scanner scanner = new Scanner(System.in);
String input = "";
while (!input.equals("quit")) {
    System.out.print("请输入命令：");
    input = scanner.nextLine();
    System.out.println("你输入了：" + input);
}

2. do-while循环

语法结构：

1
2
3

do {
    // 循环体
} while (条件表达式);

特点：

先执行循环体，后判断条件
至少执行一次循环体
适合需要至少执行一次的场景

示例：

// 密码验证（至少验证一次）
String password;
Scanner scanner = new Scanner(System.in);
do {
    System.out.print("请输入密码：");
    password = scanner.nextLine();
} while (!password.equals("123456"));
System.out.println("密码正确！");

// 生成随机数直到大于0.9
double randomValue;
do {
    randomValue = Math.random();
    System.out.println("生成值：" + randomValue);
} while (randomValue <= 0.9);

3. for循环

语法结构：

1
2
3

for (初始化; 条件表达式; 更新表达式) {
    // 循环体
}

特点：

循环次数通常已知
初始化、条件和更新都在一行
适合确定循环次数的场景

示例：

// 打印乘法表
for (int i = 1; i <= 9; i++) {
    for (int j = 1; j <= i; j++) {
        System.out.print(j + "×" + i + "=" + (i*j) + "\t");
    }
    System.out.println();
}

// 遍历数组
int[] numbers = {10, 20, 30, 40, 50};
for (int i = 0; i < numbers.length; i++) {
    System.out.println("第" + (i+1) + "个元素：" + numbers[i]);
}

4. 增强for循环（for-each）

语法结构：

1
2
3

for (元素类型 变量名 : 集合或数组) {
    // 循环体
}

特点：

简化数组和集合的遍历
无需索引变量
不能修改原数组/集合元素

示例：

// 遍历数组
String[] fruits = {"Apple", "Banana", "Orange"};
for (String fruit : fruits) {
    System.out.println(fruit);
}

// 遍历集合
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
for (int num : numbers) {
    System.out.println(num * num);
}

二、循环控制语句

1. break语句

作用： 立即终止当前循环

示例：

// 查找第一个能被7整除的数
for (int i = 1; i <= 100; i++) {
    if (i % 7 == 0) {
        System.out.println("找到第一个能被7整除的数：" + i);
        break;
    }
}

// 多层循环中的break（只跳出最内层循环）
outer: for (int i = 0; i < 5; i++) {
    for (int j = 0; j < 5; j++) {
        if (i * j > 6) {
            System.out.println("i=" + i + ", j=" + j);
            break outer;  // 使用标签跳出外层循环
        }
    }
}

2. continue语句

作用： 跳过本次循环，进入下一次循环

示例：

// 打印1-10的奇数
for (int i = 1; i <= 10; i++) {
    if (i % 2 == 0) {
        continue;
    }
    System.out.println(i);
}

// 跳过空字符串处理
String[] words = {"hello", "", "world", null, "java"};
for (String word : words) {
    if (word == null || word.isEmpty()) {
        continue;
    }
    System.out.println(word.toUpperCase());
}

三、循环结构对比

特性	while	do-while	for	for-each
执行顺序	先判断后执行	先执行后判断	先判断后执行	自动遍历
最少执行次数	0次	1次	0次	集合大小次
适用场景	条件控制循环	至少执行一次	固定次数循环	集合/数组遍历
循环变量作用域	外部声明	外部声明	内部声明	内部声明
是否可提前终止	是（break）	是	是	是

四、循环最佳实践

1. 避免无限循环

// 错误示例
while (true) {  // 缺少终止条件
    System.out.println("无限循环");
}

// 正确做法
boolean running = true;
while (running) {
    // 处理逻辑
    if (shouldStop()) {
        running = false;
    }
}

2. 循环性能优化

// 优化前（每次循环都计算length）
for (int i = 0; i < list.size(); i++) {...}

// 优化后（缓存length）
int size = list.size();
for (int i = 0; i < size; i++) {...}

// 倒序循环有时更快
for (int i = array.length - 1; i >= 0; i--) {...}

3. 嵌套循环优化

// 低效的嵌套循环
for (int i = 0; i < 1000; i++) {
    for (int j = 0; j < 100; j++) {
        // 内层循环次数多
    }
}

// 优化后（减少外层循环次数）
for (int j = 0; j < 100; j++) {
    for (int i = 0; i < 1000; i++) {
        // 现在内层循环次数少
    }
}

五、典型应用场景

1. 数据处理

// 计算平均值
double[] data = {12.5, 18.7, 11.2, 19.8, 15.3};
double sum = 0;
for (double d : data) {
    sum += d;
}
double average = sum / data.length;

2. 文件读取

// 读取文件所有行
try (BufferedReader reader = new BufferedReader(new FileReader("data.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        System.out.println(line);
    }
} catch (IOException e) {
    e.printStackTrace();
}

3. 游戏循环

boolean gameRunning = true;
while (gameRunning) {
    // 处理输入
    processInput();
    
    // 更新游戏状态
    updateGame();
    
    // 渲染画面
    render();
    
    // 检查游戏结束条件
    if (isGameOver()) {
        gameRunning = false;
    }
}

六、常见问题与陷阱

循环条件错误：

1 2	// 死循环（i永远不会等于10） for (int i = 0; i != 10; i += 2) {...}

浮点数循环：

// 不可靠的浮点数循环
for (double d = 0.1; d != 1.0; d += 0.1) {...}

// 正确做法
for (int i = 1; i <= 10; i++) {
    double d = i * 0.1;
    // 使用d
}

修改循环变量：

for (int i = 0; i < 10; i++) {
    if (i == 5) {
        i = 8;  // 直接修改循环变量，容易出错
    }
}

集合遍历时修改：

List<String> list = new ArrayList<>(Arrays.asList("a", "b", "c"));
for (String s : list) {
    if (s.equals("b")) {
        list.remove(s);  // 抛出ConcurrentModificationException
    }
}

// 正确做法：使用迭代器
Iterator<String> it = list.iterator();
while (it.hasNext()) {
    String s = it.next();
    if (s.equals("b")) {
        it.remove();  // 安全删除
    }
}

Java条件语句全面解析

条件语句是编程中实现分支逻辑的基础结构，Java提供了多种条件语句来实现不同复杂度的判断逻辑。下面我将系统地讲解Java中的条件语句及其应用。

一、基础条件语句

1. 简单if语句

语法结构：

1
2
3

if (条件表达式) {
    // 条件为true时执行的代码
}

示例：

int score = 85;
if (score >= 60) {
    System.out.println("及格");
}

// 单行语句可省略大括号（但不推荐）
if (score >= 90) System.out.println("优秀");

2. if-else语句

语法结构：

if (条件表达式) {
    // 条件为true时执行
} else {
    // 条件为false时执行
}

示例：

int age = 17;
if (age >= 18) {
    System.out.println("已成年");
} else {
    System.out.println("未成年");
}

3. 多重if-else语句

语法结构：

if (条件1) {
    // 条件1为true时执行
} else if (条件2) {
    // 条件2为true时执行
} else if (条件3) {
    // 条件3为true时执行
} else {
    // 以上条件都不满足时执行
}

示例：

int score = 78;
if (score >= 90) {
    System.out.println("优秀");
} else if (score >= 80) {
    System.out.println("良好");
} else if (score >= 70) {
    System.out.println("中等");
} else if (score >= 60) {
    System.out.println("及格");
} else {
    System.out.println("不及格");
}

二、嵌套条件语句

1. 基本嵌套结构

if (条件1) {
    if (条件2) {
        // 条件1和条件2都为true时执行
    } else {
        // 条件1为true但条件2为false时执行
    }
} else {
    // 条件1为false时执行
}

2. 实际应用示例

int age = 20;
boolean hasLicense = true;

if (age >= 18) {
    if (hasLicense) {
        System.out.println("可以合法驾驶");
    } else {
        System.out.println("需要先考取驾照");
    }
} else {
    System.out.println("未达到法定驾驶年龄");
}

三、特殊条件表达式

1. 三元运算符

语法结构：

1	变量 = (条件) ? 表达式1 : 表达式2;

示例：

int a = 10, b = 20;
int max = (a > b) ? a : b;

String result = (score >= 60) ? "及格" : "不及格";

2. switch-case语句

语法结构：

switch (表达式) {
    case 值1:
        // 代码
        break;
    case 值2:
        // 代码
        break;
    ...
    default:
        // 默认代码
}

示例：

int day = 3;
String dayName;
switch (day) {
    case 1: dayName = "星期一"; break;
    case 2: dayName = "星期二"; break;
    case 3: dayName = "星期三"; break;
    case 4: dayName = "星期四"; break;
    case 5: dayName = "星期五"; break;
    case 6: dayName = "星期六"; break;
    case 7: dayName = "星期日"; break;
    default: dayName = "无效日期";
}
System.out.println(dayName);

Java 12+增强switch：

String dayName = switch (day) {
    case 1 -> "星期一";
    case 2 -> "星期二";
    case 3 -> "星期三";
    case 4 -> "星期四";
    case 5 -> "星期五";
    case 6 -> "星期六";
    case 7 -> "星期日";
    default -> "无效日期";
};

四、条件语句最佳实践

1. 代码风格建议

// 推荐：清晰的缩进和括号
if (condition) {
    // 代码
} else {
    // 代码
}

// 不推荐：省略括号可能导致错误
if (condition) 
    doSomething();
    doSomethingElse(); // 这行不在if块内！

2. 条件表达式优化

// 不推荐：嵌套过深
if (a > b) {
    if (c > d) {
        if (e > f) {
            // 代码
        }
    }
}

// 推荐：使用逻辑运算符简化
if (a > b && c > d && e > f) {
    // 代码
}

3. 提前返回模式

// 不推荐：多层嵌套
public boolean isValid(User user) {
    if (user != null) {
        if (user.getName() != null) {
            if (user.getAge() > 0) {
                return true;
            }
        }
    }
    return false;
}

// 推荐：提前返回
public boolean isValid(User user) {
    if (user == null) return false;
    if (user.getName() == null) return false;
    if (user.getAge() <= 0) return false;
    return true;
}

五、常见问题与陷阱

1. 浮点数比较

// 错误方式
double d = 0.1 + 0.2;
if (d == 0.3) {  // false!
    System.out.println("相等");
}

// 正确方式
double epsilon = 1e-10;
if (Math.abs(d - 0.3) < epsilon) {
    System.out.println("视为相等");
}

2. 空指针异常

String str = null;
// 错误方式
if (str.equals("test")) {...}  // NullPointerException

// 正确方式
if ("test".equals(str)) {...}  // 安全
// 或
if (str != null && str.equals("test")) {...}

3. switch语句注意点

int num = 2;
switch (num) {
    case 1:
        System.out.println("一");
    case 2:  // 匹配到这里
        System.out.println("二");  // 会执行
    case 3:  // 没有break，继续执行
        System.out.println("三");  // 也会执行
        break;
    default:
        System.out.println("其他");
}
// 输出：二 三

六、实际应用案例

1. 登录验证

public void login(String username, String password) {
    if (username == null || username.trim().isEmpty()) {
        System.out.println("用户名不能为空");
    } else if (password == null || password.length() < 6) {
        System.out.println("密码长度至少6位");
    } else if (!isValidUser(username, password)) {
        System.out.println("用户名或密码错误");
    } else {
        System.out.println("登录成功");
        // 跳转到主页面
    }
}

2. 成绩等级判断

char determineGrade(int score) {
    if (score < 0 || score > 100) {
        throw new IllegalArgumentException("无效分数");
    }
    
    if (score >= 90) return 'A';
    if (score >= 80) return 'B';
    if (score >= 70) return 'C';
    if (score >= 60) return 'D';
    return 'F';
}

3. 月份天数判断

int getDaysInMonth(int year, int month) {
    if (month < 1 || month > 12) {
        throw new IllegalArgumentException("无效月份");
    }
    
    switch (month) {
        case 4: case 6: case 9: case 11:
            return 30;
        case 2:
            return (year % 400 == 0) || (year % 100 != 0 && year % 4 == 0) ? 29 : 28;
        default:
            return 31;
    }
}

Java switch-case 语句全面解析

switch-case 是Java中用于多分支选择的结构，比多重if-else语句更加清晰易读。下面我将详细讲解switch-case的各种用法和特性。

一、基本语法结构

switch (表达式) {
    case 值1:
        // 代码块1
        break;
    case 值2:
        // 代码块2
        break;
    ...
    default:
        // 默认代码块
}

二、switch语句特性

1. 支持的数据类型

Java 7之前：byte, short, int, char
Java 7+：新增String类型
Java 14+：支持表达式形式（预览特性）

2. 执行流程

计算表达式的值
与case标签的值比较
匹配成功后执行对应的代码块
遇到break或执行到switch末尾时退出

3. break的重要性

int day = 2;
switch (day) {
    case 1: System.out.println("周一");
    case 2: System.out.println("周二");  // 从这里开始执行
    case 3: System.out.println("周三");  // 继续执行（没有break）
    default: System.out.println("其他"); // 继续执行
}
// 输出：
// 周二
// 周三
// 其他

三、完整使用示例

1. 传统写法

public class DayOfWeek {
    public static void main(String[] args) {
        int day = 3;
        String dayName;
        
        switch (day) {
            case 1: dayName = "Monday"; break;
            case 2: dayName = "Tuesday"; break;
            case 3: dayName = "Wednesday"; break;
            case 4: dayName = "Thursday"; break;
            case 5: dayName = "Friday"; break;
            case 6: dayName = "Saturday"; break;
            case 7: dayName = "Sunday"; break;
            default: dayName = "Invalid day";
        }
        
        System.out.println(dayName);  // 输出：Wednesday
    }
}

2. 多个case合并

int month = 2;
int year = 2020;
int days = 0;

switch (month) {
    case 1: case 3: case 5: case 7: case 8: case 10: case 12:
        days = 31;
        break;
    case 4: case 6: case 9: case 11:
        days = 30;
        break;
    case 2:
        if ((year % 400 == 0) || (year % 100 != 0 && year % 4 == 0))
            days = 29;
        else
            days = 28;
        break;
    default:
        days = 0;
}
System.out.println("Days: " + days);  // 输出：Days: 29

3. 字符串匹配（Java 7+）

String fruit = "Apple";
switch (fruit) {
    case "Orange":
        System.out.println("Selected Orange");
        break;
    case "Apple":
        System.out.println("Selected Apple");  // 输出这行
        break;
    case "Banana":
        System.out.println("Selected Banana");
        break;
    default:
        System.out.println("Unknown fruit");
}

四、Java 12+ 新特性

1. 箭头语法（->）

int day = 3;
String dayType = switch (day) {
    case 1, 2, 3, 4, 5 -> "Weekday";  // 多case匹配
    case 6, 7 -> "Weekend";
    default -> "Invalid";
};
System.out.println(dayType);  // 输出：Weekday

2. yield返回值（Java 13+）

String season = switch (month) {
    case 12, 1, 2 -> "Winter";
    case 3, 4, 5 -> "Spring";
    case 6, 7, 8 -> {
        System.out.println("Summer months");
        yield "Summer";  // 使用yield返回值
    }
    case 9, 10, 11 -> "Autumn";
    default -> "Unknown";
};

五、最佳实践

总是包含default分支：处理未预期的值
不要省略break：除非有意使用fall-through特性
保持case分支简洁：复杂逻辑应提取为方法
利用多case合并：简化相同处理的case
考虑使用枚举：提高类型安全性

六、与if-else对比

特性	switch-case	if-else
可读性	多分支时更清晰	分支多时难以阅读
性能	通常使用跳转表更高效	需要顺序比较
表达式类型	有限支持	支持任何布尔表达式
适用场景	离散值精确匹配	范围判断或复杂条件

七、常见问题

忘记break导致意外fall-through

// 错误示例
switch (x) {
    case 1: System.out.println("1");  // 忘记break
    case 2: System.out.println("2"); break;
}

case值重复

switch (x) {
    case 1: ... break;
    case 1: ... break;  // 编译错误：重复的case
}

使用null导致NPE

1 2	String s = null; switch (s) { ... } // 抛出NullPointerException

类型不匹配

1 2	long x = 10; switch (x) { ... } // 编译错误：不支持long类型

Java Number & Math 类全面解析

Java 提供了强大的数字处理能力，包括基本数据类型的包装类和丰富的数学运算工具。下面我将系统地讲解这些功能的使用方法和最佳实践。

一、Number 包装类体系

1. 包装类与基本类型对应关系

基本类型	包装类	继承关系
byte	Byte	→ Number → Object
short	Short	→ Number → Object
int	Integer	→ Number → Object
long	Long	→ Number → Object
float	Float	→ Number → Object
double	Double	→ Number → Object
char	Character	→ Object
boolean	Boolean	→ Object

2. 自动装箱与拆箱

// 自动装箱
Integer a = 10;      // 编译器转换为 Integer.valueOf(10)
Double b = 3.14;     // Double.valueOf(3.14)

// 自动拆箱
int c = a;           // a.intValue()
double d = b;        // b.doubleValue()

// 混合运算时的自动拆箱
Integer x = 5;
x = x + 10;          // x拆箱→相加→结果装箱

3. 常用方法示例

// 字符串转换
int num = Integer.parseInt("123");
String str = Integer.toString(456);

// 比较大小
Integer x = 10, y = 20;
int compareResult = x.compareTo(y);  // -1 (x < y)

// 类型转换
double d = x.doubleValue();

// 进制转换
String binary = Integer.toBinaryString(10);  // "1010"
String hex = Integer.toHexString(255);      // "ff"

二、Math 数学工具类

1. 基本数学运算

// 绝对值
Math.abs(-5.6);      // 5.6

// 取整运算
Math.ceil(3.2);      // 4.0 (向上取整)
Math.floor(3.8);     // 3.0 (向下取整)
Math.round(3.5);     // 4 (四舍五入)
Math.rint(3.5);      // 4.0 (最接近的整数)

// 极值
Math.max(10, 20);    // 20
Math.min(1.2, 3.4);  // 1.2

2. 指数与对数

// 幂运算
Math.pow(2, 3);      // 8.0 (2的3次方)
Math.exp(1);         // 2.718... (e的1次方)

// 对数
Math.log(Math.E);    // 1.0 (自然对数)
Math.log10(100);     // 2.0 (以10为底)

// 平方根
Math.sqrt(16);       // 4.0
Math.cbrt(27);       // 3.0 (立方根)

3. 三角函数

// 角度转弧度
double radians = Math.toRadians(30);  // 0.5236

// 三角函数
Math.sin(Math.PI/6);     // 0.5 (30度正弦)
Math.cos(Math.PI/3);     // 0.5 (60度余弦)
Math.tan(Math.PI/4);     // 1.0 (45度正切)

// 反三角函数
Math.asin(0.5);          // 0.5236 (≈π/6)
Math.acos(0.5);          // 1.0472 (≈π/3)
Math.atan(1);            // 0.7854 (≈π/4)

4. 随机数生成

Random类
Java.util.Random 用于产生随机数

// 生成[0,1)之间的随机double
double rand1 = Math.random();

// 生成[1,100]的随机整数
int rand2 = (int)(Math.random() * 100) + 1;

// Java 8+更好的方式
Random random = new Random();
int rand3 = random.nextInt(100) + 1;  // [1,100]

三、数值处理高级技巧

1. 精确计算问题

// 浮点数精度问题
System.out.println(0.1 + 0.2);  // 0.30000000000000004

// 使用BigDecimal解决
BigDecimal bd1 = new BigDecimal("0.1");
BigDecimal bd2 = new BigDecimal("0.2");
System.out.println(bd1.add(bd2));  // 0.3

2. 数值溢出处理

// 整数溢出
int max = Integer.MAX_VALUE;
int overflow = max + 1;  // -2147483648 (溢出)

// 安全运算方法
Math.addExact(max, 1);   // 抛出ArithmeticException

// 使用更大范围的类型
long safeResult = (long)max + 1;

3. 位运算操作

// 基本位运算
int a = 0b1100;  // 12
int b = 0b1010;  // 10
a & b;           // 8 (0b1000)
a | b;           // 14 (0b1110)
a ^ b;           // 6 (0b0110)
~a;              // -13 (0b...11110011)

// 位移运算
int c = 0b1100;
c << 2;          // 48 (0b110000)
c >> 1;          // 6 (0b0110)
c >>> 1;         // 6 (无符号右移)

四、Java 8+ 新增数值API

1. 无符号数支持

// 无符号比较
Integer.compareUnsigned(-1, 1);  // 1 (视为无符号数比较)

// 无符号转换
Long.toUnsignedString(-1);       // "18446744073709551615"

// 无符号除法
Integer.divideUnsigned(-2, 2);   // 2147483647

2. 数值溢出检查

// 安全运算方法
Math.addExact(100000, 200000);    // 正常
Math.addExact(Integer.MAX_VALUE, 1); // 抛出异常

// 乘法检查
Math.multiplyExact(100000, 1000); // 正常
Math.multiplyExact(Integer.MAX_VALUE, 2); // 抛出异常

3. 数学增强方法

// 精确数学运算
Math.floorDiv(5, 2);       // 2
Math.floorMod(5, 2);       // 1

// 双曲函数
Math.sinh(1.0);           // 双曲正弦
Math.cosh(1.0);           // 双曲余弦
Math.tanh(1.0);           // 双曲正切

五、最佳实践与性能考虑

优先使用基本类型：包装类有额外开销

// 不好
Integer sum = 0;
for (int i = 0; i < 100; i++) {
    sum += i;  // 反复装箱拆箱
}

// 好
int sum = 0;
for (int i = 0; i < 100; i++) {
    sum += i;
}

缓存机制利用：

Integer a = 127;
Integer b = 127;
System.out.println(a == b);  // true (使用缓存)

Integer c = 128;
Integer d = 128;
System.out.println(c == d);  // false (超出缓存范围)

精确计算选择：

// 金融计算使用BigDecimal
BigDecimal price = new BigDecimal("19.99");
BigDecimal quantity = new BigDecimal("2.5");
BigDecimal total = price.multiply(quantity).setScale(2, RoundingMode.HALF_UP);

数学函数优化：
1
2
3
// 重复计算先缓存
double sinValue = Math.sin(angle);
double cosValue = Math.cos(angle);
记住在关键性能路径上避免不必要的对象创建，并注意数值精度和溢出问题。

Java Character 类全面解析

Character 类是 Java 中用于操作单个字符的包装类，提供了丰富的字符操作方法。下面我将系统地讲解 Character 类的各种功能和使用场景。

一、Character 类基础

1. 创建 Character 对象

// 构造函数方式（Java 9后已废弃）
Character ch1 = new Character('A');  // 不推荐

// 自动装箱方式（推荐）
Character ch2 = 'B';

// valueOf 方法（推荐）
Character ch3 = Character.valueOf('C');

2. 基本方法

char c = 'a';

// 获取字符的Unicode值
int code = Character.getNumericValue(c);

// 判断字符类型
boolean isLetter = Character.isLetter(c);      // true
boolean isDigit = Character.isDigit('7');      // true
boolean isSpace = Character.isWhitespace(' '); // true

// 大小写转换
char upper = Character.toUpperCase('a');  // 'A'
char lower = Character.toLowerCase('Z');  // 'z'

二、字符类型检测方法

1. 常用检测方法

方法名	描述	示例
`isLetter(char ch)`	判断是否是字母	`isLetter('A') → true`
`isDigit(char ch)`	判断是否是数字	`isDigit('5') → true`
`isLetterOrDigit(char)`	判断是否是字母或数字	`isLetterOrDigit('_') → false`
`isWhitespace(char)`	判断是否是空白字符	`isWhitespace('\t') → true`
`isUpperCase(char)`	判断是否是大写字母	`isUpperCase('A') → true`
`isLowerCase(char)`	判断是否是小写字母	`isLowerCase('a') → true`

2. Unicode 相关检测

// 判断是否是Java标识符起始字符
Character.isJavaIdentifierStart('$');  // true

// 判断是否是Java标识符部分字符
Character.isJavaIdentifierPart('_');   // true

// 判断是否是Unicode空格字符
Character.isSpaceChar('\u00A0');       // true

// 判断是否是代理字符
Character.isSurrogate('\uD800');       // true

三、字符转换操作

1. 大小写转换

// 单个字符转换
char upperA = Character.toUpperCase('a');  // 'A'
char lowerZ = Character.toLowerCase('Z');  // 'z'

// 整个字符串转换
String str = "Hello World";
String upperStr = str.toUpperCase();  // "HELLO WORLD"
String lowerStr = str.toLowerCase();  // "hello world"

2. 数字字符转换

// 字符数字转数值
int num = Character.getNumericValue('9');  // 9
int hex = Character.getNumericValue('A');  // 10 (十六进制)

// 数值转字符
char digit = Character.forDigit(15, 16);   // 'f' (16进制)

3. 字符与Unicode

// 获取Unicode代码点
int codePoint = Character.codePointAt("ABC", 1);  // 66 ('B')

// 代码点转字符
char[] chars = Character.toChars(0x1F600);  // 😀

四、特殊字符处理

1. 转义字符

转义序列	Unicode	描述
`\t`	\u0009	水平制表符
`\b`	\u0008	退格
`\n`	\u000a	换行
`\r`	\u000d	回车
`\f`	\u000c	换页
`\'`	\u0027	单引号
`\"`	\u0022	双引号
`\\`	\u005c	反斜杠

2. Unicode 处理

// 直接使用Unicode
char omega = '\u03A9';  // Ω
System.out.println(omega);

// 处理代理对（Surrogate Pair）
String emoji = "\uD83D\uDE00";  // 😀
int codePoint = emoji.codePointAt(0);  // 128512

五、Character 常量

Character 类提供了许多有用的常量：

// 基本类型大小
Character.SIZE;      // 16 (bits)
Character.BYTES;     // 2 (bytes)

// 特殊字符值
Character.MIN_VALUE; // '\u0000'
Character.MAX_VALUE; // '\uffff'

// Unicode常量
Character.MIN_CODE_POINT;  // 0x000000
Character.MAX_CODE_POINT;  // 0x10FFFF
Character.MIN_SURROGATE;   // '\uD800'
Character.MAX_SURROGATE;   // '\uDFFF'

六、实际应用示例

1. 统计字符串中的字母和数字

public class CharCounter {
    public static void countChars(String str) {
        int letters = 0;
        int digits = 0;
        int others = 0;
        
        for (char c : str.toCharArray()) {
            if (Character.isLetter(c)) {
                letters++;
            } else if (Character.isDigit(c)) {
                digits++;
            } else {
                others++;
            }
        }
        
        System.out.println("字母: " + letters);
        System.out.println("数字: " + digits);
        System.out.println("其他: " + others);
    }

    public static void main(String[] args) {
        countChars("Hello123!你好");
    }
}

2. 密码强度验证

public class PasswordValidator {
    public static boolean isStrongPassword(String password) {
        if (password == null || password.length() < 8) {
            return false;
        }
        
        boolean hasUpper = false;
        boolean hasLower = false;
        boolean hasDigit = false;
        boolean hasSpecial = false;
        
        for (char c : password.toCharArray()) {
            if (Character.isUpperCase(c)) hasUpper = true;
            else if (Character.isLowerCase(c)) hasLower = true;
            else if (Character.isDigit(c)) hasDigit = true;
            else if (!Character.isLetterOrDigit(c)) hasSpecial = true;
        }
        
        return hasUpper && hasLower && hasDigit && hasSpecial;
    }

    public static void main(String[] args) {
        System.out.println(isStrongPassword("Pass123!"));  // true
        System.out.println(isStrongPassword("weak"));      // false
    }
}

3. 驼峰命名转换

public class CamelCaseConverter {
    public static String toCamelCase(String input) {
        if (input == null || input.isEmpty()) {
            return input;
        }
        
        StringBuilder result = new StringBuilder();
        boolean nextUpper = false;
        
        for (int i = 0; i < input.length(); i++) {
            char current = input.charAt(i);
            
            if (current == '_') {
                nextUpper = true;
            } else {
                if (nextUpper) {
                    result.append(Character.toUpperCase(current));
                    nextUpper = false;
                } else {
                    result.append(Character.toLowerCase(current));
                }
            }
        }
        
        return result.toString();
    }

    public static void main(String[] args) {
        System.out.println(toCamelCase("hello_world"));  // helloWorld
        System.out.println(toCamelCase("MY_VAR_NAME"));  // myVarName
    }
}

七、性能考虑与最佳实践

避免不必要的装箱：

// 不好
Character ch = 'a';
if (ch.equals('b')) {...}

// 好
char c = 'a';
if (c == 'b') {...}

使用String处理字符串：

// 不要这样处理字符串
Character[] chars = ...;

// 应该使用String或char[]
String str = ...;
char[] chars = ...;

处理代理对：

String emoji = "😀";
// 错误方式（会拆分成两个char）
char first = emoji.charAt(0);  // '\uD83D'

// 正确方式（处理代码点）
int codePoint = emoji.codePointAt(0);  // 128512

使用Character常量：

// 不要使用魔法值
if (c == 9) {...}

// 使用预定义常量
if (c == '\t') {...}
// 或
if (c == Character.TAB) {...}

通过合理使用 Character 类，可以高效地处理各种字符操作需求，特别是在文本处理、输入验证和国际化应用中。记住在性能敏感的场景中优先使用基本类型 char，并注意 Unicode 特殊字符的处理。

Java String 类全面解析

String 类是 Java 中最常用的类之一，用于表示和操作文本数据。下面我将系统地讲解 String 类的各种功能和使用场景。
Java.lang.String 类代表字符串，java程序中所有的字符串都作为此类的实例，字符串是常量，他们的值在创建之后是不能更改的。

从源码可以看到，String是被ﬁnal修饰的，并且底层使用char数组实现。

一、String 类基础

1. 创建 String 对象

// 字面量方式（推荐）
String str1 = "Hello";

// 构造函数方式
String str2 = new String("World");

// 从字符数组创建
char[] charArray = {'J', 'a', 'v', 'a'};
String str3 = new String(charArray);

// 从字节数组创建
byte[] byteArray = {65, 66, 67};
String str4 = new String(byteArray);  // "ABC"

2. 字符串池与内存管理

字符串池：
字符串常量是JVM（java虚拟机）中的一个特殊存储区域，用于存储字符串常量。当使用字面量方式创建String对象时，JVM会首先检查字符串常量池是否已经存在相同内容的字符串对象，如果存在，则直接返回常量池中该字符串对象的引用，如果不存在，则在常量池中创建一个新的字符串对象，并返回其
引用。

堆内存：

用于存储对象实例，包括字符串对象
当使用new关键字创建字符串对象时，会在堆上分配内存

栈内存：

用于存储基本数据类型和引用变量
栈内存的分配和释放速度快，仅次于寄存器
栈内存的大小通常是固定的，无法动态扩展
栈内存的存储内容包括局部变量、方法参数、方法调用信息等

String s1 = "Java";      // 存储在字符串常量池
String s2 = "Java";      // 复用常量池中的"Java"
String s3 = new String("Java");  // 在堆上创建新对象

System.out.println(s1 == s2);  // true (相同引用)
System.out.println(s1 == s3);  // false (不同对象)
System.out.println(s1.equals(s3));  // true (内容相同)

字符串常见的几种创建方式

    public class Test3 {
    public static void main(String[] args) {
        // 1.通过字面量直接赋值方式创建对象是存放在方法区的常量池
        String str="helloWorld";
        // 2.通过构造方法创建字符串，字符串对象是在堆内中
        String str1=new String("helloWorld");
        // 3.方式三
        char []c={'a','b','c'};
        String str2=new String(c);
        String str3=new String(c,0,c.length);
   }
}

注意
java中的”==”操作符的作用：

基本数据类型：比较的是内容
引用数据类型：比较的是对象的内存对象。

二、字符串基本操作

1. 获取字符串信息

String str = "Hello World";

// 获取长度
int len = str.length();  // 11

// 获取指定位置字符
char ch = str.charAt(1);  // 'e'

// 获取子字符串位置
int index = str.indexOf("World");  // 6
int lastIndex = str.lastIndexOf('o');  // 7

字符串获取方法补充

public static void main(String[] args) {
        String s="hello World";
        // 获取字符串的长度，其实就是字符串的字符个数
        System.out.println(s.length());
        // charAt()获取指定索引处的字符
        System.out.println(s.charAt(2));
        // trim()去掉字符串(左右)前后(不包括里面的)的空格
        System.out.println(s.trim().length());
        // replace("字符串","新字符") 替换
        System.out.println(s.replace(" ","-"));
        // substring(开始索引) 索引从0开始获取子串， 直到末尾
        System.out.println(s.substring(3));
        // substring(开始索引,结束索引) 包括开始，不包括结束
        System.out.println(s.substring(3,7));
        // concat() 字符串拼接
        System.out.println(s.concat("2025!!"));
        // 判断字符串里面是否包含特定的字符
        if(s.contains("e")){
            System.out.println("包含e");
       }
        // String.valueOf() 将各种类型转换成字符串
        System.out.println(String.valueOf(123));
        System.out.println(String.valueOf(true));
        // 此方法同等String.valueOf(123)
        // 字符串+基本数据类型 变成字符串
        System.out.println(""+123);
        System.out.println(345+"");
   }

面试题：
equals和==的区别?

== 是运算符，如果是基本数据类型，比较的存储的值，如果是引用数据类型，则比较所指对象的地址值。
String类重写Object类的equals()方法，用于比较两个字符串的内容是否相等。

严重注意事项
字符串数组创建的时候每个元素默认是null,所以这个是个大地雷，经常会因为这个原因导致空指针异常（NullPointerException）。
你可以看下面这个例子：

public class Tset07 {
    public static void main(String[] args) {
        String[] arr = new String[10];
        arr[0] = "java";
        arr[1] = "linux";
        arr[2] = "mysql";
        //遍历字符串数组，打印每个字符长度
        for (int i = 0; i < arr.length; i++) {
            //人畜无害是吧
            //可以通过编译
            //运行时就是个大地雷
            //这是因为字符串数组默认创建时全都是null,在这里除了前三个都是null，遍历过前三个就爆炸了
            //所以我们在对字符串数组进行操作的时候必须进行非空判断，防止空指针异常
            System.out.println(arr[i].length());
        }
    }
}

所以我们在使用字符串数组和字符串的时候，必须要进行非空判断，防止空指针异常。
同时，栈溢出问题也不容小看，这些玩意不会给我吗进行代码提示

2. 字符串比较

方法名	描述	示例
`equals(Object obj)`	比较内容是否相同	`"abc".equals("abc") → true`
`equalsIgnoreCase(String)`	忽略大小写比较内容	`"ABC".equalsIgnoreCase("abc") → true`
`compareTo(String)`	按字典顺序比较	`"a".compareTo("b") → -1`
`compareToIgnoreCase(String)`	忽略大小写的字典顺序比较	`"A".compareToIgnoreCase("a") → 0`
`startsWith(String)`	检查是否以指定字符串开头	`"Hello".startsWith("He") → true`
`endsWith(String)`	检查是否以指定字符串结尾	`"Hello".endsWith("lo") → true`

三、字符串操作与转换

1. 字符串连接

// 使用 + 运算符
String s1 = "Hello" + " " + "World";  // "Hello World"

// 使用 concat 方法
String s2 = "Hello".concat(" World");  // "Hello World"

// 使用 StringBuilder (高性能)
StringBuilder sb = new StringBuilder();
sb.append("Hello").append(" ").append("World");
String s3 = sb.toString();  // "Hello World"

2. 字符串修改

String original = "Java Programming";

// 替换字符
String replaced = original.replace('a', 'o');  // "Jovo Progromming"

// 替换子串
String replacedAll = original.replaceAll("Java", "Python");  // "Python Programming"

// 获取子串
String substring1 = original.substring(5);  // "Programming"
String substring2 = original.substring(5, 12);  // "Program"

3. 大小写转换

String str = "Hello World";

// 转大写
String upper = str.toUpperCase();  // "HELLO WORLD"

// 转小写
String lower = str.toLowerCase();  // "hello world"

四、字符串格式化

1. 静态 format 方法

这个方法用于格式化字符串，将指定的参数按照格式说明符替换到字符串中。

String name = "Alice";
int age = 25;
double score = 95.5;

// 格式化字符串
String info = String.format("Name: %s, Age: %d, Score: %.2f", name, age, score);
// "Name: Alice, Age: 25, Score: 95.50"

2. 常用格式说明符

说明符	适用类型	示例输出
`%s`	字符串	“Hello”
`%d`	十进制整数	123
`%f`	浮点数	3.141593
`%.2f`	保留两位小数	3.14
`%c`	字符	‘A’
`%b`	布尔值	true
`%n`	平台相关的行分隔符	(换行)

五、字符串分割与正则表达式

1. 字符串分割

String str = "apple,orange,banana,grape";

// 简单分割
String[] fruits = str.split(",");
// ["apple", "orange", "banana", "grape"]

// 限制分割次数
String[] limited = str.split(",", 2);
// ["apple", "orange,banana,grape"]

2. 正则表达式匹配

String email = "test@example.com";

// 检查格式
boolean isValid = email.matches("^[\\w-]+@[\\w-]+\\.[a-z]{2,3}$");  // true

// 替换所有数字
String replaced = "a1b2c3".replaceAll("\\d", "-");  // "a-b-c-"

六、字符串与字符/字节数组转换

1. 字符数组转换

String str = "Hello";

// String → char[]
char[] charArray = str.toCharArray();

// char[] → String
String newStr = new String(charArray);

2. 字节数组转换

String str = "Hello";

// String → byte[] (使用默认编码)
byte[] byteArray = str.getBytes();

// byte[] → String
String newStr = new String(byteArray);

// 指定编码
try {
    byte[] utf8Bytes = str.getBytes("UTF-8");
    String fromUtf8 = new String(utf8Bytes, "UTF-8");
} catch (UnsupportedEncodingException e) {
    e.printStackTrace();
}

七、实际应用示例

前提提要，这毕竟是用来查找的学习笔记，所以常用的函数和方法我就放在这里了，稍微有点多就是了，我会把最最最常用的给标出来，放心吧。

String 类常用函数

函数名称功能描述使用方式示例注意事项

==length()== 获取字符串的字符长度 String str = "hello"; int len = str.length();（结果：5） 1. 区分数组的length（属性）和字符串的length()（方法）
2. 空字符串""的长度为0，null调用该方法会抛空指针异常

charAt(int index) 获取指定索引位置的字符 String str = "hello"; char c = str.charAt(1);（结果：’e’） 1. 索引从0开始
2. 索引超出范围会抛出IndexOutOfBoundsException

equals(Object obj) 比较两个字符串的内容是否完全相同 String str1 = "hello"; String str2 = "HELLO"; boolean b = str1.equals(str2);（结果：false） 1. 区分大小写
2. 避免空指针：建议用非空字符串调用，如"hello".equals(str)

equalsIgnoreCase(String anotherString) 忽略大小写比较字符串内容 String str1 = "hello"; String str2 = "HELLO"; boolean b = str1.equalsIgnoreCase(str2);（结果：true）仅忽略英文字母大小写，其他字符（如数字、符号）严格匹配

contains(CharSequence s) 判断字符串是否包含指定子串 String str = "hello world"; boolean b = str.contains("world");（结果：true）参数可以是String、StringBuffer、StringBuilder等CharSequence类型

indexOf(String str) 查找子串首次出现的索引，未找到返回-1 String str = "hello world"; int idx = str.indexOf("o");（结果：4） 1. 索引从0开始
2. 支持重载：indexOf(str, int fromIndex)（从指定位置开始查找）

lastIndexOf(String str) 查找子串最后一次出现的索引，未找到返回-1 String str = "hello world"; int idx = str.lastIndexOf("o");（结果：7）支持重载：lastIndexOf(str, int fromIndex)（从指定位置向前查找）

substring(int beginIndex) 截取从指定索引到末尾的子串 String str = "hello world"; String sub = str.substring(6);（结果：”world”） 1. 索引从0开始
2. 重载方法substring(beginIndex, endIndex)：包含begin，不包含end

trim() 去除字符串首尾的空白字符（空格、制表符、换行等） String str = " hello "; String res = str.trim();（结果：”hello”） 1. Java 11前仅去除ASCII空白符，Java 11+可使用strip()（支持Unicode空白）
2. 不改变原字符串内容

replace(CharSequence oldStr, CharSequence newStr) 替换字符串中所有指定的子串 String str = "hello world"; String res = str.replace("o", "0");（结果：”hell0 w0rld”） 1. 替换所有匹配项
2. 区分大小写，如需忽略大小写可使用replaceAll()结合正则

split(String regex) 按指定正则表达式分割字符串，返回字符串数组 String str = "a,b,c"; String[] arr = str.split(",");（结果：[“a”,”b”,”c”]） 1. 参数是正则表达式，特殊字符（如.、、*）需转义（\\.）
2. 分割空字符串可能返回长度为1的数组（包含空串）

toUpperCase() 将字符串所有字符转为大写 String str = "hello"; String res = str.toUpperCase();（结果：”HELLO”）遵循系统默认Locale，如需指定Locale可使用重载方法

toLowerCase() 将字符串所有字符转为小写 String str = "HELLO"; String res = str.toLowerCase();（结果：”hello”）同上，避免因Locale差异导致转换异常

isEmpty() 判断字符串是否为空（长度为0） String str = ""; boolean b = str.isEmpty();（结果：true） 1. null调用该方法会抛空指针异常
2. 可结合str == null判断：`str == null str.isEmpty()`

startsWith(String prefix) 判断字符串是否以指定前缀开头 String str = "hello"; boolean b = str.startsWith("he");（结果：true）重载方法startsWith(prefix, int offset)：从指定索引开始判断前缀

endsWith(String suffix) 判断字符串是否以指定后缀结尾 String str = "hello"; boolean b = str.endsWith("lo");（结果：true）区分大小写，无忽略大小写的重载方法，需自行转换后判断

valueOf(Object obj) 静态方法，将任意类型转为字符串 int num = 123; String str = String.valueOf(num);（结果：”123”） 1. 若obj为null，返回字符串”null”
2. 比obj.toString()更安全，避免空指针

String 类核心要点

String是不可变字符串，所有修改操作都会返回新对象，原对象不变；
空指针防护：调用equals()、length()等方法前，需确保字符串非null；
正则相关方法（如split()、replaceAll()）需注意特殊字符转义。

1. 字符串反转

public class StringReverse {
    public static String reverse(String input) {
        if (input == null || input.isEmpty()) {
            return input;
        }
        
        char[] chars = input.toCharArray();
        int left = 0;
        int right = chars.length - 1;
        
        while (left < right) {
            char temp = chars[left];
            chars[left] = chars[right];
            chars[right] = temp;
            left++;
            right--;
        }
        
        return new String(chars);
    }

    public static void main(String[] args) {
        System.out.println(reverse("Hello"));  // "olleH"
        System.out.println(reverse("Java"));   // "avaJ"
    }
}

2. 检查回文字符串

public class PalindromeChecker {
    public static boolean isPalindrome(String str) {
        if (str == null) {
            return false;
        }
        
        str = str.toLowerCase().replaceAll("[^a-z0-9]", "");
        int left = 0;
        int right = str.length() - 1;
        
        while (left < right) {
            if (str.charAt(left) != str.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        
        return true;
    }

    public static void main(String[] args) {
        System.out.println(isPalindrome("A man, a plan, a canal: Panama"));  // true
        System.out.println(isPalindrome("racecar"));  // true
        System.out.println(isPalindrome("hello"));    // false
    }
}

3. 统计单词出现次数

import java.util.HashMap;
import java.util.Map;

public class WordCounter {
    public static Map<String, Integer> countWords(String text) {
        Map<String, Integer> wordCount = new HashMap<>();
        
        if (text == null || text.isEmpty()) {
            return wordCount;
        }
        
        String[] words = text.split("\\s+");
        
        for (String word : words) {
            word = word.toLowerCase().replaceAll("[^a-z]", "");
            if (!word.isEmpty()) {
                wordCount.put(word, wordCount.getOrDefault(word, 0) + 1);
            }
        }
        
        return wordCount;
    }

    public static void main(String[] args) {
        String text = "Hello world hello Java world Java";
        Map<String, Integer> counts = countWords(text);
        System.out.println(counts);  // {hello=2, world=2, java=2}
    }
}

八、性能考虑与最佳实践

字符串拼接性能：

// 不好 - 创建多个临时对象
String result = "";
for (int i = 0; i < 100; i++) {
    result += i;
}

// 好 - 使用StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
    sb.append(i);
}
String result = sb.toString();

字符串比较：

// 不好 - 可能NullPointerException
if (str.equals("literal")) {...}

// 好 - 避免NPE
if ("literal".equals(str)) {...}

// 更好 - Java 7+
if (Objects.equals(str, "literal")) {...}

字符串常量池利用：

// 不好 - 创建不必要的对象
String str = new String("literal");

// 好 - 利用字符串常量池
String str = "literal";

处理大文本：

// 对于大文件处理，避免一次性加载到内存
try (BufferedReader reader = new BufferedReader(new FileReader("large.txt"))) {
    String line;
    while ((line = reader.readLine()) != null) {
        // 处理每行
    }
}

国际化考虑：

1
2
3

// 指定Locale进行大小写转换
String lower = str.toLowerCase(Locale.ENGLISH);
String upper = str.toUpperCase(Locale.FRENCH);

通过合理使用 String 类及其相关工具类，可以高效地处理各种文本操作需求。记住字符串是不可变对象，在需要频繁修改字符串的场景中应考虑使用 StringBuilder 或 StringBuffer。

Java StringBuffer 和 StringBuilder 类全面解析

由于String是字符串是常量，他们的值在创建之后不能更改，如果我们使用这个String频繁进行操作，会有性能问题，这个时候需要使用StringBuﬀer和StringBuilder类，StringBuﬀer也被叫做“字符串缓冲区”，以后如果遇到什么缓冲，缓存，第一反应是为了提供性能。
在使用StringBuﬀer类时，每次都会对StringBuﬀer对象本身进行操作，而不是生成新的对象，所以如果需要对字符串进行修改推荐使用StringBuﬀer，StringBuilder类在java5被提出的，StringBuilder和
StringBuﬀer之间的最大不同是在于StringBuilder的方法不是线程安全

操作完String以后返回的是另外一个新的对象

一、StringBuffer 和 StringBuilder 基础

1. 创建对象

// StringBuilder 创建
StringBuilder sb1 = new StringBuilder();       // 默认容量16
StringBuilder sb2 = new StringBuilder(100);    // 指定初始容量
StringBuilder sb3 = new StringBuilder("Hello"); // 初始内容

// StringBuffer 创建
StringBuffer sbf1 = new StringBuffer();        // 默认容量16
StringBuffer sbf2 = new StringBuffer(100);     // 指定初始容量
StringBuffer sbf3 = new StringBuffer("World"); // 初始内容

2. 主要区别

特性	StringBuilder	StringBuffer
线程安全	非线程安全	线程安全
性能	更高	稍低
引入版本	Java 5	Java 1.0
适用场景	单线程环境	多线程环境

面试题：String/Stringbuﬀer/StringBuilder的区别？
1.String字符串的值不可改变，导致每次对String操作都会生成新的String对象，这样不仅效率底下，而且大量浪费有限的内存空间。如果频繁对字符型修改推荐使用StringBuﬀer和StringBuilder
2.StringBuﬀer是线程安全的，而StringBuilder是线程不安全的，在不考虑线程安全的情况下
3.StringBuilder的运行效率比StringBuﬀer更高。

二、常用方法详解

1. 追加内容 (append)

StringBuﬀer类的append()方法源码

注意代码不需要考虑线程安全问题的情况下，首先考虑使用StringBuilder。

@Override
    public synchronized StringBuffer append(String str) {
        toStringCache = null;
        super.append(str);
        return this;
   }

StringBuilder sb = new StringBuilder("Hello");

// 追加各种类型数据
sb.append(" ");             // 字符串
sb.append("World");         // 字符串
sb.append(123);             // 整数
sb.append(3.14);            // 浮点数
sb.append('!');             // 字符
sb.append(true);            // 布尔值

System.out.println(sb);     // "Hello World1233.14!true"

2. 插入内容 (insert)

StringBuilder sb = new StringBuilder("HelloWorld");

// 在指定位置插入各种类型数据
sb.insert(5, " ");          // 在索引5处插入空格
sb.insert(6, "Java");       // 在索引6处插入"Java"
sb.insert(10, 2023);        // 在索引10处插入数字

System.out.println(sb);     // "Hello JavaWorld2023"

3. 删除内容 (delete)

StringBuilder sb = new StringBuilder("HelloJavaWorld");

// 删除指定范围的字符
sb.delete(5, 9);            // 删除索引5-8的字符("Java")
System.out.println(sb);     // "HelloWorld"

// 删除指定位置的字符
sb.deleteCharAt(5);         // 删除索引5的字符('W')
System.out.println(sb);     // "Helloorld"

4. 替换内容 (replace)

StringBuilder sb = new StringBuilder("HelloWorld");

// 替换指定范围的字符
sb.replace(5, 10, "Java");  // 替换索引5-9的字符
System.out.println(sb);     // "HelloJava"

// 设置指定位置的字符
sb.setCharAt(5, 'j');       // 替换索引5的字符
System.out.println(sb);     // "Hellojava"

5. 反转字符串 (reverse)

1
2
3

StringBuilder sb = new StringBuilder("Hello");
sb.reverse();
System.out.println(sb);     // "olleH"

三、容量管理

1. 容量相关方法

StringBuilder sb = new StringBuilder(50);  // 初始容量50

// 获取信息
int length = sb.length();       // 当前长度 (0)
int capacity = sb.capacity();   // 当前容量 (50)

// 确保最小容量
sb.ensureCapacity(100);         // 确保容量至少100

// 设置长度
sb.setLength(10);               // 设置长度为10，可能用null字符填充

2. 容量增长机制

当追加内容超过当前容量时，会自动扩容：

新容量 = (原容量 + 1) * 2
如果还不够，则直接扩容到所需大小

1
2
3

StringBuilder sb = new StringBuilder();  // 默认容量16
sb.append("12345678901234567");          // 长度17
System.out.println(sb.capacity());       // 34 (16+1)*2

四、字符串操作

1. 获取子串和字符

StringBuilder sb = new StringBuilder("HelloWorld");

// 获取字符
char ch = sb.charAt(4);         // 'o'

// 获取子串
String sub1 = sb.substring(5);      // "World"
String sub2 = sb.substring(5, 8);   // "Wor"

// 获取字符序列
CharSequence seq = sb.subSequence(3, 6);  // "loW"

2. 查找操作

StringBuilder sb = new StringBuilder("HelloHello");

// 查找字符串
int first = sb.indexOf("ell");      // 1
int from = sb.indexOf("ell", 2);    // 6

// 反向查找
int last = sb.lastIndexOf("ell");   // 6
int lastFrom = sb.lastIndexOf("ell", 5);  // 1

五、实际应用示例

StringBuffer & StringBuilder 常用函数

说明

StringBuffer：线程安全，效率较低，适用于多线程场景
StringBuilder：非线程安全，效率较高，适用于单线程场景
两者方法名和功能完全一致，示例以StringBuilder为例

函数名称	功能描述	使用方式示例	注意事项
`append(任意类型)`	将任意类型数据追加到字符串末尾	`StringBuilder sb = new StringBuilder("hello"); sb.append(" world");`（结果：”hello world”）	1. 支持所有基本类型、对象（调用`toString()`） 2. 直接修改原对象，无返回新对象（区别于String）
`insert(int offset, 任意类型)`	在指定索引位置插入数据	`StringBuilder sb = new StringBuilder("hello"); sb.insert(2, "xx");`（结果：”hexxllo”）	1. 索引从0开始，超出范围抛`IndexOutOfBoundsException` 2. 插入位置为0则在开头插入，为长度则等价于append
`delete(int start, int end)`	删除指定索引范围的字符（包含start，不包含end）	`StringBuilder sb = new StringBuilder("hello"); sb.delete(1, 3);`（结果：”hlo”）	索引超出范围会抛异常，`deleteCharAt(int index)`可删除单个字符
`replace(int start, int end, String str)`	替换指定索引范围的字符为目标字符串	`StringBuilder sb = new StringBuilder("hello"); sb.replace(1, 3, "xx");`（结果：”hxxlo”）	1. 范围是[start, end) 2. 目标字符串长度可与原范围长度不同
`reverse()`	反转字符串内容	`StringBuilder sb = new StringBuilder("hello"); sb.reverse();`（结果：”olleh”）	直接修改原对象，无返回新对象
`charAt(int index)`	获取指定索引位置的字符	`StringBuilder sb = new StringBuilder("hello"); char c = sb.charAt(1);`（结果：’e’）	与String的`charAt()`规则一致，索引从0开始
`setCharAt(int index, char ch)`	修改指定索引位置的字符	`StringBuilder sb = new StringBuilder("hello"); sb.setCharAt(1, 'E');`（结果：”hEllo”）	1. 索引超出范围抛异常 2. 仅能修改单个字符，区别于replace
`length()`	获取字符序列的长度	`StringBuilder sb = new StringBuilder("hello"); int len = sb.length();`（结果：5）	与String的`length()`用法一致
`capacity()`	获取当前缓冲区的容量（可存储字符数，大于等于length）	`StringBuilder sb = new StringBuilder(); int cap = sb.capacity();`（默认：16）	1. 初始容量：空构造器为16，带字符串构造器为`16 + 字符串长度` 2. 容量不足时会自动扩容（通常翻倍+2）
`ensureCapacity(int minimumCapacity)`	手动指定最小容量，避免频繁扩容	`StringBuilder sb = new StringBuilder(); sb.ensureCapacity(100);`	仅当当前容量小于指定值时扩容，否则无操作
`trimToSize()`	收缩容量至当前字符长度，节省内存	`StringBuilder sb = new StringBuilder("hello"); sb.trimToSize();`	扩容后的缓冲区若有空闲空间，调用后会释放
`substring(int start)`	截取子串（返回String类型）	`StringBuilder sb = new StringBuilder("hello"); String sub = sb.substring(2);`（结果：”llo”）	1. 重载方法`substring(start, end)`规则同String 2. 返回新的String对象，不修改原StringBuilder
`toString()`	将StringBuilder/StringBuffer转为String类型	`StringBuilder sb = new StringBuilder("hello"); String str = sb.toString();`	是两者与String互转的核心方法，转换后不可变

StringBuffer/StringBuilder 核心要点

两者是可变字符序列，修改操作直接作用于原对象，效率远高于String；
线程安全选StringBuffer，单线程高性能选StringBuilder；
初始容量可根据业务预估设置，减少自动扩容带来的性能损耗。

1. 高效字符串拼接

public class StringConcatenation {
    public static String buildString(String[] parts) {
        StringBuilder sb = new StringBuilder();
        for (String part : parts) {
            sb.append(part);
        }
        return sb.toString();
    }

    public static void main(String[] args) {
        String[] words = {"This", " ", "is", " ", "a", " ", "test"};
        System.out.println(buildString(words));  // "This is a test"
    }
}

2. SQL 查询构建

public class SqlBuilder {
    public static String buildQuery(String table, String[] columns, String condition) {
        StringBuilder sql = new StringBuilder("SELECT ");
        
        // 添加列
        if (columns == null || columns.length == 0) {
            sql.append("*");
        } else {
            for (int i = 0; i < columns.length; i++) {
                if (i > 0) sql.append(", ");
                sql.append(columns[i]);
            }
        }
        
        // 添加表名
        sql.append(" FROM ").append(table);
        
        // 添加条件
        if (condition != null && !condition.isEmpty()) {
            sql.append(" WHERE ").append(condition);
        }
        
        return sql.toString();
    }

    public static void main(String[] args) {
        String[] cols = {"id", "name", "age"};
        String query = buildQuery("users", cols, "age > 18");
        System.out.println(query);
        // 输出: SELECT id, name, age FROM users WHERE age > 18
    }
}

3. CSV 文件生成

public class CsvGenerator {
    public static String generateCsv(String[] headers, String[][] data) {
        StringBuilder csv = new StringBuilder();
        
        // 添加表头
        for (int i = 0; i < headers.length; i++) {
            if (i > 0) csv.append(",");
            csv.append("\"").append(headers[i]).append("\"");
        }
        csv.append("\n");
        
        // 添加数据行
        for (String[] row : data) {
            for (int i = 0; i < row.length; i++) {
                if (i > 0) csv.append(",");
                csv.append("\"").append(row[i]).append("\"");
            }
            csv.append("\n");
        }
        
        return csv.toString();
    }

    public static void main(String[] args) {
        String[] headers = {"Name", "Age", "City"};
        String[][] data = {
            {"Alice", "25", "New York"},
            {"Bob", "30", "London"},
            {"Charlie", "22", "Paris"}
        };
        
        System.out.println(generateCsv(headers, data));
    }
}

六、性能考虑与最佳实践

选择正确的类：

// 单线程环境 - 使用StringBuilder
StringBuilder sb = new StringBuilder();

// 多线程环境 - 使用StringBuffer
StringBuffer sbf = new StringBuffer();

初始化容量：

1 2	// 如果知道大概大小，预先设置容量 StringBuilder sb = new StringBuilder(1024); // 避免频繁扩容

链式调用：

// 使用方法链提高可读性
String result = new StringBuilder()
    .append("Name: ").append(name)
    .append(", Age: ").append(age)
    .append(", Score: ").append(score)
    .toString();

与String的转换：

// 只在需要时才转换为String
StringBuilder sb = new StringBuilder();
// ...多次操作...
String finalString = sb.toString();  // 最后转换

线程安全考虑：

// 在多线程环境中使用StringBuffer
StringBuffer sharedBuffer = new StringBuffer();

// 或者使用同步包装
StringBuilder sb = new StringBuilder();
synchronized(sb) {
    sb.append("thread-safe operation");
}

避免不必要的使用：

// 简单拼接不需要StringBuilder
String simple = "Hello " + name;  // 编译器会自动优化

// 循环中应该使用StringBuilder
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 100; i++) {
    sb.append(i);
}

通过合理使用 StringBuffer 和 StringBuilder，可以显著提高字符串处理性能，特别是在需要频繁修改字符串内容的场景中。根据线程安全需求选择合适的类，并注意容量管理和转换时机，以获得最佳性能。

函数名称	功能描述	使用方式示例	注意事项
==`length()`==	获取字符串的字符长度	`String str = "hello"; int len = str.length();`（结果：5）	1. 区分数组的`length`（属性）和字符串的`length()`（方法） 2. 空字符串`""`的长度为0，`null`调用该方法会抛空指针异常
`charAt(int index)`	获取指定索引位置的字符	`String str = "hello"; char c = str.charAt(1);`（结果：’e’）	1. 索引从0开始 2. 索引超出范围会抛出`IndexOutOfBoundsException`
`equals(Object obj)`	比较两个字符串的内容是否完全相同	`String str1 = "hello"; String str2 = "HELLO"; boolean b = str1.equals(str2);`（结果：false）	1. 区分大小写 2. 避免空指针：建议用非空字符串调用，如`"hello".equals(str)`
`equalsIgnoreCase(String anotherString)`	忽略大小写比较字符串内容	`String str1 = "hello"; String str2 = "HELLO"; boolean b = str1.equalsIgnoreCase(str2);`（结果：true）	仅忽略英文字母大小写，其他字符（如数字、符号）严格匹配
`contains(CharSequence s)`	判断字符串是否包含指定子串	`String str = "hello world"; boolean b = str.contains("world");`（结果：true）	参数可以是String、StringBuffer、StringBuilder等CharSequence类型
`indexOf(String str)`	查找子串首次出现的索引，未找到返回-1	`String str = "hello world"; int idx = str.indexOf("o");`（结果：4）	1. 索引从0开始 2. 支持重载：`indexOf(str, int fromIndex)`（从指定位置开始查找）
`lastIndexOf(String str)`	查找子串最后一次出现的索引，未找到返回-1	`String str = "hello world"; int idx = str.lastIndexOf("o");`（结果：7）	支持重载：`lastIndexOf(str, int fromIndex)`（从指定位置向前查找）
`substring(int beginIndex)`	截取从指定索引到末尾的子串	`String str = "hello world"; String sub = str.substring(6);`（结果：”world”）	1. 索引从0开始 2. 重载方法`substring(beginIndex, endIndex)`：包含begin，不包含end
`trim()`	去除字符串首尾的空白字符（空格、制表符、换行等）	`String str = " hello "; String res = str.trim();`（结果：”hello”）	1. Java 11前仅去除ASCII空白符，Java 11+可使用`strip()`（支持Unicode空白） 2. 不改变原字符串内容
`replace(CharSequence oldStr, CharSequence newStr)`	替换字符串中所有指定的子串	`String str = "hello world"; String res = str.replace("o", "0");`（结果：”hell0 w0rld”）	1. 替换所有匹配项 2. 区分大小写，如需忽略大小写可使用`replaceAll()`结合正则
`split(String regex)`	按指定正则表达式分割字符串，返回字符串数组	`String str = "a,b,c"; String[] arr = str.split(",");`（结果：[“a”,”b”,”c”]）	1. 参数是正则表达式，特殊字符（如.、	、*）需转义（`\\.`） 2. 分割空字符串可能返回长度为1的数组（包含空串）
`toUpperCase()`	将字符串所有字符转为大写	`String str = "hello"; String res = str.toUpperCase();`（结果：”HELLO”）	遵循系统默认Locale，如需指定Locale可使用重载方法
`toLowerCase()`	将字符串所有字符转为小写	`String str = "HELLO"; String res = str.toLowerCase();`（结果：”hello”）	同上，避免因Locale差异导致转换异常
`isEmpty()`	判断字符串是否为空（长度为0）	`String str = ""; boolean b = str.isEmpty();`（结果：true）	1. `null`调用该方法会抛空指针异常 2. 可结合`str == null`判断：`str == null		str.isEmpty()`
`startsWith(String prefix)`	判断字符串是否以指定前缀开头	`String str = "hello"; boolean b = str.startsWith("he");`（结果：true）	重载方法`startsWith(prefix, int offset)`：从指定索引开始判断前缀
`endsWith(String suffix)`	判断字符串是否以指定后缀结尾	`String str = "hello"; boolean b = str.endsWith("lo");`（结果：true）	区分大小写，无忽略大小写的重载方法，需自行转换后判断
`valueOf(Object obj)`	静态方法，将任意类型转为字符串	`int num = 123; String str = String.valueOf(num);`（结果：”123”）	1. 若obj为null，返回字符串”null” 2. 比`obj.toString()`更安全，避免空指针