Java基础十八（正则表达式 + 日期时间）-Toy模板网

这篇具有很好参考价值的文章主要介绍了Java基础十八（正则表达式 + 日期时间）。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

1. 正则表达式

1.1 普通字符

字符	描述	示例
[abc]	匹配 […] 中所有字符	`[hlo] 匹配字符串 "hello world" 中所有的 h l o 字母`
[^ABC]	匹配除了 […] 中所有字符	`[hlo] 匹配字符串 "hello world" 中除了 h l o 的所有字母`
[^a-z]	匹配除了 […] 中所有字符	`[hlo] 匹配字符串 "hello world" 中除了 a 到 z 的所有字母`
[A-Z]	[A-Z] 表示一个区间，匹配所有的大写字母	`[A-Z] 匹配字符串 "Hello world" 结果为 H`

1.2 特殊字符

字符	描述	示例
.	匹配任意单个字符，除了换行符	`a.b`、`1.2`
*	匹配前一个字符零次或多次	`gogle`、`colour`
+	匹配前一个字符一次或多次	`go+gle`、`colou+r`
?	匹配前一个字符零次或一次	`colou?r`、`col(o)?r`
\|	表示“或”的意思，用于匹配多个选项中的一个	`apple\|orange`、`yes\|no`
[]	用于定义字符类，匹配方括号内的任意一个字符	`[aeiou]`、`[0-9]`
()	用于分组，可以改变默认的优先级和应用限定符	`(go)+`、`(abc\|def)`
$	匹配输入字符串的结尾位置，如果设置了 RepExp 对象的 Multiline 属性，则 $ 也匹配‘\n’或‘\r’	…
{	标记限定表达式的开始	…
\|	指明两项直接的一个选择	…

1.3 非打印字符

字符	描述	示例
\n	匹配换行符	`Hello\nWorld`
\r	匹配回车符	`Hello\rWorld`
\t	匹配制表符	`Hello\tWorld`
\v	匹配垂直制表符	`Hello\vWorld`
\s	匹配任意空白字符，包括空格、制表符、换页符等	`Hello World`
\S	匹配任意非空白字符，不包括换行	我暂时不知道
\d	匹配任意数字字符，相当于 [0-9]	`12345`、`9am`
\w	匹配任意字母、数字或下划线字符，相当于 [a-zA-Z0-9_]	`hello_world_123`

1.4 限定符

字符	描述	示例
*	匹配前一个字符零次或多次	`gogle`、`colour`
+	匹配前一个字符一次或多次	`go+gle`、`colou+r`
?	匹配前一个字符零次或一次	`colou?r`、`col(o)?r`
{n}	匹配前一个字符恰好出现 n 次	`go{2}gle`、`colou{3}r`
{n,}	匹配前一个字符至少出现 n 次	`go{2,}gle`、`colou{3,}r`
{n,m}	匹配前一个字符出现 n 到 m 次	`go{2,5}gle`、`colou{3,7}r`

1.5 定位符

字符	描述	示例
^	匹配字符串的开头	`^Hello`、`^[A-Z]`
$	匹配字符串的结尾	`World$`、`[0-9]$`
\b	匹配单词的边界	`\btest\b`、`\bword\b`
\B	匹配非单词边界	`\Btest\B`、`\Bword\B`

2. 日期时间

2.1 Date 类方法

Date类位于 java.util 包中，用于表示特定的时间点。

方法	描述
`getTime()`	返回自 1970 年 1 月 1 日 00:00:00 GMT 以来的毫秒数。
`toString()`	将日期对象转换为字符串形式。
`compareTo(Date anotherDate)`	比较两个日期的顺序。返回值为 0 表示相等，大于 0 表示当前日期在参数日期之后，小于 0 表示当前日期在参数日期之前。
`equals(Object obj)`	检查该日期对象是否等于另一个日期对象。
`before(Date when)`	检查当前日期是否在指定日期之前。
`after(Date when)`	检查当前日期是否在指定日期之后。
`setTime(long time)`	设置日期对象的时间值。

例题1 : Date使用

public class DateDemo01 {
    public static void main(String[] args) {
        // 创建一个表示当前时间的 Date 对象
        Date date = new Date();
        System.out.println(date);   // Thu Aug 24 22:35:10 CST 2023
        // 获取 Date 对象的时间（毫秒数）
         long timeInMillis = date.getTime();
        System.out.println(timeInMillis);  // 1692887710157
        // 创建一个指定时间的 Date 对象
        Date specifiedDate = new Date(1640886000000L);
        System.out.println(specifiedDate);  // Fri Dec 31 01:40:00 CST 2021
        // 比较两个 Date 对象的时间
        boolean isBefore = date.before(specifiedDate);
        boolean isEquals = date.equals(specifiedDate);
        boolean isAfter = date.after(specifiedDate);
        System.out.println(isBefore);  // false
        System.out.println(isEquals);  // false
        System.out.println(isAfter);  // true
    }
}

2.2 Calendar 类方法

Calender 类是 java 中用于处理日期和时间的类，位于 java.util 包中。它提供了一种比 Date 类更灵活和功能更强大的日期和时间操作方式。

方法	描述
`getTime()`	返回一个表示此 Calendar 时间值（从历元到现在毫秒偏移量）的 Date 对象。
`get(int field)`	返回给定日历字段的值。
`set(int field, int value)`	设置给定日历字段的值。
`add(int field, int amount)`	根据日历的规则，将指定的时间量添加到给定日历字段。
`roll(int field, int amount)`	根据日历的规则，将给定的时间量添加到给定日历字段，但不更改较大的字段值。
`getActualMaximum(int field)`	返回指定日历字段的最大值。
`getActualMinimum(int field)`	返回指定日历字段的最小值。
`getDisplayName(int field, int style, Locale locale)`	返回给定字段值的本地化表示名称。
`getFirstDayOfWeek()`	返回一个代表每周的第一天的值。
`setFirstDayOfWeek(int value)`	设置一星期中的第一天是哪一天。
`getMinimum(int field)`	返回给定日历字段的最小值。
`getMaximum(int field)`	返回给定日历字段的最大值。

例题2 : Calender使用

import java.util.Calendar;
import java.util.Date;

public class CalenderDemo01 {
    public static void main(String[] args) {
        // 获取当前时间和日期的 Calender 对象
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);  // java.util.GregorianCalendar[time=1692889224235,areFieldsSet=true,···]
        // 设置日期为指定的年份、月份和日 1970年2月1日
        calendar.set(1970, 1, 1);
        System.out.println(calendar);  // java.util.GregorianCalendar[time=?,areFieldsSet=false,areAllField···]
        // 获取年份
        int year = calendar.get(Calendar.YEAR);
        System.out.println(year);  // 1970
        // 获取月份(月份从 0 开始计数)
        int month = calendar.get(Calendar.MONTH) + 1;
        System.out.println(month);  // 2
        // 获取当前月份中的第几天
        int dayOfMonth = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(dayOfMonth);  // 1
        // 月份加 1
        calendar.add(Calendar.MONTH, 1);
        // 输出修改过后的月份
        System.out.println(calendar.getTime());  // Sun Mar 01 23:00:24 CST 1970
        // 将 Calender 转换为 Date 对象
        Date date = calendar.getTime();
        System.out.println(date);  // Sun Mar 01 23:00:24 CST 1970
    }
}

