Java SE 常用工具类：String 与日期时间处理

1.2 字符串存储原理

public static void main(String[] args) {
    String string1 = "Hello World";
    String string2 = "Hello World";
    String string3 = new String("Hello World");
    System.out.println(string1 == string2); // true
    System.out.println(string1 == string3); // false
}

字符串常量池：是 Java 中用于优化字符串存储和性能的一种机制，旨在通过共享字符串字面量来节省内存并提高性能。实际是一个固定大小的 HashTable（一种高效用来进行查找的数据结构）。

字符串常量池的工作原理：

• 字面量创建：当你在代码中使用字符串字面量（例如 "Hello World"）时，Java 会首先检查字符串常量池中是否已经存在相同的字符串。如果存在，则直接返回池中字符串的引用；如果不存在，则在池中创建一个新的字符串对象。
• 使用 new 关键字创建字符串：当你使用 new 关键字创建字符串对象时，Java 会创建一个新的字符串实例，即使字符串常量池中已经存在相同的字符串。

1.3 字符串常用方法介绍

1.3.1 字符串的比较

• 1. 使用 == 进行比较：对于基本类型，比较的是变量中的值；对于引用类型比较的是引用中的地址。

public static void main(String[] args) {
    int a = 1;
    int b = 1;
    int c = 2;
    System.out.println(a == b); // true
    System.out.println(a == c); // false

    String string1 = new String("Hello World");
    String string2 = new String("Hello World");
    System.out.println(string1 == string2); // false
}

• 2. 使用 equals 方法进行比较：Object 中 equals 默认按照 == 比较；String 重写 equals 方法后按照字典序比较，相同返回 true，不同返回 false。

public static void main(String[] args) {
    String string1 = new String("Hello World");
    String string2 = new String("Hello World");
    String string3 = new String("hello world");
    System.out.println(string1.equals(string2)); // true
    System.out.println(string1.equals(string3)); // false
}

• 3. 使用 compareTo 方法进行比较
  • 逐字符比较：从两个字符串的第一个字符开始，逐个字符进行比较。比较字符的 Unicode 值（即字符的整数值）。如果在某个位置上的字符不同，则返回两个字符的 Unicode 值之差。
  • 长度比较：如果所有对应字符都相同，但其中一个字符串比另一个字符串长，则返回两个字符串长度之差。

public static void main(String[] args) {
    String string1 = new String("Hello World");
    String string2 = new String("Hello World");
    String string3 = new String("hello world");
    String string4 = new String("Hello");
    System.out.println(string1.compareTo(string2)); // 返回 0
    System.out.println(string1.compareTo(string3)); // 返回 -32, 'H' - 'h'
    System.out.println(string1.compareTo(string4)); // 返回 6, string1 比 string4 长 6 个字符
}

1.3.2 字符串的查找

• char charAt(int index)：返回 index 下标的字符，如果 index 为负数或者越界，抛出 StringIndexOutOfBoundsException 异常。

public static void main(String[] args) {
    String string = "0123456789";
    System.out.println(string.charAt(0)); // 0
    // System.out.println(string.charAt(100)); // StringIndexOutOfBoundsException
    // System.out.println(string.charAt(-1)); // StringIndexOutOfBoundsException
}

• int indexOf(int ch)：返回指定字符在字符串中第一次出现的索引位置。如果字符未在字符串中找到，则返回 -1。参数以 Unicode 代码点（int 类型）形式传入。

public static void main(String[] args) {
    String string = "HelloWorld"; // H 的 Unicode 值：72
    System.out.println(string.indexOf(72)); // 返回 H 的下标 0
    System.out.println(string.indexOf(1)); // 返回 -1
}

• int indexOf(int ch, int fromIndex)：从 fromIndex 下标开始，返回指定字符在字符串中第一次出现的索引位置。如果字符未在字符串中找到，则返回 -1。参数以 Unicode 代码点（int 类型）形式传入。

public static void main(String[] args) {
    String string = "HelloHello"; // H 的 Unicode 值：72
    System.out.println(string.indexOf(72, 3)); // 返回第二个 H 的下标 5
}

