Java 核心 API 速查：数组、String、日期时间与 BigDecimal | 星雨笔录

JavaSE 基础阶段高频核心知识速查。 JDK：21 范围：数组、二维数组、`Arrays`、`String`、`StringBuilder`、`java.time`、`BigDecimal`

1. 数组 Array

1.1 核心概念

数组是固定长度、存储同一种类型数据、通过下标访问元素的容器。

int[] arr = {10, 20, 30};

核心特征：

下标从 0 开始。
最后一个下标是 arr.length - 1。
创建后长度不可改变。
基本数据类型数组存储值。
引用数据类型数组存储对象引用。
根据下标访问元素：O(1)。
中间插入、删除通常需要移动元素：O(n)。

2. 数组创建

2.1 静态初始化

int[] arr = new int[]{1, 2, 3, 4};

简化写法：

int[] arr = {1, 2, 3, 4};

2.2 动态初始化

int[] arr = new int[5];

默认值：

类型	默认值
`byte short int long`	`0`
`float double`	`0.0`
`char`	`'\u0000'`
`boolean`	`false`
引用类型	`null`

3. 数组基本操作

3.1 获取元素

int value = arr[0];

3.2 修改元素

arr[0] = 100;

3.3 获取长度

int length = arr.length;

length 是数组的字段，不是方法。

3.4 普通遍历

for (int i = 0; i < arr.length; i++) {
    System.out.println(arr[i]);
}

3.5 增强 for

for (int value : arr) {
    System.out.println(value);
}

适合：只读取元素。

4. 数组常用算法

求和

int sum = 0;

for (int value : arr) {
    sum += value;
}

最大值

int max = arr[0];

for (int value : arr) {
    if (value > max) {
        max = value;
    }
}

最小值

int min = arr[0];

for (int value : arr) {
    if (value < min) {
        min = value;
    }
}

平均值

double average = (double) sum / arr.length;

方差

double variance = 0;

for (int value : arr) {
    variance += (value - average) * (value - average);
}

variance /= arr.length;

数组反转

for (int left = 0, right = arr.length - 1;
     left < right;
     left++, right--) {

    int temp = arr[left];
    arr[left] = arr[right];
    arr[right] = temp;
}

元素交换

int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;

顺序查找

int index = -1;

for (int i = 0; i < arr.length; i++) {
    if (arr[i] == target) {
        index = i;
        break;
    }
}

时间复杂度：

O(n)

中位数

先排序。

奇数个元素：

median = arr[arr.length / 2];

偶数个元素：

median = (arr[arr.length / 2 - 1] + arr[arr.length / 2]) / 2.0;

众数

核心思想：

统计每个元素出现次数
→ 找出现次数最多的元素

后续学习 HashMap 后推荐使用：

Map<Integer, Integer>

统计频率。

5. 二维数组

二维数组本质：

数组里面存数组

声明：

int[][] arr;

静态初始化：

int[][] arr = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
};

动态初始化：

int[][] arr = new int[3][4];

访问：

arr[0][1];

修改：

arr[0][1] = 100;

行数：

arr.length

某一行长度：

arr[0].length

二维数组遍历

for (int i = 0; i < arr.length; i++) {
    for (int j = 0; j < arr[i].length; j++) {
        System.out.println(arr[i][j]);
    }
}

增强 for：

for (int[] row : arr) {
    for (int value : row) {
        System.out.println(value);
    }
}

6. Arrays 数组工具类

包：

import java.util.Arrays;

Arrays 是操作数组的核心工具类，主要提供排序、查找、复制、比较、填充和输出等静态方法。

必须掌握 API