Calender 和 Date 相互转换

import java.util.Calendar;
import java.util.Date;

public class CalenderDeom02 {
    // 创建一个 Calender 对象
    public static void main(String[] args) {
        Calendar calendar = Calendar.getInstance();
        // 设置日期为指定的日期
        calendar.set(1970, 0, 1);
        // 获取当前的日期和时间
        Date date = calendar.getTime();
        System.out.println(date);  // Thu Jan 01 23:25:45 CST 1970
        // 将 Calender 转换为 Date
        Date convertedDate = calendar.getTime();
        System.out.println(convertedDate);  // Thu Jan 01 23:25:45 CST 1970
        // 创建一个新的 Date 对象
        Date newDate = new Date(70, 1, 1);
        // 将 Date 转换为 Calender 
        Calendar convertedCalender = Calendar.getInstance();
        convertedCalender.setTime(newDate);
        System.out.println(convertedCalender);  // java.util.GregorianCalendar[time=2649600000,areFieldsSet=true,areAllFieldsSet=true...
    }
}

请注意，尽管 Date 类和 Calendar 类仍然存在于 Java 中，但在 Java 8 及更高版本中，推荐使用新版的日期时间类（如 LocalDate、LocalTime、LocalDateTime）来替代旧版的 Date 和 Calendar 类，因为新版的类更加简洁、易用，并且线程安全。

2.3 SimpleDateFormat 类方法

SimpleDateFormat 类是 Java 中用于日期和时间格式化的类，它位于 java.text 包中。它允许将 Date 对象格式化为指定的日期和时间字符串，或将日期和时间字符串解析为 Date 对象。