• int indexOf(String str)：返回指定字符在字符串中第一次出现的索引位置。如果字符未在字符串中找到，则返回 -1。

public static void main(String[] args) {
    String string = "HelloWorld";
    System.out.println(string.indexOf("H")); // 返回 H 的下标 0
    System.out.println(string.indexOf('H')); // 返回 H 的下标 0
    System.out.println(string.indexOf("Z")); // 返回 -1
    System.out.println(string.indexOf('Z')); // 返回 -1
}

• int indexOf(String str, int fromIndex)：从 fromIndex 下标开始，返回指定字符在字符串中第一次出现的索引位置。如果字符未在字符串中找到，则返回 -1。

public static void main(String[] args) {
    String string = "HelloHello";
    System.out.println(string.indexOf("H", 3)); // 返回第二个 H 的下标 5
}

1.3.3 字符串转换

• valueOf：将不同的数据类型转换为字符串。

public static void main(String[] args) {
    String string1 = String.valueOf(10);
    System.out.println(string1); // 10
    String string2 = String.valueOf(10.0);
    System.out.println(string2); // 10.0
    String string3 = String.valueOf(true);
    System.out.println(string3); // true
}

• 字符串转换为其他数据类型。

public static void main(String[] args) {
    int data1 = Integer.parseInt("12345");
    System.out.println(data1); // 12345
    double data2 = Double.parseDouble("12345.0");
    System.out.println(data2); // 12345.0
    boolean data3 = Boolean.parseBoolean("true");
    System.out.println(data3); // true
}

• String toUpperCase()：将字符串中的所有字符转换为大写形式。
• String toLowerCase()：将字符串中的所有字符转换为小写形式。

public static void main(String[] args) {
    String string1 = "Hello World";
    System.out.println(string1.toLowerCase()); // hello world
    String string2 = "Hello World";
    System.out.println(string2.toUpperCase()); // HELLO WORLD
}

• char[] toCharArray()：将字符串转换为字符数组。

public static void main(String[] args) {
    String string = "Hello World";
    char[] array = string.toCharArray();
    for (char c : array) {
        System.out.print(c + " ");
    }
    // 输出结果：H e l l o W o r l d
    System.out.println();
}

• static String format(String format, Object... args)：通过格式化字符串和可变参数生成格式化后的字符串输出。

public static void main(String[] args) {
    String name = "Alice";
    int age = 30;
    String result1 = String.format("Name: %s, Age: %d", name, age);
    System.out.println(result1); // Name: Alice, Age: 30
    String result2 = String.format("%d-%d-%d", 2025, 6, 12);
    System.out.println(result2); // 2025-6-12
}

1.3.4 字符串替换

public static void main(String[] args) {
    String string = "Hello World";
    String string1 = string.replaceAll("l", "_");
    System.out.println(string1); // He__o Wor_d
    String string2 = string.replaceFirst("l", "_");
    System.out.println(string2); // He_lo World
}

1.3.5 字符串拆分

正则表达式 (Regular Expression，简称 regex 或 regexp)：是一种用于匹配字符串中字符模式的强大工具。它广泛应用于文本搜索、替换、验证和数据提取等场景。正则表达式由一系列字符和特殊符号组成，这些符号定义了搜索模式。

1. 基本语法

• 普通字符：匹配自身。例如，a 匹配字符 "a"
• 元字符：具有特殊含义的字符，如 .、*、+、?、^、$、[]、()、{}、| 等

2. 常用元字符