方法类型	方法	返回值	参数	作用
static	`Arrays.toString(arr)`	`String`	一维数组	将一维数组转为可读字符串
static	`Arrays.deepToString(arr)`	`String`	多维数组	输出多维数组
static	`Arrays.sort(arr)`	`void`	数组	对数组排序
static	`Arrays.sort(arr, from, to)`	`void`	数组、起点、终点	排序指定区间
static	`Arrays.binarySearch(arr, key)`	`int`	有序数组、目标值	二分查找
static	`Arrays.copyOf(arr, len)`	新数组	原数组、新长度	复制数组
static	`Arrays.copyOfRange(arr, from, to)`	新数组	原数组、区间	复制指定区间
static	`Arrays.fill(arr, value)`	`void`	数组、值	批量填充
static	`Arrays.equals(a, b)`	`boolean`	两个数组	比较一维数组内容
static	`Arrays.deepEquals(a, b)`	`boolean`	两个多维数组	比较多维数组内容
static	`Arrays.setAll(arr, generator)`	`void`	数组、生成规则	根据索引批量设置元素

示例

int[] arr = {5, 1, 4, 2, 3};

System.out.println(Arrays.toString(arr));

Arrays.sort(arr);

System.out.println(Arrays.toString(arr));

int index = Arrays.binarySearch(arr, 4);

System.out.println(index);

int[] copy = Arrays.copyOf(arr, 3);

System.out.println(Arrays.toString(copy));

7. 数组综合案例

import java.util.Arrays;

public class ArrayDemo {

    public static void main(String[] args) {

        int[] nums = {7, 2, 9, 4, 2, 6};

        int sum = 0;
        int max = nums[0];
        int min = nums[0];

        for (int num : nums) {
            sum += num;

            if (num > max) {
                max = num;
            }

            if (num < min) {
                min = num;
            }
        }

        double average = (double) sum / nums.length;

        double variance = 0;

        for (int num : nums) {
            variance += (num - average) * (num - average);
        }

        variance /= nums.length;

        int[] sorted = Arrays.copyOf(nums, nums.length);

        Arrays.sort(sorted);

        double median;

        if (sorted.length % 2 == 1) {
            median = sorted[sorted.length / 2];
        } else {
            median =
                    (sorted[sorted.length / 2 - 1]
                    + sorted[sorted.length / 2]) / 2.0;
        }

        System.out.println("原数组：" + Arrays.toString(nums));
        System.out.println("排序后：" + Arrays.toString(sorted));
        System.out.println("和：" + sum);
        System.out.println("最大值：" + max);
        System.out.println("最小值：" + min);
        System.out.println("平均值：" + average);
        System.out.println("中位数：" + median);
        System.out.println("方差：" + variance);
    }
}

8. String 字符串

8.1 核心概念

String 是不可变字符序列。

String str = "Hello";

所谓不可变：

String str = "Hello";

str.replace("H", "J");

原来的 str 仍然是：

Hello

必须接收返回值：

str = str.replace("H", "J");

9. String 创建

10. String 必须掌握 API

10.1 长度与字符

类型	方法	返回值	参数	作用
实例	`length()`	`int`	无	获取字符串长度
实例	`charAt(index)`	`char`	索引	获取指定位置字符
实例	`toCharArray()`	`char[]`	无	转换成字符数组
实例	`isEmpty()`	`boolean`	无	判断长度是否为 0
实例	`isBlank()`	`boolean`	无	判断是否为空或只有空白字符

10.2 字符串比较

类型	方法	返回值	参数	作用
实例	`equals(obj)`	`boolean`	对象	比较字符串内容
实例	`equalsIgnoreCase(str)`	`boolean`	字符串	忽略大小写比较
实例	`compareTo(str)`	`int`	字符串	按字典顺序比较
实例	`compareToIgnoreCase(str)`	`int`	字符串	忽略大小写字典比较

10.3 查找

类型	方法	返回值	参数	作用
实例	`contains(s)`	`boolean`	字符序列	是否包含指定内容
实例	`indexOf(str)`	`int`	字符串	第一次出现的位置
实例	`indexOf(str, from)`	`int`	内容、起点	从指定位置查找
实例	`lastIndexOf(str)`	`int`	字符串	最后一次出现位置
实例	`startsWith(prefix)`	`boolean`	前缀	是否以指定内容开头
实例	`endsWith(suffix)`	`boolean`	后缀	是否以指定内容结尾

没有找到：

indexOf(...)

-1

10.4 截取与修改

