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