• . (点)：匹配除换行符之外的任何单个字符。示例：a.b 匹配 "aab"、"acb"、"a3b" 等
• ^ (脱字符)：匹配字符串的开始。示例：^Hello 匹配以 "Hello" 开头的字符串
• $ (美元符)：匹配字符串的结束。示例：world$ 匹配以 "world" 结尾的字符串
• [] (方括号)：定义一个字符集，匹配其中任意一个字符。示例：[abc] 匹配 "a"、"b" 或 "c"。范围表示法：[a-z] 匹配任意小写字母，[0-9] 匹配任意数字。否定：[^abc] 匹配除 "a"、"b"、"c" 之外的任意字符
• | (竖线)：表示'或'关系。示例：cat|dog 匹配 "cat" 或 "dog"
• () (圆括号)：用于分组，可以提取子匹配或应用量词。示例：(ab)+ 匹配一个或多个连续的 "ab"
• 量词：
  • *：匹配前面的表达式零次或多次。示例：ab*c 匹配 "ac"、"abc"、"abbbc" 等
  • +：匹配前面的表达式一次或多次。示例：ab+c 匹配 "abc"、"abbbc" 等，但不匹配 "ac"
  • ?：匹配前面的表达式零次或一次。示例：ab?c 匹配 "ac" 或 "abc"
  • {n}：匹配前面的表达式恰好 n 次。示例：a{3} 匹配 "aaa"
  • {n,}：匹配前面的表达式至少 n 次。示例：a{2,} 匹配 "aa"、"aaa"、"aaaa" 等
  • {n,m}：匹配前面的表达式至少 n 次，但不超过 m 次。示例：a{2,3} 匹配 "aa"、"aaa"

public static void main(String[] args) {
    String string1 = "Hello World";
    String[] array1 = string1.split(" ");
    for (String s : array1) {
        System.out.println(s);
    }
    // Hello
    // World

    String string2 = "Hello World Hello World";
    String[] array2 = string2.split(" ", 2);
    for (String s : array2) {
        System.out.println(s);
    }
    // Hello
    // World Hello World
}

1.3.6 字符串截取

public static void main(String[] args) {
    String string = "Hello World";
    String substring1 = string.substring(1); // [1,end)
    System.out.println(substring1); // ello World
    String substring2 = string.substring(1, 2); // [1,2)
    System.out.println(substring2); // e
}

1.3.7 去除空格

• String trim()：用于去除字符串两端的空白字符。

public static void main(String[] args) {
    String string = " Hello World ";
    String trim = string.trim();
    System.out.println("[" + trim + "]"); // [Hello World]
}

1.3.8 intern 方法

• native String intern()：用于将字符串对象动态添加到字符串常量池中，并返回池中的唯一引用。调用 intern() 时，JVM 会检查常量池中是否存在内容相同的字符串：
  • 若存在，直接返回池中对象的引用
  • 若不存在，将当前字符串对象添加到池中，并返回其引用

1.4 字符串的不可变性

字符串的不可变性：指 String 对象一旦创建，其内容就无法更改。任何看似修改字符串的操作 (如拼接、替换) 实际上都会创建新的 String 对象。

不可变性的实现原理：String 类内部使用 private final 修饰的 byte 数组 存储数据，且不提供修改该数组的方法。

1.5 StringBuilder&StringBuffer

public static void main(String[] args) {
    String string = "Hello";
    string = string + "World";
    System.out.println(string); // 输出 Hello World
}

在上述代码中，s + " world" 创建了一个新的 String 对象，而原的 "Hello" 对象保持不变。对于 String 的拼接来说，如果是在循环当中会产生很多的临时对象。此时 Java 提供了 StringBuilder 和 StringBuffer。

public static void main(String[] args) {
    // String
    long start = System.currentTimeMillis();
    String string = "";
    for (int i = 0; i < 10000; i++) {
        string = string + i;
    }
    long end = System.currentTimeMillis();
    System.out.println(end - start); // 输出结果在 60 左右

    // StringBuilder
    start = System.currentTimeMillis();
    StringBuilder stringBuilder = new StringBuilder("");
    for (int i = 0; i < 10000; i++) {
        stringBuilder.append(i);
    }
    end = System.currentTimeMillis();
    System.out.println(end - start); // 输出结果不超过 2
}

可以看到在对 String 类进行拼接时，效率是非常慢。因此：如果要修改建议尽量使用 StringBuilder 或者 StringBuffer。

