目录
[Java 核心知识点：字符串转整数与字符串相加](#Java 核心知识点：字符串转整数与字符串相加)
[一、 字符串转整形数字](#一、 字符串转整形数字)
[1.1 精简版（快速上手）](#1.1 精简版（快速上手）)
[1.2 详细版（机制与陷阱）](#1.2 详细版（机制与陷阱）)
[1.3 关键陷阱总结表](#1.3 关键陷阱总结表)
[二、 字符串相加](#二、 字符串相加)
[2.1 精简版（性能核心）](#2.1 精简版（性能核心）)
[2.2 详细版（编译器优化与陷阱）](#2.2 详细版（编译器优化与陷阱）)
[2.3 性能选择决策树](#2.3 性能选择决策树)
[💡 一句话总结](#💡 一句话总结)
本文总结Java中字符串转整数和字符串相加的核心知识点：1. 字符串转整数：推荐使用Integer.parseInt()方法，需注意处理NumberFormatException异常，对带空格的字符串要先trim()，大数值可使用Long.parseLong()或BigInteger。2. 字符串相加：编译期常量可使用+运算符（会被优化），但循环中必须使用StringBuilder以避免性能问题（性能差距可达200倍），多线程场景用StringBuffer，分隔符连接推荐String.join()。3. 关键陷阱：包括字符串转数字时的空值处理、进制转换问题，以及字符串拼接的性能优化策略。
Java 核心知识点：字符串转整数与字符串相加
一、 字符串转整形数字
1.1 精简版（快速上手）
Java
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); // 2551.2 详细版（机制与陷阱）
Java
java
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.3 关键陷阱总结表
| 输入字符串 | 结果 | 原因 |
|---|---|---|
"123" |
✅ 123 | 标准十进制 |
" 123 " |
❌ 异常 | 含空格，必须先 trim() |
"" |
❌ 异常 | 空字符串无法解析 |
null |
❌ NPE | 非 NumberFormatException，需提前判空 |
"0xFF" |
❌ 异常 | parseInt 不认识前缀，用 decode 或指定 radix=16 |
"123.45" |
❌ 异常 | 含小数点，应先用 Double.parseDouble 再转 int |
二、 字符串相加
2.1 精简版（性能核心）
Java
java
// 方式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"2.2 详细版（编译器优化与陷阱）
Java
java
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]
}
}2.3 性能选择决策树
- 需要拼接字符串？
├── 编译期常量（如 "a" + "b"）→ 直接用 +（编译器优化）
├── 单线程运行时拼接
│ ├── 次数 < 5 → 用 +（可读性好，性能可接受）
│ └── 次数 ≥ 5 或循环中 → 用 StringBuilder
├── 多线程共享变量拼接 → 用 StringBuffer（线程安全）
└── 需要分隔符连接多个字符串 → 用 String.join