类型	方法	返回值	参数	作用
实例	`substring(begin)`	`String`	起始位置	从指定位置截取到末尾
实例	`substring(begin, end)`	`String`	起点、终点	截取指定区间
实例	`replace(old, new)`	`String`	原内容、新内容	替换内容
实例	`replaceAll(regex, replacement)`	`String`	正则、新内容	正则批量替换
实例	`replaceFirst(regex, replacement)`	`String`	正则、新内容	替换第一个匹配项

区间统一：

[begin, end)

即：

左闭右开

10.5 分割与拼接

类型	方法	返回值	参数	作用
实例	`split(regex)`	`String[]`	正则表达式	分割字符串
static	`String.join(delimiter, elements...)`	`String`	分隔符、内容	拼接多个字符串
实例	`concat(str)`	`String`	字符串	拼接字符串

例如：

String[] arr = "Java,MySQL,Spring".split(",");

10.6 大小写与空白字符

类型	方法	返回值	参数	作用
实例	`toUpperCase()`	`String`	无	转大写
实例	`toLowerCase()`	`String`	无	转小写
实例	`trim()`	`String`	无	去除首尾传统空白字符
实例	`strip()`	`String`	无	去除首尾 Unicode 空白字符

现代 Java 优先：

strip()

10.7 转换

类型	方法	返回值	参数	作用
static	`String.valueOf(value)`	`String`	任意常见数据	转字符串
实例	`getBytes()`	`byte[]`	无	转换为字节数组
实例	`toCharArray()`	`char[]`	无	转字符数组

推荐明确字符集：

str.getBytes(StandardCharsets.UTF_8);

10.8 其他高频 API

类型	方法	返回值	作用
实例	`repeat(count)`	`String`	重复字符串
实例	`matches(regex)`	`boolean`	正则匹配
static	`String.format(format, args...)`	`String`	格式化字符串
实例	`formatted(args...)`	`String`	使用当前字符串作为格式模板

11. String 综合案例

public class StringDemo {

    public static void main(String[] args) {

        String text = "  Java,MySQL,Spring Boot  ";

        text = text.strip();

        System.out.println(text);
        System.out.println(text.length());

        System.out.println(text.contains("Java"));
        System.out.println(text.startsWith("Java"));
        System.out.println(text.endsWith("Boot"));

        int index = text.indexOf("MySQL");

        System.out.println(index);

        String[] technologies = text.split(",");

        for (String technology : technologies) {
            System.out.println(technology);
        }

        String result = text
                .replace("Java", "JavaSE")
                .toUpperCase();

        System.out.println(result);
    }
}

12. StringBuilder 可变字符串

12.1 核心概念

StringBuilder 是可修改的字符序列。

适合：

大量字符串拼接、插入、删除、反转

单线程场景通常优先使用 StringBuilder。

13. StringBuilder 创建

空对象：

StringBuilder sb = new StringBuilder();

指定字符串：

StringBuilder sb = new StringBuilder("Hello");

指定初始容量：

StringBuilder sb = new StringBuilder(100);

14. StringBuilder 必须掌握 API

类型	方法	返回值	参数	作用
实例	`append(value)`	`StringBuilder`	内容	尾部追加
实例	`insert(index, value)`	`StringBuilder`	索引、内容	指定位置插入
实例	`delete(start, end)`	`StringBuilder`	区间	删除指定区间
实例	`deleteCharAt(index)`	`StringBuilder`	索引	删除指定字符
实例	`replace(start, end, str)`	`StringBuilder`	区间、内容	替换指定区间
实例	`setCharAt(index, ch)`	`void`	索引、字符	修改指定字符
实例	`reverse()`	`StringBuilder`	无	反转
实例	`length()`	`int`	无	获取字符数量
实例	`capacity()`	`int`	无	获取当前容量
实例	`charAt(index)`	`char`	索引	获取字符
实例	`substring(start, end)`	`String`	区间	截取内容
实例	`toString()`	`String`	无	转为 String

典型链式调用：

String result = new StringBuilder()
        .append("Java")
        .append("-")
        .append("Spring")
        .reverse()
        .toString();

15. 日期时间 API

Java 8 之后核心日期时间 API 位于：

java.time

核心类：

LocalDate
LocalTime
LocalDateTime
DateTimeFormatter
Period
Duration