String：String 对象是不可变的，任何修改操作（如拼接、替换）都会生成新的 String 对象，原对象不变。适用于字符串内容不频繁变化的场景，因不可变性带来线程安全性。频繁修改 String 会导致大量临时对象，影响性能。

StringBuilder：StringBuilder 同样是可变的字符序列，修改操作直接在原对象上进行。非线程安全，无同步开销，单线程环境下性能最优。

StringBuffer：StringBuffer 是可变的字符序列，修改操作直接在原对象上进行。线程安全，所有方法使用 synchronized 关键字修饰，适合多线程环境。性能略低于 StringBuilder，因同步开销。

2. 日期类

2.1 Date 类

Java 中的 Date 类位于 java.util 包中，用于表示特定的时间点，精确到毫秒。它是 Java 早期版本中处理日期和时间的主要类，但在 Java 8 之后，推荐使用 java.time 包中的新日期时间 API(LocalDateTime 类)，因为 Date 类存在设计缺陷和线程安全问题。

public class Date_Demo {
    public static void main(String[] args) {
        Date date1 = new Date(); // 不带参数的构造方法表示获取当前时间
        System.out.println(date1); // Fri Jun 13 20:09:22 CST 2025

        Date date2 = new Date(125, 5, 13); // 参数一：Date 默认的时间是从 1900 年开始计算的，这里的 125 会和 1900 加得到 2025，用来确定年份
                                        // 参数二：2 代表 3 月，也就是说 0 代表 1 月，1 代表 2 月，以此类推
                                        // 参数三：代表实际的日期
        System.out.println(date2); // Fri Jun 13 00:00:00 CST 2025
    }
}

• CST：表示时区。

Date 类已经过时了，下面重点介绍 LocalDateTime 类。

2.2 LocalDateTime 类

2.2.1 概述

LocalDateTime 是 Java8 引入的日期时间 API(java.time 包) 中的一个类，用于表示不带时区的日期和时间 (即本地日期时间)。它结合了 LocalDate 和 LocalTime 的功能，适用于不需要时区信息的场景。

2.2.2 创建 LocalDateTime 对象

LocalDateTime 类的构造方法使用 private 修饰，无法通过 new 关键字来实例化对象。

• 1. now() 方法：获取当前的日期和时间。
• 2. of() 方法：指定年、月、日、时、分等参数创建对象。

public static void main(String[] args) {
    LocalDateTime time1 = LocalDateTime.now();
    System.out.println(time1); // 2025-06-13T22:58:00.587917400
    LocalDateTime time2 = LocalDateTime.of(2025, 6, 13, 22, 57);
    System.out.println(time2); // 2025-06-13T22:57
}

• 3. LocalDate 和 LocalTime 组合：将 LocalDate 和 LocalTime 对象组合成 LocalDateTime。

public static void main(String[] args) {
    LocalDate date = LocalDate.now();
    LocalTime time = LocalTime.now();
    LocalDateTime dateTime = LocalDateTime.of(date, time);
    System.out.println(dateTime); // 2025-06-13T23:01:00.030160400
}

• 4. parse() 方法：解析符合 ISO-8601 格式的字符串。

public static void main(String[] args) {
    LocalDateTime parsedDateTime = LocalDateTime.parse("2026-06-13T23:03:00");
    System.out.println(parsedDateTime); // 2026-06-13T23:03
}

• 5. ofPattern() 方法：由 DateTimeFormatter 类提供，用于创建一个自定义的日期时间格式。可以将 LocalDateTime 对象格式化为字符串，或者将字符串解析为 LocalDateTime 对象。

public static void main(String[] args) {
    String stringDate = "2026-06-13 23:03:10";
    // 创建一个自定义的日期时间格式化器
    DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    // 1. 解析字符串为 LocalDateTime
    LocalDateTime dateTime = LocalDateTime.parse(stringDate, formatter);
    System.out.println(dateTime); // 2026-06-13T23:03:10
    // 2. 格式化 LocalDateTime 为字符串
    String stringTime = dateTime.format(formatter);
    System.out.println(stringTime); // 2026-06-13 23:03:10
}

