复习篇-常用实用类

9.1 String 类（不可变字符串，java.lang 包无需导入）

String 特点：字符串一旦创建，内容不能修改，底层 char 数组（Java9+byte 数组），每次拼接都会生成新 String 对象。

9.1.1 构造 String 对象（4 种常用构造方式）

直接字面量（推荐，复用常量池）

String s1 = "hello"; // 存字符串常量池，重复创建会复用

String s2 = "hello";System.out.println(s1 == s2); // true，同一常量池对象

new String (String 字符串)，强制新建堆对象

String s3 = new String("hello");

System.out.println(s1 == s3); // false，堆中新对象

System.out.println(s1.equals(s3)); // true，内容相等

char 数组构造

char[] arr = {'J','a','v','a'};

String s4 = new String(arr);

System.out.println(s4); // Java

String 变量名 = new String(char[] 字符数组);//就是 把一个 char 数组，转换成一个完整的 String 字符串。

byte 字节数组构造（解码）

byte[] b = {97,98,99};

String s5 = new String(b);

System.out.println(s5); // abc

9.1.2 String 类的常用方法

1. 获取长度、字符、索引

String str = "Java面向对象";

// 长度

System.out.println(str.length()); // 8

// 根据下标取字符

System.out.println(str.charAt(2)); // v

// 查找字符第一次出现下标

System.out.println(str.indexOf('面')); // 4// 查找最后一次下标

System.out.println(str.lastIndexOf('a')); // 3

2. 截取字符串 substring

String s = "abcdef";

System.out.println(s.substring(2)); // cdef 从下标2到末尾

System.out.println(s.substring(1,4)); // bcd 左闭右开[1,4)

3. 大小写转换

String s = "HelloJava";

System.out.println(s.toUpperCase()); // HELLOJAVA

System.out.println(s.toLowerCase()); // hellojava

4. 去除首尾空格 trim ()

String s = "  测试  ";

System.out.println(s.trim()); // "测试" 中间空格保留

5. 判断开头结尾

String url = "https://www.baidu.com";System.out.println(url.startsWith("https"));

 // true

System.out.println(url.endsWith(".com")); // true

6. 内容比较

==：比较对象地址

equals()：比较字符串内容（区分大小写）

equalsIgnoreCase()：忽略大小写比较

String a = "ABC", b = "abc";

System.out.println(a.equals(b)); // false

System.out.println(a.equalsIgnoreCase(b)); // true

9.1.3 String 与基本数据类型相互转换

1. 基本类型 → String

两种方式：String.valueOf(数据) / 数据 +""

int num = 123;

String s1 = String.valueOf(num);

String s2 = num + "";

System.out.println(s1+s2); // 123123

2. String → 基本类型（包装类静态 parseXxx）

String numStr = "666";

int i = Integer.parseInt(numStr);

double d = Double.parseDouble("3.14");

boolean flag = Boolean.parseBoolean("true");

System.out.println(i + d); // 669.14

9.1.4 对象的 String 表示 toString ()

所有对象都继承 Object 的 toString ()，默认返回类名@哈希地址，建议重写打印自定义信息。 示例：自定义学生类

class Student{

    String name;

    int age;

    public Student(String name,int age){

        this.name = name;

        this.age = age;

    }

    // 重写toString

    @Override

    public String toString() {

        return "学生{姓名："+name+"，年龄："+age+"}";

    }}public class Test{

    public static void main(String[] args) {

        Student stu = new Student("张三",18);

        System.out.println(stu); // 自动调用toString()

        // 输出：学生{姓名：张三，年龄：18}

    }}

9.1.5 字符序列与字符、字节数组转换

String ↔ char [] 字符数组转换（最常用）

1. String → char[] ：toCharArray()

把字符串拆成一个个字符，放进数组。

String str = "Java面向对象";

// 字符串 → 字符数组

char[] chs = str.toCharArray();

结果：

chs[0] = 'J'

chs[1] = 'a'

chs[2] = 'v'

chs[3] = 'a'

chs[4] = '面'

...

2. char[] → String ：new String(char[])

把字符数组拼成字符串。

char[] arr = {'J','a','v','a'};

String s = new String(arr); // 结果："Java"

---

三、String ↔ byte [] 字节数组转换（编码 / 解码）

1. String → byte[] ：getBytes()一个中文字有三个字节

编码：把字符串变成计算机能存的字节（UTF-8 最常用）。

String str = "中文";byte[] bytes = str.getBytes(); // 转成字节数组

2. byte[] → String ：new String(byte[])

解码：把字节数组还原成字符串。

byte[] b = {97, 98, 99};String s = new String(b); // 结果："abc"

---

