Javajava
Java 常用类速查：包装类、String、StringBuilder、Math、日期类
Java 开发中常用的核心类库。涵盖包装类的概念、自动装箱拆箱及缓存机制；详细解析了 String 类的不可变性、内存分配及常用方法，对比了 StringBuffer 与 StringBuilder 的区别；讲解了 Math 类的数学运算功能；并梳理了从 Date、Calendar 到 JDK 8 LocalDateTime 的日期处理演变。适合 Java 初学者快速查阅与复习。
Java 开发中常用的核心类库。涵盖包装类的概念、自动装箱拆箱及缓存机制；详细解析了 String 类的不可变性、内存分配及常用方法，对比了 StringBuffer 与 StringBuilder 的区别；讲解了 Math 类的数学运算功能；并梳理了从 Date、Calendar 到 JDK 8 LocalDateTime 的日期处理演变。适合 Java 初学者快速查阅与复习。
常用类是 Java 开发中频繁使用的工具类，掌握这些类的使用方法和特点能够提高开发效率，编写更加规范的代码。
+ 拼接会创建新对象常用类： Java 提供的一系列工具类，包括包装类、字符串类、数学类、日期类等，用于处理常见的编程任务。
核心类：
包装类（Wrapper Class）： 将基本数据类型封装成对象。
为什么需要包装类？
| 基本类型 | 包装类 | 父类 |
|---|---|---|
| byte | Byte | Number |
| short | Short | Number |
| int | Integer | Number |
| long | Long | Number |
| float | Float | Number |
| double | Double | Number |
| char | Character | Object |
| boolean | Boolean | Object |
装箱： 基本类型 → 包装类
拆箱： 包装类 → 基本类型
手动装箱拆箱（JDK 5 之前）：
// 手动装箱
int n1 = 100;
Integer integer1 = new Integer(n1);
// 方式 1
Integer integer2 = Integer.valueOf(n1);
// 方式 2（推荐）
// 手动拆箱
int n2 = integer1.intValue();
自动装箱拆箱（JDK 5 之后，推荐）：
// 自动装箱
int n1 = 100;
Integer integer = n1;
// 底层：Integer.valueOf(n1)
// 自动拆箱
int n2 = integer;
// 底层：integer.intValue()
包装类 ↔ String：
// Integer → String
Integer i = 100;
String s1 = i + ""; // 方式 1
String s2 = i.toString(); // 方式 2
String s3 = String.valueOf(i); // 方式 3（推荐）
// String → Integer
String s = "123";
Integer i1 = Integer.parseInt(s); // 方式 1（自动装箱）
Integer i2 = new Integer(s); // 方式 2
// 常量
System.out.println(Integer.MIN_VALUE); // -2147483648
System.out.println(Integer.MAX_VALUE); // 2147483647
// 方法
Integer.parseInt("123"); // 字符串转 int
Integer.valueOf("123"); // 字符串转 Integer
Integer.toBinaryString(10); // 十进制转二进制字符串
Integer.toHexString(255); // 十进制转十六进制字符串
Character.isDigit('5'); // 判断是否是数字
Character.isLetter('a'); // 判断是否是字母
Character.isUpperCase('A'); // 判断是否是大写
Character.isLowerCase('a'); // 判断是否是小写
Character.isWhitespace(' '); // 判断是否是空白字符
Character.toUpperCase('a'); // 转大写
Character.toLowerCase('A'); // 转小写
Integer 缓存： -128 ~ 127
Integer a = 127;
Integer b = 127;
System.out.println(a == b); // true（使用缓存）
Integer c = 128;
Integer d = 128;
System.out.println(c == d); // false（超出缓存范围，创建新对象）
// 建议：包装类比较使用 equals()
System.out.println(c.equals(d)); // true
特点：
char[] value（JDK 8）或 byte[] value（JDK 9+）方式一：直接赋值（推荐）
String s1 = "hello"; // 指向常量池
String s2 = "hello"; // 复用常量池中的对象
System.out.println(s1 == s2); // true
方式二：使用构造器
String s3 = new String("hello"); // 在堆中创建对象
String s4 = new String("hello"); // 在堆中创建新对象
System.out.println(s3 == s4); // false
内存分析：
栈 常量池 堆
s1 ────→ "hello"
s2 ────→ ↑
s3 ────────────────→ String 对象 ──→ "hello"
s4 ────────────────→ String 对象 ──→ "hello"
规则：
// 1. 常量相加
String s1 = "hello" + "world"; // 编译优化为 "helloworld"，在常量池
// 2. 变量相加
String a = "hello";
String b = "world";
String s2 = a + b; // 在堆中创建新对象
// 底层实现：
// StringBuilder sb = new StringBuilder();
// sb.append(a);
// sb.append(b);
// String s2 = sb.toString();
System.out.println(s1 == s2); // false
判断类：
String s = "Hello World";
s.equals("hello"); // false（比较内容，区分大小写）
s.equalsIgnoreCase("hello"); // true（忽略大小写）
s.isEmpty(); // false（判断是否为空）
s.startsWith("He"); // true（是否以指定字符串开头）
s.endsWith("ld"); // true（是否以指定字符串结尾）
s.contains("lo"); // true（是否包含）
查找类：
String s = "hello world";
s.length(); // 11（字符串长度）
s.charAt(0); // 'h'（获取指定索引的字符）
s.indexOf('o'); // 4（第一次出现的索引）
s.lastIndexOf('o'); // 7（最后一次出现的索引）
提取类：
String s = "Hello World";
s.substring(6); // "World"（从索引 6 到末尾）
s.substring(0, 5); // "Hello"（从索引 0 到 5，不含 5）
转换类：
String s = "Hello World";
s.toUpperCase(); // "HELLO WORLD"（转大写）
s.toLowerCase(); // "hello world"（转小写）
s.trim(); // 去除前后空格
s.replace('l', 'L'); // "HeLLo WorLd"（替换字符）
s.replace("World", "Java"); // "Hello Java"（替换字符串）
分割类：
String s = "apple,banana,orange";
String[] arr = s.split(","); // ["apple", "banana", "orange"]
// 特殊字符需要转义
String s2 = "a|b|c";
String[] arr2 = s2.split("\\|"); // ["a", "b", "c"]
转换为字符数组：
String s = "hello";
char[] chars = s.toCharArray(); // ['h', 'e', 'l', 'l', 'o']
格式化字符串：
String name = "张三";
int age = 20;
double score = 95.5;
String info = String.format("姓名：%s，年龄：%d，成绩：%.2f", name, age, score);
System.out.println(info); // 姓名：张三，年龄：20，成绩：95.50
题目 1：创建了几个对象？
String s = new String("hello");
答案： 2 个
题目 2：下面代码的输出？
String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
System.out.println(s1 == s2); // ?
System.out.println(s1 == s3); // ?
System.out.println(s1.equals(s3)); // ?
答案：
s1 == s2：true（指向同一个常量池对象）s1 == s3：false（s3 在堆中）s1.equals(s3)：true（内容相同）特点：
char[] value（可变数组）| 特性 | String | StringBuffer |
|---|---|---|
| 可变性 | 不可变 | 可变 |
| 线程安全 | 安全 | 安全 |
| 效率 | 低（频繁创建对象） | 高 |
| 使用场景 | 字符串不变 | 频繁修改 |
// 方式 1：无参构造器（初始容量 16）
StringBuffer sb1 = new StringBuffer();
// 方式 2：指定容量
StringBuffer sb2 = new StringBuffer(100);
// 方式 3：通过字符串创建
StringBuffer sb3 = new StringBuffer("hello");
String → StringBuffer：
String str = "hello";
// 方式 1：使用构造器
StringBuffer sb1 = new StringBuffer(str);
// 方式 2：使用 append()
StringBuffer sb2 = new StringBuffer();
sb2.append(str);
StringBuffer → String：
StringBuffer sb = new StringBuffer("hello");
// 方式 1：使用 toString()（推荐）
String s1 = sb.toString();
// 方式 2：使用构造器
String s2 = new String(sb);
StringBuffer sb = new StringBuffer("hello");
// 1. append()：追加
sb.append(" world"); // "hello world"
sb.append(123); // "hello world123"
// 2. delete()：删除
sb.delete(5, 11); // "hello123"（删除索引 5 到 11，不含 11）
// 3. replace()：替换
sb.replace(0, 5, "hi"); // "hi123"（替换索引 0 到 5）
// 4. indexOf()：查找
int index = sb.indexOf("123"); // 2
// 5. insert()：插入
sb.insert(2, "aaa"); // "hiaa123"（在索引 2 处插入）
// 6. length()：获取长度
int len = sb.length(); // 7
// 7. reverse()：反转
sb.reverse(); // "321aahi"
特点：
char[] value（可变数组）| 特性 | String | StringBuffer | StringBuilder |
|---|---|---|---|
| 可变性 | 不可变 | 可变 | 可变 |
| 线程安全 | 安全 | 安全 | 不安全 |
| 效率 | 低 | 较高 | 最高 |
| 使用场景 | 少量修改 | 多线程频繁修改 | 单线程频繁修改 |
效率测试：
long start = System.currentTimeMillis();
// String：最慢
String s = "";
for (int i = 0; i < 100000; i++) {
s += i;
}
// StringBuffer：较快
StringBuffer sb = new StringBuffer();
for (int i = 0; i < 100000; i++) {
sb.append(i);
}
// StringBuilder：最快
StringBuilder sbd = new StringBuilder();
for (int i = 0; i < 100000; i++) {
sbd.append(i);
}
long end = System.currentTimeMillis();
效率： StringBuilder > StringBuffer > String
选择建议：
// 1. abs()：绝对值
Math.abs(-10); // 10
// 2. pow()：幂运算
Math.pow(2, 3); // 8.0（2 的 3 次方）
// 3. sqrt()：平方根
Math.sqrt(16); // 4.0
// 4. ceil()：向上取整
Math.ceil(3.1); // 4.0
// 5. floor()：向下取整
Math.floor(3.9); // 3.0
// 6. round()：四舍五入
Math.round(3.5); // 4
Math.round(3.4); // 3
// 7. random()：随机数 [0, 1)
Math.random(); // 0.xxxx
// 8. max()、min()：最大最小值
Math.max(10, 20); // 20
Math.min(10, 20); // 10
// 9. PI、E 常量
Math.PI; // 3.141592653589793
Math.E; // 2.718281828459045
生成 [a, b] 范围的随机整数：
// 公式：(int)(Math.random() * (b - a + 1)) + a
// 示例：生成 [10, 20] 的随机数
int num = (int)(Math.random() * 11) + 10;
import java.util.Date;
import java.text.SimpleDateFormat;
// 1. 获取当前时间
Date date = new Date();
System.out.println(date); // Thu Jan 18 18:30:00 CST 2025
// 2. 格式化日期
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String dateStr = sdf.format(date);
System.out.println(dateStr); // 2025-01-18 18:30:00
// 3. 字符串 → Date
String str = "2025-01-18 18:30:00";
Date date2 = sdf.parse(str);
import java.util.Calendar;
// 1. 获取 Calendar 实例
Calendar cal = Calendar.getInstance();
// 2. 获取日期信息
int year = cal.get(Calendar.YEAR);
int month = cal.get(Calendar.MONTH) + 1; // 月份从 0 开始，要 +1
int day = cal.get(Calendar.DAY_OF_MONTH);
int hour = cal.get(Calendar.HOUR_OF_DAY); // 24 小时制
int minute = cal.get(Calendar.MINUTE);
int second = cal.get(Calendar.SECOND);
// 3. 设置日期
cal.set(2025, 0, 18); // 设置为 2025 年 1 月 18 日
// 4. 日期计算
cal.add(Calendar.DAY_OF_MONTH, 10); // 加 10 天
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
// 1. 获取当前时间
LocalDateTime now = LocalDateTime.now();
System.out.println(now); // 2025-01-18T18:30:00
// 2. 获取日期信息
int year = now.getYear();
int month = now.getMonthValue();
int day = now.getDayOfMonth();
int hour = now.getHour();
int minute = now.getMinute();
int second = now.getSecond();
// 3. 格式化
DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String dateStr = now.format(dtf);
System.out.println(dateStr); // 2025-01-18 18:30:00
// 4. 字符串 → LocalDateTime
String str = "2025-01-18 18:30:00";
LocalDateTime ldt = LocalDateTime.parse(str, dtf);
// 5. 日期计算
LocalDateTime future = now.plusDays(10); // 加 10 天
LocalDateTime past now.minusMonths();
答案：
答案：
| 特性 | String | StringBuffer | StringBuilder |
|---|---|---|---|
| 可变性 | 不可变 | 可变 | 可变 |
| 线程安全 | 安全 | 安全 | 不安全 |
| 效率 | 低 | 较高 | 最高 |
选择建议：
答案：
==：比较引用（地址）equals()：比较内容String s1 = "hello";
String s2 = "hello";
String s3 = new String("hello");
s1 == s2; // true（指向同一个常量池对象）
s1 == s3; // false（s3 在堆中）
s1.equals(s3); // true（内容相同）
答案： 2 个
答案：
intern() 方法会在常量池中查找是否有相同内容的字符串：
String s1 = "hello";
String s2 = new String("hello");
System.out.println(s1 == s2); // false
System.out.println(s1 == s2.intern()); // true
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online