2.2.3 获取年月日时分秒

public static void main(String[] args) {
    LocalDateTime time = LocalDateTime.now();
    // 获取年
    int year = time.getYear();
    // 获取月
    int month1 = time.getMonthValue();
    Month month2 = time.getMonth();
    // 获取日
    int day = time.getDayOfMonth();
    // 获取时
    int hour = time.getHour();
    // 获取分
    int minute = time.getMinute();
    // 获取秒
    int second = time.getSecond();
    System.out.println(year); // 2025
    System.out.println(month1); // 6
    System.out.println(month2); // JUNE
    System.out.println(day); // 13
    System.out.println(hour); // 23
    System.out.println(minute); // 7
    System.out.println(second); // 10
}

2.2.4 获取具体详细信息

public static void main(String[] args) {
    LocalDate date = LocalDate.now();
    System.out.println(date); // 2025-06-13
    // 本周第几天
    int dayOfWeek = date.getDayOfWeek().getValue();
    System.out.println(dayOfWeek); // 5, 表示星期五
    // 本月第几天
    int dayOfMonth = date.getDayOfMonth();
    System.out.println(dayOfMonth); // 13
    // 今年第几天
    int dayOfYear = date.getDayOfYear();
    System.out.println(dayOfYear); // 164
}

2.2.5 日期运算

• 1. 加/减天数

public static void main(String[] args) {
    LocalDateTime date = LocalDateTime.now();
    System.out.println("当前日期：" + date);
    LocalDateTime date1 = date.plusDays(1);
    System.out.println("增加一天后的日期：" + date1);
    LocalDateTime date2 = date.minusDays(1);
    System.out.println("减少一天后的日期：" + date2);
}

• 2. 加/减周数

public static void main(String[] args) {
    LocalDateTime date = LocalDateTime.now();
    System.out.println("当前日期：" + date);
    LocalDateTime date1 = date.plusWeeks(1);
    System.out.println("增加一周后的日期：" + date1);
    LocalDateTime date2 = date.minusWeeks(1);
    System.out.println("减少一周后的日期：" + date2);
}

• 3. 加/减月数

public static void main(String[] args) {
    LocalDateTime date = LocalDateTime.now();
    System.out.println("当前日期：" + date);
    LocalDateTime date1 = date.plusMonths(1);
    System.out.println("增加一月后的日期：" + date1);
    LocalDateTime date2 = date.minusMonths(1);
    System.out.println("减少一月后的日期：" + date2);
}

• 4. 加/减年数

public static void main(String[] args) {
    LocalDateTime date = LocalDateTime.now();
    System.out.println("当前日期：" + date);
    LocalDateTime date1 = date.plusYears(1);
    System.out.println("增加一年后的日期：" + date1);
    LocalDateTime date2 = date.minusYears(1);
    System.out.println("减少一年后的日期：" + date2);
}

2.2.6 根据当前时间获取指定时间

• 获取当前日期所在周的周日和周一

public static void main(String[] args) {
    LocalDateTime curDate = LocalDateTime.now();
    System.out.println("当前日期：" + curDate);
    LocalDateTime firstDayOfWeek = curDate.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
    System.out.println("这周的周一：" + firstDayOfWeek);
    LocalDateTime lastDayOfWeek = curDate.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));
    System.out.println("这周的周天：" + lastDayOfWeek);
}

previousOrSame：寻找当前日期或之前最近的指定星期几 nextOrSame：寻找当前日期或之后最近的指定星期几

• 获取当前日期所在月的第一天和最后一天的日期

public static void main(String[] args) {
    LocalDateTime curDate = LocalDateTime.now();
    System.out.println("当前日期：" + curDate);
    LocalDateTime firstDayOfMonth = curDate.with(TemporalAdjusters.firstDayOfMonth());
    System.out.println("本月的第一天：" + firstDayOfMonth);
    LocalDateTime lastDayOfMonth = curDate.with(TemporalAdjusters.lastDayOfMonth());
    System.out.println("本月的最后一天：" + lastDayOfMonth);
}