四、3 句口诀记住所有转换

字符串变字符数组 → toCharArray()

字符数组变字符串 → new String(数组)

字符串变字节数组 → getBytes()

字节数组变字符串 → new String(数组)

9.2 正则表达式（匹配、替换、分割字符串，Pattern/Matcher 底层）

9.2.1 正则元字符（核心匹配符号）

表格

元字符	作用	示例
\d	数字 0-9	\\d{6} 匹配 6 位数字
\w	字母、数字、下划线	[a-zA-Z0-9_]
\s	空白（空格、制表、换行）
.	任意字符（除换行）	a.b 匹配 a1b、a#b
^	开头	^1 以 1 开头
$	结尾	9$ 以 9 结尾
*	0 次或多次	\d* 任意个数字
+	1 次或多次	\d+ 至少 1 个数字
?	0 或 1 次	\\d? 0/1 个数字
{n}	恰好 n 次	{6} 6 次
{n,m}	n~m 次	{1,11} 1 到 11 位
[]	字符集	[0-9a-z] 数字小写字母
()	分组	`(13	15)\d {9}` 13/15 开头手机号

反斜杠要加倍

示例：手机号正则 ^1[3-9]\\d{9}$

String phone = "13812345678";

boolean match = phone.matches("^1[3-9]\\d{9}$");

System.out.println(match); // true

9.2.2 常用正则场景

邮箱匹配：^\\w+@\\w+\\.(com|cn)$

. 在正则里是 “任意字符” 如果想表示 真正的点（.），必须写成 \\.

String email = "test123@qq.com";

System.out.println(email.matches("^\\w+@\\w+\\.(com|cn)$")); // true

身份证 18 位：^\\d{17}[0-9Xx]$

纯数字校验：^\\d+$

想当功能用 → 直接写

+ * . ? () []

想当普通字符用 → 加 \

\\+ 加号本身

\\. 点本身

\\? 问号本身

Java 要写 4 个反斜杠 \\\\ 才能真正表示 1 个 \

9.2.3 字符序列的替换与分割（String 内置方法）

1. split (String regex) 按正则分割字符串，返回数组

String str = "苹果,香蕉,橘子";

String[] fruits = str.split(",");

for(String f : fruits) System.out.println(f);

//把 fruits 数组里的每一个东西，挨个取出来，放进 f 里，然后打印

// 按数字分割

String s = "a1b2c3d";

String[] arr = s.split("\\d");

System.out.println(arr[0]+arr[1]+arr[2]+arr[3]); // abcd

2. replaceAll (String regex,String newStr) 正则全局替换

String text = "a1b2c3";

String res = text.replaceAll("\\d","*");

System.out.println(res); // a*b*c*

// 过滤所有中文

String s = "java语言888";

String clear = s.replaceAll("[\\u4e00-\\u9fa5]","");

System.out.println(clear); // java888

9.3 StringTokenizer 类（老式字符串分割工具，java.util）

区别于 split：基于分隔符标记分割，不支持正则，分割效率高，迭代遍历 构造：StringTokenizer(字符串,分隔符) 常用方法：

hasMoreTokens()：是否还有分割片段

nextToken()：取出下一段

countTokens()：总片段数量 示例：

// 1. 必须导入工具类，不然程序找不到

StringTokenizerimport java.util.StringTokenizer;

public class TestToken {

    public static void main(String[] args) {

        // 2. 原始字符串：用逗号隔开4个数字

        String data = "100,200,300,400";

        

        // 3. 创建分割器对象

        // 第一个参数：要切割的字符串 data

        // 第二个参数：分隔符 , （按逗号切分）

        StringTokenizer st = new StringTokenizer(data,",");

        

        // 4. countTokens()：统计还剩下多少段没读取

        System.out.println("片段总数："+st.countTokens()); //输出4

        // 原理：字符串被逗号切成 100、200、300、400 一共4段

        

        // 5. while循环：判断是否还有没读完的片段

        // hasMoreTokens() 返回 true = 还有片段没取；false = 全部读完

        while(st.hasMoreTokens()){

            // 6. nextToken()：取出当前这一段，指针自动往后走一格

            String num = st.nextToken();

            // 打印取出的片段

            System.out.print(num+" ");

        }

    }}

9.4 Scanner 类（控制台输入、文件读取，java.util）

作用：读取控制台键盘输入，支持基本类型、字符串

核心方法

next()：读取一段不含空格的字符串

nextLine()：读取整行（含空格）

nextInt()/nextDouble ()：读取数字 示例：控制台录入姓名、年龄

import java.util.Scanner;

public class TestScanner {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        System.out.print("输入姓名：");

        String name = sc.nextLine();