16. LocalDate

表示：

年月日

不包含：

时分秒、时区

例如：

2026-09-09

必须掌握 API

类型	方法	返回值	参数	作用
static	`LocalDate.now()`	`LocalDate`	无	当前日期
static	`LocalDate.of(y,m,d)`	`LocalDate`	年月日	创建日期
static	`LocalDate.parse(text)`	`LocalDate`	字符串	解析日期
实例	`getYear()`	`int`	无	年
实例	`getMonthValue()`	`int`	无	月
实例	`getDayOfMonth()`	`int`	无	日
实例	`getDayOfYear()`	`int`	无	一年中的第几天
实例	`getDayOfWeek()`	`DayOfWeek`	无	星期
实例	`plusYears(n)`	`LocalDate`	年数	增加年份
实例	`plusMonths(n)`	`LocalDate`	月数	增加月份
实例	`plusDays(n)`	`LocalDate`	天数	增加天数
实例	`minusYears(n)`	`LocalDate`	年数	减少年份
实例	`minusMonths(n)`	`LocalDate`	月数	减少月份
实例	`minusDays(n)`	`LocalDate`	天数	减少天数
实例	`withYear(y)`	`LocalDate`	年	修改年份
实例	`withMonth(m)`	`LocalDate`	月	修改月份
实例	`withDayOfMonth(d)`	`LocalDate`	日	修改日
实例	`isBefore(date)`	`boolean`	日期	是否更早
实例	`isAfter(date)`	`boolean`	日期	是否更晚
实例	`isEqual(date)`	`boolean`	日期	日期是否相等
实例	`format(formatter)`	`String`	格式器	格式化

17. LocalTime

表示：

时分秒

例如：

10:30:20

必须掌握 API

类型	方法	返回值	作用
static	`LocalTime.now()`	`LocalTime`	当前时间
static	`LocalTime.of(h,m)`	`LocalTime`	创建时间
static	`LocalTime.of(h,m,s)`	`LocalTime`	创建时间
static	`LocalTime.parse(text)`	`LocalTime`	解析时间
实例	`getHour()`	`int`	小时
实例	`getMinute()`	`int`	分钟
实例	`getSecond()`	`int`	秒
实例	`plusHours(n)`	`LocalTime`	增加小时
实例	`plusMinutes(n)`	`LocalTime`	增加分钟
实例	`plusSeconds(n)`	`LocalTime`	增加秒
实例	`minusHours(n)`	`LocalTime`	减少小时
实例	`minusMinutes(n)`	`LocalTime`	减少分钟
实例	`minusSeconds(n)`	`LocalTime`	减少秒
实例	`withHour(h)`	`LocalTime`	修改小时
实例	`withMinute(m)`	`LocalTime`	修改分钟
实例	`withSecond(s)`	`LocalTime`	修改秒
实例	`isBefore(time)`	`boolean`	是否更早
实例	`isAfter(time)`	`boolean`	是否更晚
实例	`format(formatter)`	`String`	格式化

18. LocalDateTime

表示：

年月日 + 时分秒

例如：

2026-09-09T10:30:20

创建

LocalDateTime.now();

LocalDateTime.of(
        2026,
        9,
        9,
        10,
        30,
        20
);

高频 API

LocalDateTime 基本同时具有 LocalDate 与 LocalTime 的能力：

getYear()
getMonthValue()
getDayOfMonth()

getHour()
getMinute()
getSecond()

plusYears()
plusMonths()
plusDays()
plusHours()
plusMinutes()
plusSeconds()

minusYears()
minusMonths()
minusDays()
minusHours()
minusMinutes()
minusSeconds()

withYear()
withMonth()
withDayOfMonth()
withHour()
withMinute()
withSecond()

isBefore()
isAfter()
isEqual()

format()

19. DateTimeFormatter

包：

java.time.format.DateTimeFormatter

作用：

日期时间 ↔ 字符串

创建格式器

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

日期时间 → String

String text = dateTime.format(formatter);

String → 日期时间

LocalDateTime dateTime =
        LocalDateTime.parse(text, formatter);

高频格式字符