方法	描述
`SimpleDateFormat(String pattern)`	使用指定的日期模式创建一个 `SimpleDateFormat` 对象。
`String format(Date date)`	将给定的 `Date` 对象格式化为字符串，使用 `SimpleDateFormat` 的日期模式。
`Date parse(String source)`	将给定的字符串解析为 `Date` 对象，使用 `SimpleDateFormat` 的日期模式。
`void setLenient(boolean lenient)`	设置解析过程是否宽松，即是否严格遵循日期格式。
`String toPattern()`	返回当前日期模式。
`void applyPattern(String pattern)`	使用给定的日期模式更新当前日期模式。
`DateFormatSymbols getDateFormatSymbols()`	获取与该日期格式化程序相关联的 `DateFormatSymbols` 对象，用于获取或设置本地化信息（如月名、星期几名等）。
`void setDateFormatSymbols(DateFormatSymbols newFormatSymbols)`	设置与该日期格式化程序相关联的 `DateFormatSymbols` 对象，用于设置本地化信息（如月名、星期几名等）。

例题3 ：SimpleDateFormatExample使用

import java.text.SimpleDateFormat;
import java.util.Date;

public class SimpleDateFormatExample {
    public static void main(String[] args) {
        Date date = new Date();
        // 创建 SimpleDateFormat 对象，并指定格式化模式,默认2023/8/25 上午10:59
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd a HH:mm:ss:SSS");
        // 格式化 Date 对象为字符串
        String formatDate = sdf.format(date);
        System.out.println(formatDate);  // 2023-08-25 上午 11:02:59:178
        // 解析字符串为 Date 对象
        String dateString = "1949-10-01 下午 3:30:45:123";
        try {
            Date parsedDate = sdf.parse(dateString);
            System.out.println(parsedDate);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

2.4 LocalDate 类方法

LocalDate 是 Java 中的一个日期类，它提供了处理日期的方法和功能。LocalDate 类位于 java.time 包中，从 JDK 8 引入。LocalDate 是不可变类型，final 修饰储存值的数组。

方法	描述
`static LocalDate now()`	返回当前日期。
`static LocalDate of(int year, int month, int dayOfMonth)`	根据指定的年、月、日创建一个 `LocalDate` 对象。
`int getYear()`	获取日期中的年份。
`Month getMonth()`	获取日期中的月份，返回一个 `Month` 枚举对象。
`int getDayOfMonth()`	获取日期中的月份中的天数。
`DayOfWeek getDayOfWeek()`	获取日期中的星期几，返回一个 `DayOfWeek` 枚举对象。
`LocalDate plusDays(long daysToAdd)`	返回当前日期加上指定天数后的日期。
`LocalDate minusDays(long daysToSubtract)`	返回当前日期减去指定天数后的日期。
`boolean isBefore(LocalDate other)`	检查当前日期是否在另一个日期之前。
`boolean isAfter(LocalDate other)`	检查当前日期是否在另一个日期之后。
`boolean isEqual(LocalDate other)`	检查当前日期是否等于另一个日期。
`String format(DateTimeFormatter formatter)`	将日期格式化为指定的字符串格式。

例题4 : LocalDate使用

import java.time.LocalDate;
import java.time.Month;
import java.time.format.DateTimeFormatter;

public class LocalDateDemo01 {
    public static void main(String[] args) {
        // 创建 LocalDate 对象
        LocalDate today = LocalDate.now();  // 当前日期创建对象
        System.out.println(today);  // 2023-08-25
        LocalDate specificDate = LocalDate.of(1970, 1, 1);  // 指定日期创建对象
        System.out.println("specificDate" + specificDate);  // 1970-01-01
        // 解析字符串为 LocalDate 对象
        LocalDate parseDate = LocalDate.parse("1949-10-01");
        System.out.println("parseDate" + parseDate);  // 1949-10-01

        // 获取日期信息
        int year = today.getYear();
        System.out.println("年份" + year);  // 年份2023
        Month month = today.getMonth();
        System.out.println("月份" + month);  // AUGUST
        int mon = today.getMonthValue();
        System.out.println("月份" + mon);  // 8
        int day = today.getDayOfYear();  // 一年中的第几天
        System.out.println(day);  // 237
        int day1 = today.getDayOfMonth();  // 当月的第多少天
        System.out.println(day1);  // 25

        // 增加、减少日期
        LocalDate futureDate = specificDate.plusDays(7);
        System.out.println("增加日期:" + futureDate);  // 增加日期:1970-01-08
        LocalDate pastDate = specificDate.minusMonths(1);
        System.out.println("减少日期:" + pastDate);  // 减少日期:1969-12-01

        // 判定日期关系
        boolean isBefore = specificDate.isBefore(parseDate);
        System.out.println(isBefore);  // false
        boolean isAfter = specificDate.isAfter(parseDate);
        System.out.println(isAfter);  // true
        boolean isEqual = specificDate.isEqual(parseDate);
        System.out.println(isEqual);  // false

        // 格式化日期
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        String fomattedDate = specificDate.format(formatter);
        System.out.println("格式化后的日期" + fomattedDate);  // 格式化后的日期1970-01-01
    }
}

Date 和 LocalDate 相互转换

import java.time.LocalDate;
import java.time.ZoneId;
import java.util.Date;

public class DateLocalDateConversionExample {
    public static void main(String[] args) {
        //将Date对象转换为LocalDate对象
        Date date = new Date();
        LocalDate localDate = dateToLocalDate(date);
        System.out.println(localDate);
        // 将LocalDate对象转换为Date对象
        LocalDate localDate1 = LocalDate.of(1970, 1, 1);
        Date convertedDate = localDatetoDate(localDate1);
        System.out.println(convertedDate);
    }

    // 将LocalDate对象转换为Date对象
    private static Date localDatetoDate(LocalDate localDate1) {
        ZoneId zoneId = ZoneId.systemDefault();
        return Date.from(localDate1.atStartOfDay(zoneId).toInstant());
    }

    // 将Date对象转换为LocalDate对象
    private static LocalDate dateToLocalDate(Date date) {
        ZoneId zoneId = ZoneId.systemDefault();
        return date.toInstant().atZone(zoneId).toLocalDate();
    }
}

2.5 LocalTime 类方法

LocalTime 是 Java 中的一个时间类，它提供了处理时间的方法和功能。LocalDate 类位于 java.time 包中，从 JDK 8 引入。LocalTime 是不可变类型，final 修饰储存值的数组。

方法	描述
`static LocalTime now()`	返回当前时间。
`static LocalTime of(int hour, int minute)`	根据指定的小时和分钟创建一个 `LocalTime` 对象。
`int getHour()`	获取时间中的小时数。
`int getMinute()`	获取时间中的分钟数。
`int getSecond()`	获取时间中的秒数。
`LocalTime plusHours(long hoursToAdd)`	返回当前时间加上指定小时数后的时间。
`LocalTime minusHours(long hoursToSubtract)`	返回当前时间减去指定小时数后的时间。
`LocalTime plusMinutes(long minutesToAdd)`	返回当前时间加上指定分钟数后的时间。
`LocalTime minusMinutes(long minutesToSubtract)`	返回当前时间减去指定分钟数后的时间。
`LocalTime plusSeconds(long secondsToAdd)`	返回当前时间加上指定秒数后的时间。
`LocalTime minusSeconds(long secondsToSubtract)`	返回当前时间减去指定秒数后的时间。
`boolean isBefore(LocalTime other)`	检查当前时间是否在另一个时间之前。
`boolean isAfter(LocalTime other)`	检查当前时间是否在另一个时间之后。
`boolean isEqual(LocalTime other)`	检查当前时间是否等于另一个时间。
`String format(DateTimeFormatter formatter)`	将时间格式化为指定的字符串格式。

例题5 : LocalTime使用

import java.time.LocalTime;
import java.time.format.DateTimeFormatter;

public class LocalTimeDemo01 {
    public static void main(String[] args) {
        // 创建 LocalTime 对象
        LocalTime now = LocalTime.now();
        System.out.println("当前时间" + now);  // 当前时间19:56:31.828827500
        LocalTime specificTime = LocalTime.of(14, 30);
        System.out.println("指定时间" + specificTime);  // 指定时间14:30
        // 解析字符串为 loCalTime 对象
        LocalTime parsedTime = LocalTime.parse("08:45:30");
        System.out.println("解析后的时间" + parsedTime);  // 解析后的时间08:45:30

        // 获取时间信息
        int hour = now.getHour();
        System.out.println("小时数" + hour);  // 小时数19
        int minute = now.getMinute();
        System.out.println("分钟数" + minute);  // 分钟数56
        int second = now.getSecond();
        System.out.println("秒数" + second);  // 秒数31

        // 增加、减少时间
        LocalTime futureTime = now.plusHours(3);
        System.out.println("未来时间:" + futureTime);  // 未来时间:22:56:31.828827500
        LocalTime pastTime = now.minusMinutes(15);
        System.out.println("过去时间:" + pastTime);  // 过去时间:19:41:31.828827500

        // 判定时间关系
        boolean isBefore = now.isBefore(specificTime);
        System.out.println(isBefore);  // false
        boolean isEqusl = pastTime.equals(futureTime);
        System.out.println(isEqusl);  // false
        boolean isAfter = pastTime.isAfter(futureTime);
        System.out.println(isAfter);  // false

        // 格式化时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH:mm:ss");
        String formattedTime = now.format(formatter);
        System.out.println(formattedTime);  // 19:56:31
    }
}

在判定日期时间关系中，日期是否相等为 isEqual() ，时间为 equals() 。

2.6 LocalDateTime 类方法

LocalDateTime 是 Java 中的一个日期时间类，LocalDate 类位于 java.time 包中，从 JDK 8 引入。它结合了 LocalDate 和 LocalTime 的功能，用于表示日期和时间的组合。

方法	描述
`static LocalDateTime now()`	返回当前日期和时间。
`static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute)`	根据指定的年、月、日、小时和分钟创建一个 `LocalDateTime` 对象。
`LocalDate toLocalDate()`	获取 `LocalDateTime` 对象中的日期部分，返回一个 `LocalDate` 对象。
`LocalTime toLocalTime()`	获取 `LocalDateTime` 对象中的时间部分，返回一个 `LocalTime` 对象。
`int getYear()`	获取日期时间中的年份。
`Month getMonth()`	获取日期时间中的月份，返回一个 `Month` 枚举对象。
`int getDayOfMonth()`	获取日期时间中的月份中的天数。
`int getHour()`	获取时间中的小时数。
`int getMinute()`	获取时间中的分钟数。
`LocalDateTime plusDays(long daysToAdd)`	返回当前日期时间加上指定天数后的日期时间。
`LocalDateTime minusDays(long daysToSubtract)`	返回当前日期时间减去指定天数后的日期时间。
`LocalDateTime plusHours(long hoursToAdd)`	返回当前日期时间加上指定小时数后的日期时间。
`LocalDateTime minusHours(long hoursToSubtract)`	返回当前日期时间减去指定小时数后的日期时间。
`LocalDateTime plusMinutes(long minutesToAdd)`	返回当前日期时间加上指定分钟数后的日期时间。
`LocalDateTime minusMinutes(long minutesToSubtract)`	返回当前日期时间减去指定分钟数后的日期时间。
`LocalDateTime plusSeconds(long secondsToAdd)`	返回当前日期时间加上指定秒数后的日期时间。
`LocalDateTime minusSeconds(long secondsToSubtract)`	返回当前日期时间减去指定秒数后的日期时间。
`boolean isBefore(LocalDateTime other)`	检查当前日期时间是否在另一个日期时间之前。
`boolean isAfter(LocalDateTime other)`	检查当前日期时间是否在另一个日期时间之后。
`boolean isEqual(LocalDateTime other)`	检查当前日期时间是否等于另一个日期时间。
`String format(DateTimeFormatter formatter)`	将日期时间格式化为指定的字符串格式。

例题6 : LocalDateTime使用文章来源地址https://www.toymoban.com/news/detail-680429.html

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class LocalDateTimeDemo {
    public static void main(String[] args) {
        // 创建 LocalDateTime 对象
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime specificDateTime = LocalDateTime.of(1949, 10, 1, 14, 20);
        System.out.println("指定日期时间" + specificDateTime);  // 指定日期时间1949-10-01T14:20
        // 解析字符串为 LocalDateTime 对象
        LocalDateTime parsedDateTime = LocalDateTime.parse("1970-01-01T09:00:00");
        System.out.println("解析后的日期时间" + parsedDateTime);  // 解析后的日期时间1970-01-01T09:00
        // 获取日期时间信息
        LocalDate date = specificDateTime.toLocalDate();
        System.out.println("日期部分" + date);  // 日期部分1949-10-01
        int year = specificDateTime.getYear();
        System.out.println("年份" + year);  // 年份1949
        int minute = specificDateTime.getMinute();
        System.out.println("分钟数" + minute);  // 分钟数20

        // 减少、增加日期时间
        LocalDateTime futureDateTime = specificDateTime.plusDays(7).plusHours(3);
        System.out.println("增加日期时间" + futureDateTime);  // 增加日期时间1949-10-08T17:20
        // 判定日期时间关系
        boolean isEqual = parsedDateTime.isEqual(specificDateTime);
        System.out.println(isEqual);  // false
        // 格式化日期时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss:SSS");
        String formattedDateTime = parsedDateTime.format(formatter);
        System.out.println("格式化后的日期时间为" + formattedDateTime);  // 格式化后的日期时间为1970-01-01 09:00:00:000
    }
}