        System.out.print("输入年龄：");

        int age = sc.nextInt();

        System.out.println("姓名："+name+"，年龄："+age);

        sc.close(); // 关闭流

    }}

坑点：nextInt () 读取数字后会残留换行符，后续 nextLine () 会直接读空行，解决：多读一次空行sc.nextLine();

9.5 Pattern 与 Matcher（正则底层实现，复杂匹配、分组提取）

---

String s = "123456";

boolean res = s.matches("\\d{6}");

---

使用固定 4 步（背会这 4 步就无敌）

// 1. 写正则

String regex = "\\d+";

// 2. 编译正则 →

PatternPattern p = Pattern.compile(regex);

// 3. 创建匹配器 →

MatcherMatcher m = p.matcher("abc123def456");

// 4. 使用Matcher方法

m.find(); // 查找

m.group(); // 取找到的内容

完整示例 1：查找数字

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class TestPattern {

    public static void main(String[] args) {

        String str = "Java123Python456";

        String regex = "\\d+"; // 匹配数字

        // 1. 编译

        Pattern p = Pattern.compile(regex);

        // 2. 匹配器

        Matcher m = p.matcher(str);

        // 3. 循环查找所有数字

        while(m.find()){

            System.out.println("找到：" + m.group());

        }

}}

输出：

找到：123

找到：456

完整示例 2：判断邮箱

String regex = "\\w+@\\w+\\.com";

Pattern p = Pattern.compile(regex);

Matcher m = p.matcher("test@qq.com");

boolean ok = m.matches();

System.out.println(ok); // true

9.6 StringBuffer 类（可变字符串，线程安全；同类 StringBuilder 线程不安全、速度更快）

String 不可变，大量拼接用 StringBuffer/Builder 避免生成大量中间对象。

9.6.1 StringBuffer 对象创建

三种构造：

// 空缓冲区，默认容量16

StringBuffer sb1 = new StringBuffer();

// 指定初始容量

StringBuffer sb2 = new StringBuffer(50);

// 用字符串初始化

StringBuffer sb3 = new StringBuffer("java");

9.6.2 StringBuffer 常用方法（全部修改自身，不产生新对象）

append () 追加（最常用，支持所有类型）

StringBuffer sb = new StringBuffer();

sb.append("数字：").append(123).append(",布尔：").append(true);

System.out.println(sb); //数字：123,布尔：true

insert (下标，内容) 指定位置插入

StringBuffer sb = new StringBuffer("abc");

sb.insert(1,"X");System.out.println(sb); //aXbc

delete (start,end) 删除区间字符

StringBuffer sb = new StringBuffer("123456");

sb.delete(2,4);System.out.println(sb); //1256

reverse () 字符串反转

StringBuffer sb = new StringBuffer("abcde");

sb.reverse();System.out.println(sb); //edcba

replace (start,end, 新串) 区间替换

StringBuffer sb = new StringBuffer("0000");

sb.replace(1,3,"99");System.out.println(sb); //0990

转 String：toString ()

String res = sb.toString();

类	可变性	线程安全	性能	适用场景
String	不可变	安全	差（频繁拼接大量对象）	少量字符串、常量
StringBuffer	可变	加同步锁，安全	较慢	多线程下字符串拼接
StringBuilder	可变	无锁，不安全	最快	单线程大量拼接（开发最常用）

9.7 日期与时间（java.time 包 Java8 全新时间 API，替代老旧 Date/SimpleDateFormat）

9.7.1 java.time 核心类（推荐全部使用，无线程安全问题）

LocalDate：只存年月日（日期）

LocalTime：只存时分秒（时间）

LocalDateTime：年月日时分秒（完整日期时间）

Instant：时间戳（毫秒，机器时间）

Duration：时分秒时间差

Period：年月日日期差

示例 1：获取当前时间

import java.time.*;

public class TestTime {

    public static void main(String[] args) {

        LocalDate date = LocalDate.now(); // 当前日期 2026-06-08

        LocalTime time = LocalTime.now(); // 当前时分秒

        LocalDateTime dt = LocalDateTime.now(); // 完整时间

        System.out.println(date);

        System.out.println(time);

        System.out.println(dt);

}}

示例 2：自定义指定时间

LocalDate birthday = LocalDate.of(2005,5,20);

LocalDateTime dt = LocalDateTime.of(2026,6,8,14,30);

9.7.2 日期、时间差和日历

Period 计算年月日差

LocalDate d1 = LocalDate.of(2020,1,1);

LocalDate d2 = LocalDate.of(2026,6,8);

Period p = Period.between(d1,d2);

System.out.println("相差："+p.getYears()+"年"+p.getMonths()+"月"+p.getDays()+"日");