字符	含义
`yyyy`	年
`MM`	月
`dd`	日
`HH`	24 小时制小时
`mm`	分钟
`ss`	秒

典型格式：

yyyy-MM-dd

HH:mm:ss

yyyy-MM-dd HH:mm:ss

20. Period

用于计算：

日期之间的年月日间隔

例如：

LocalDate start = LocalDate.of(2025, 1, 1);
LocalDate end = LocalDate.of(2026, 9, 9);

Period period = Period.between(start, end);

高频 API

类型	方法	返回值	作用
static	`Period.between(start,end)`	`Period`	计算两个日期差
实例	`getYears()`	`int`	获取年差
实例	`getMonths()`	`int`	获取月差
实例	`getDays()`	`int`	获取日差

21. Duration

用于计算：

时间之间的持续时间

例如：

LocalTime start = LocalTime.of(10, 0);
LocalTime end = LocalTime.of(12, 30);

Duration duration = Duration.between(start, end);

高频 API

类型	方法	返回值	作用
static	`Duration.between(start,end)`	`Duration`	计算时间间隔
实例	`toDays()`	`long`	转天
实例	`toHours()`	`long`	转小时
实例	`toMinutes()`	`long`	转分钟
实例	`getSeconds()`	`long`	获取总秒数

记忆：

Period → 年月日

Duration → 时分秒

22. BigDecimal 精确小数计算

包：

java.math.BigDecimal

核心用途：

金额、财务、精确小数计算

double：

System.out.println(0.1 + 0.2);

可能得到：

0.30000000000000004

精确十进制运算使用：

BigDecimal

23. BigDecimal 创建

24. BigDecimal 必须掌握 API

类型	方法	返回值	参数	作用
实例	`add(value)`	`BigDecimal`	BigDecimal	加
实例	`subtract(value)`	`BigDecimal`	BigDecimal	减
实例	`multiply(value)`	`BigDecimal`	BigDecimal	乘
实例	`divide(value)`	`BigDecimal`	BigDecimal	除
实例	`divide(value,scale,mode)`	`BigDecimal`	除数、位数、舍入模式	精确控制除法
实例	`setScale(scale,mode)`	`BigDecimal`	位数、舍入规则	设置小数位
实例	`compareTo(value)`	`int`	BigDecimal	比较数值
实例	`max(value)`	`BigDecimal`	BigDecimal	最大值
实例	`min(value)`	`BigDecimal`	BigDecimal	最小值
实例	`abs()`	`BigDecimal`	无	绝对值
实例	`negate()`	`BigDecimal`	无	相反数
实例	`pow(n)`	`BigDecimal`	次数	幂运算
实例	`toPlainString()`	`String`	无	普通字符串表示

25. BigDecimal 四则运算

加

BigDecimal result = a.add(b);

减

BigDecimal result = a.subtract(b);

乘

BigDecimal result = a.multiply(b);

除

26. BigDecimal 比较

不要主要依赖：

a == b

数值比较使用：

a.compareTo(b)

返回值：

< 0    a < b

= 0    a == b

> 0    a > b

例如：

if (a.compareTo(b) > 0) {
    System.out.println("a 大于 b");
}

27. 高频注意事项

数组

数组下标范围：

0 ~ length - 1

越界：

arr[arr.length]

会产生：

ArrayIndexOutOfBoundsException

数组长度创建后不可修改。
arr.length 是字段：

arr.length

不是：

arr.length()

Arrays.sort() 会直接修改原数组。
Arrays.binarySearch() 使用前必须保证数组按照相同规则有序。
copyOfRange()：

[from, to)

左闭右开。

二维数组每一行长度可以不同：

int[][] arr = {
        {1, 2},
        {3, 4, 5},
        {6}
};

28. String 注意事项

String 不可变：

str.replace(...)
str.substring(...)
str.toUpperCase()

都会返回新的 String。

必须接收返回值：

str = str.replace("a", "b");

比较字符串内容：

equals()

不要使用：

==

== 比较的是引用是否相同。

substring(begin,end)：

[begin, end)

indexOf() 找不到返回：

-1

split() 参数是正则表达式。

例如按点号分割：

split("\\.")

不能直接：

split(".")

字符串长度：

str.length()

数组长度：

arr.length

29. StringBuilder 注意事项

StringBuilder 可变。
高频操作：

append
insert
delete
replace
reverse

最终需要字符串：

toString()

单线程字符串拼接优先：

StringBuilder

多线程需要同步可考虑：

StringBuffer

30. 日期时间注意事项

LocalDate、LocalTime、LocalDateTime 都是不可变对象。

例如：

LocalDate date = LocalDate.now();

date.plusDays(1);

date 没变。

正确：

date = date.plusDays(1);

LocalDate：

年月日

LocalTime：

时分秒

LocalDateTime：

年月日 + 时分秒

三者都不保存真正的时区信息。

涉及跨时区系统时进一步学习：

ZoneId
ZonedDateTime
Instant

日期之间的年月日差：

Period

时间持续长度：

Duration

格式化：

DateTimeFormatter

格式字符串注意大小写：

MM → 月
mm → 分钟

HH → 24 小时制小时

31. BigDecimal 注意事项

精确十进制常量优先：

new BigDecimal("0.1")

不要：

new BigDecimal(0.1)

也可以：

BigDecimal.valueOf(0.1)

BigDecimal 同样不可变：

a.add(b);

不会修改 a。

正确：

a = a.add(b);

除法可能出现无限循环小数。

例如：

1 / 3

需要指定精度：

a.divide(
        b,
        2,
        RoundingMode.HALF_UP
);

数值大小比较优先：

compareTo()

equals() 不只比较数值，还会考虑 scale。

例如：

new BigDecimal("1.0")
new BigDecimal("1.00")

数值比较：

a.compareTo(b) == 0

结果为：

true

32. 最终必须形成的知识结构

Java 高频基础数据处理
│
├── 数组
│   ├── 创建
│   ├── 下标
│   ├── length
│   ├── 遍历
│   ├── 查找
│   ├── 交换
│   ├── 反转
│   ├── 排序
│   ├── 统计
│   └── 二维数组
│
├── Arrays
│   ├── toString
│   ├── deepToString
│   ├── sort
│   ├── binarySearch
│   ├── copyOf
│   ├── copyOfRange
│   ├── fill
│   └── equals
│
├── String
│   ├── length
│   ├── charAt
│   ├── equals
│   ├── substring
│   ├── contains
│   ├── indexOf
│   ├── replace
│   ├── split
│   ├── startsWith
│   ├── endsWith
│   ├── strip
│   └── toCharArray
│
├── StringBuilder
│   ├── append
│   ├── insert
│   ├── delete
│   ├── replace
│   ├── reverse
│   └── toString
│
├── java.time
│   ├── LocalDate
│   ├── LocalTime
│   ├── LocalDateTime
│   ├── DateTimeFormatter
│   ├── Period
│   └── Duration
│
└── BigDecimal
    ├── add
    ├── subtract
    ├── multiply
    ├── divide
    ├── setScale
    ├── compareTo
    └── RoundingMode

33. 当前阶段掌握标准

这部分不要求背下所有 API。

达到下面标准即可进入下一阶段：

看到需求
↓
知道应该使用哪个类
↓
知道核心方法名称
↓
知道参数大致是什么
↓
知道返回什么
↓
可以借助 IDEA 自动补全写出代码
↓
常用 API 使用数次后自然记住

真正需要做到不用查就能写出的第一优先级：

arr.length
arr[i]

Arrays.toString()
Arrays.sort()
Arrays.binarySearch()

String.length()
String.charAt()
String.equals()
String.substring()
String.contains()
String.indexOf()
String.replace()
String.split()

StringBuilder.append()
StringBuilder.reverse()
StringBuilder.toString()

LocalDate.now()
LocalDate.of()

LocalDateTime.now()
LocalDateTime.of()

DateTimeFormatter.ofPattern()

BigDecimal.add()
BigDecimal.subtract()
BigDecimal.multiply()
BigDecimal.divide()
BigDecimal.compareTo()

其余 API：

知道存在
+
需要时能够查到
+
实际使用时逐渐形成记忆

这就是这一阶段最合理的掌握程度。