Duration 计算时分秒毫秒差

LocalTime t1 = LocalTime.of(9,0);

LocalTime t2 = LocalTime.of(18,30);

Duration dur = Duration.between(t1,t2);

System.out.println("相差小时："+dur.toHours());

日期增减操作（plus/minus，返回新时间对象，原对象不变）

LocalDate today = LocalDate.now();

LocalDate nextWeek = today.plusWeeks(1); //加一周

LocalDate lastMonth = today.minusMonths(1); //减一月

加：plus 减：minus

后面跟上你要加 / 减的单位：

Years → 年

Months → 月

Days → 日

Hours → 时

Minutes → 分

Seconds → 秒

9.7.3 日期格式化 DateTimeFormatter（线程安全，替代 SimpleDateFormat）

格式化时间 → 字符串、字符串 → 时间

import java.time.format.DateTimeFormatter;

public class TestFormat {

    public static void main(String[] args) {

        LocalDateTime now = LocalDateTime.now();

        // 定义格式模板

       DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        // 时间转字符串

        String timeStr = now.format(formatter);

        System.out.println(timeStr);

        // 字符串转回时间

        String str = "2026-06-08 15:20:00";

        LocalDateTime parseDt = LocalDateTime.parse(str,formatter);

        System.out.println(parseDt);

}}

格式符号说明：

yyyy：4 位年份，MM：两位月份，dd：两位日期

HH：24 小时制，mm：分钟，ss：秒

例子：

"yyyy-MM-dd HH:mm:ss"

→ 2026-06-08 14:30:00

"yyyy/MM/dd"

→ 2026/06/08

"yyyy年MM月dd日 HH:mm"

→ 2026年06月08日 14:30

9.8 Math、BigInteger 和 Random 类

9.8.1 Math 类（java.lang，静态数学工具，全静态方法，无需 new）

1）Math.abs(数字) → 求绝对值

System.out.println(Math.abs(-10)); // 10

2）Math.max(a,b) → 取最大

System.out.println(Math.max(5, 9)); // 9

3）Math.min(a,b) → 取最小

System.out.println(Math.min(5,9)); //5

4）Math.round(小数) → 四舍五入

System.out.println(Math.round(3.6)); //4

5）Math.ceil(小数) → 向上取整

System.out.println(Math.ceil(2.1)); //3.0

6）Math.floor(小数) → 向下取整

System.out.println(Math.floor(2.9)); //2.0

7）Math.pow(a,b) → a 的 b 次方

System.out.println(Math.pow(2,3)); //8.0  2³

8）Math.sqrt(数字) → 开平方

System.out.println(Math.sqrt(16)); //4.0

4. Math.random () 随机数

生成 0.0 ~ 1.0 之间的随机小数

double d = Math.random();

想生成 1~100 整数：

int num = (int)(Math.random() * 100) + 1;

9.8.2 BigInteger 类（java.math，超大整数，超出 long 范围时使用）

long 最大值：9223372036854775807，超过只能用 BigInteger，支持加减乘除取模

import java.math.BigInteger;

public class TestBigInt {

    public static void main(String[] args) {

        BigInteger a = new BigInteger("9999999999999999999999");

        BigInteger b = new BigInteger("2");

        // 运算，返回新BigInteger对象

        BigInteger add = a.add(b); //加

        BigInteger sub = a.subtract(b); //减

        BigInteger mul = a.multiply(b); //乘

        BigInteger div = a.divide(b); //除

        System.out.println(add);

    }}

9.8.3 Random 类（java.util，生成伪随机数，比 Math.random 灵活）

import java.util.Random;

public class TestRandom {

    public static void main(String[] args) {

        Random r = new Random();

        // 随机int（正负都有）

        System.out.println(r.nextInt());

        // 0~9随机整数 [0,10)

        System.out.println(r.nextInt(10));

        // 1~10随机整数

        System.out.println(r.nextInt(10)+1);

        // 随机小数 [0,1)

        System.out.println(r.nextDouble());

        // 随机布尔

        System.out.println(r.nextBoolean());

    }}

固定种子 Random (100)：每次运行随机序列完全相同，用于测试复现。

1. nextInt(数字) → 生成 0 ~ 数字 - 1 的随机整数

r.nextInt(10);   // 0 ~ 9

r.nextInt(3);    // 0 ~ 2

2. 想生成 1 ~ 10 怎么办？

int num = r.nextInt(10) + 1;

公式：

plaintext

r.nextInt(最大值) + 1

3. nextDouble() → 0.0 ~ 1.0 之间随机小数

double d = r.nextDouble();

4. nextBoolean() → 随机 true /false

boolean b = r.nextBoolean();