Java核心类库：数字、字符串、时间与格式化操作详解-优快云博客

本文链接：https://blog.youkuaiyun.com/csdn_muxin/article/details/117674328

Java常用类

Java类库：
数字相关类：
字符串相关类：
- String
- 可变字符串
时间相关类：
- Calendar
- time
格式化相关类

学习内容来自于mooc中华东师范大学课程Java核心技术。
Java类库文档：https://docs.oracle.com/javase/8/docs/api/

Java类库：

包名以Java开头的是Java核心包。
包名以Javax开头的是Java扩展包。

java.lang包是每个类都默认调用的。

数字相关类：

Java数字类：

整数 Short，Int，Long
浮点数 Float，Double
大数类 BigInteger， BIgDecimal
随机整数
工具类 Math

short 2字节默认值0
int 4字节默认值0
long 8字节默认值0L

float 4字节默认值0.0f
范围 1.40129846432481707e-45 ~ 3.40282346638528860e+38
double 8字节默认值0.0d
范围 4.94065645841246544e-d ~ 1.79769313486231570e+308d
两者都不能表示非常精确的数字

大整数类BigInteger

支持无限大的整数运算

样例：

public static void main(String[] args) {
        BigInteger b1 = new BigInteger("123456789");
        BigInteger b2 = new BigInteger("987654321");

        System.out.println("b1: " + b1 + ", b2：" + b2);
        System.out.println("加法: " + b2.add(b1));
        System.out.println("减法：" + b2.subtract(b1));
        System.out.println("乘法: " + b2.multiply(b1));
        System.out.println("除法：" + b2.divide(b1));
        System.out.println("最大值: " + b2.max(b1));
        System.out.println("最小值：" + b2.min(b1));

        BigInteger result[] = b2.divideAndRemainder(b1);
        System.out.println("商是： " + result[0] + "；余数是：" + result[1]);
        System.out.println("等价性是：" + b1.equals(b2));

        int flag = b1.compareTo(b2);
        if (flag == -1)
            System.out.println("b1 < b2");
        else if (flag == 0)
            System.out.println("b1 = b2");
        else
            System.out.println("b1 > b2");
    }

大浮点数BigDecimal

支持无限大的小数运算
注意精度和截断

样例：

public static void main(String[] args) {
        BigDecimal b1 = new BigDecimal("123456789.987654321");
        BigDecimal b2 = new BigDecimal("987654321.123456789");

        System.out.println("b1: "+ b1 + ", b2:" + b2);
        System.out.println("加法: " + b2.add(b1));
        System.out.println("减法：" + b2.subtract(b1));
        System.out.println("乘法: " + b2.multiply(b1));
        // 防止无限循环，需要指定位数，或者放在try-catch中
        System.out.println("除法：" + b2.divide(b1,10,BigDecimal.ROUND_HALF_UP)); 
        System.out.println("最大值: " + b2.max(b1));
        System.out.println("最小值：" + b2.min(b1));


        int flag = b1.compareTo(b2);
        if (flag == -1)
            System.out.println("b1 < b2");
        else if (flag == 0)
            System.out.println("b1 = b2");
        else
            System.out.println("b1 > b2");

        System.out.println(">>>>>>>>>>>>>>>>>>>>>>");
        
        // 尽量采用字符串赋值
        System.out.println(new BigDecimal("2.3"));
        System.out.println(new BigDecimal(2.3));

        System.out.println(">>>>>>>>>>>>>>>>>>>>>>");

        BigDecimal num1 = new BigDecimal("10");
        BigDecimal num2 = new BigDecimal("3");
        // 指定位数，防止无限循环，或者放在try-catch中
        BigDecimal num3 = num1.divide(num2, 3, BigDecimal.ROUND_HALF_UP);
        System.out.println(num3);
    }

输出：

b1: 123456789.987654321, b2:987654321.123456789
加法: 1111111111.111111110
减法：864197531.135802468
乘法: 121932632103337905.662094193112635269
除法：8.0000000099
最大值: 987654321.123456789
最小值：123456789.987654321
b1 < b2
>>>>>>>>>>>>>>>>>>>>>>
2.3
2.29999999999999982236431605997495353221893310546875
>>>>>>>>>>>>>>>>>>>>>>
3.333

随机数类

Random随机数：

nextInt() 返回一个随机int
nextInt(int a) 返回一个[0,a)之间的随机int
nextDoubla() 返回一个[0.0,1.0] 之间的double
ints 方法批量返回随机数数组

Math.random() 也会返回一个[0.0,1.0] 之间的double

例子：

public static void main(String[] args) {
        // 第一种方法，采用Random类随机生成int范围内的随机数
        Random rd = new Random();
        System.out.println(rd.nextInt());
        System.out.println(rd.nextInt(100)); // 0-100的随机数
        System.out.println(rd.nextLong());
        System.out.println(rd.nextDouble()); // 0.0-1.0之间的随机浮点数
        // System.out.println(rd.nextDouble(100)); // error nextDouble()不能有输入参数
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // 第二种办法，生成一个范围内的随机数
        // Math.random[0,1)
        System.out.println(Math.round(Math.random()*10)); // 0.0-1.0之间的随机浮点数 * 10 再取整，就是 0-10之间的随机整数
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        // JDK 8 新增办法
        rd.ints(); // 返回无限个int类型范围内的随机数
        rd.doubles(); // 返回无限个 0.0-1.0 内的随机浮点数
        int[] arr = rd.ints(10).toArray(); // 返回10个int类型范围内的随机数
        double[] arrD = rd.doubles(10).toArray(); // 返回10个 0.0-1.0 内的随机浮点数

        for (int i = 0; i < 10; i++){
            System.out.println(arr[i]);
            System.out.println(arrD[i]);
        }
        System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>");

        arr = rd.ints(5, 10, 100).toArray(); // 返回5个 10-100 内的随机数
        arrD = rd.doubles(5, 10, 100).toArray(); // 返回5个 10-100 内的随机浮点数
        for (int i = 0; i < 10; i++){
            System.out.println(arr[i]);
            System.out.println(arrD[i]);
        }

}

数字工具类

java.lang.Math

绝对值函数 abs
对数函数 log
比较函数 max、min
幂函数 pow
四舍五入函数 round 等
向下取整 floor
向上取整 ceil

字符串相关类：

String

String 是Java中使用频率最高的类。
是一个不可变对象，加减操作性能较差。

底层使用 private final char[] value，每次更新实际上就是更改地址

常用方法：

方法名	作用
charAt(idx)	返回索引 idx 处的字符
concat(str)	返回尾部连接了 str 的新字符串，原来的字符串不变
endsWith(str)	判断字符串是否以 str 结尾
equals(str)	判断字符串的内容是否和 str 相同
equalsIgnoreCase(str)	忽略大小写的情况下，判断字符串的内容是否和 str 相同
hashCode
indexOf (str)	返回第一个 str 在字符串的位置
length()	返回字符串长度
matches
replace(str1,str2)	返回原字符串中的 str1 都替换为 str2 的新字符串
replaceAll	返回原字符串中的 str1 都替换为 str2 的新字符串，其中 str1 是正则表达式规则
split(str)	返回原字符串按照 str 分割的数组
startsWith(str)	判断字符串是否以 str 开头
subString(b,e)	返回索引 b 到索引 e-1 的子串
trim()	返回去掉首尾空格的新字符串
valueOf(str/double/int)	返回 str/double/int 对应的字符串

实例：

public static void main(String[] args) {
        String a = "123;456;789;123 0 ";

        System.out.println(a.charAt(0)); // 返回第0个元素
        System.out.println(a.indexOf(";")); // 返回第一个 ; 的位置
        System.out.println(a.concat(";000")); // 连接一个新字符串 ;000 并返回，a 不变
        System.out.println(a.contains("000")); // 判断 a 是否包含 000
        System.out.println(a.endsWith("000")); // 判断 a 是否以 000 结尾
        System.out.println(a.equals("000")); // 判断 a 的字符串内容是否等于 000
        System.out.println(a.equalsIgnoreCase("000")); // 判断 a 在忽略大小写的情况下，字符串内容是否等于 000
        System.out.println(a.length()); // 返回 a 的字符串长度
        System.out.println(a.trim()); // 返回 a 取出前后空格后的字符串， a 不变

        String[] b = a.split(";"); // 将 a 的字符串按照 ; 分割成数组
        for (int i = 0; i < b.length; i++) {
            System.out.println(b[i]);
        }

        System.out.println(">>>>>>>>>>>>>>>>>");

        System.out.println(a.substring(2, 5)); // 截取 a 的第2个到第5个字符（不包含a[5]）， a 不变
        System.out.println(a.replace("1", "a"));  // 把 a 中的全部字符 1 替换为字符 a， a 不变
        System.out.println(a.replaceAll("1", "a")); // 把 a 中的全部字符 1 替换为字符 a， a 不变，这里第一个参数是正则表达式
        
        System.out.println(">>>>>>>>>>>>>>>>>");

        String s1 = "12345?6789";
        String s2 = s1.replace("?", ";");
        String s3 = s1.replaceAll("[?]", "a");
        // 这里的[?]在正则表达式中表示?，直接使用 ? 会出现异常，因为 ? 在正则表达式有特殊的意义
        System.out.println(s2);
        System.out.println(s3);
        System.out.println(s1.replaceAll("[\\d]", "a")); // 将s1 中所有数字字符替换为字符 a ，原字符串不变

    }

可变字符串

StringBuffer 适用于字符串加减，同步，性能好

底层使用char[] value，里面的值可以更改，不用每次更新地址，当需要扩容时更新地址

StringBuilder 适用于字符串加减，不同步，性能更好

StringBuffer/StringBuilder 方法（几乎一样，区别在同步）：

append/insert/delete/replace/substring
length字符串实际大小，capacity字符串占用空间大小
trimToSize(): 去处空隙，将字符串存储压缩到实际大小
如有大量append，事先预估大小再调用相应构造函数

样例：

public static void main(String[] args) {
        // StringBuffer的初始大小为（16+初始字符串长度）= capacity
        // length 实际长度 capacity 存储空间大小
        StringBuffer sb1 = new StringBuffer();

        System.out.println("sb1 length: " + sb1.length()); // 0
        System.out.println("sb1 capacity: " + sb1.capacity()); // 16
        System.out.println("》》》》》》》》》》》》》");
        
        StringBuffer sb2 = new StringBuffer("123");
        sb2.append("123");
        System.out.println("sb2 length: " + sb2.length()); // 6
        System.out.println("sb2 capacity: " + sb2.capacity()); // 19
        System.out.println("》》》》》》》》》》》》》");
        
        sb2.append("1890123456789");
        System.out.println("sb2 length: " + sb2.length()); // 19
        System.out.println("sb2 capacity: " + sb2.capacity()); // 19
        System.out.println("》》》》》》》》》》》》》");

        sb2.append("0");
        System.out.println("sb2 length: " + sb2.length()); // 20
        System.out.println("sb2 capacity: " + sb2.capacity()); // 40
        // 当length大于capacity时，capacity将会在前一次的基础上加 1 再翻倍
        System.out.println("》》》》》》》》》》》》》");
// 又添加了70个字符
        sb2.append("1234567890123456789012345678901234567890123456789012345678901234567890"); 
        System.out.println("sb2 length: " + sb2.length()); // 90
        System.out.println("sb2 capacity: " + sb2.capacity()); // 90
        // 如果append的对象很长，大于 加 1 再翻倍 的容量，则capacity会等于实际的长度
        System.out.println("》》》》》》》》》》》》》");

        sb2.append("0");
        System.out.println("sb2 length: " + sb2.length()); // 91
        System.out.println("sb2 capacity: " + sb2.capacity()); // 182
        // 当length大于capacity时，capacity将会在前一次的基础上加 1 再翻倍
        sb2.trimToSize();
        System.out.println("》》after trim 》》》》》");
        System.out.println("sb2 length: " + sb2.length()); // 91
        System.out.println("sb2 capacity: " + sb2.capacity()); // 91
  }

时间相关类：

java.util.Data 基本废弃
仅剩一个常用方法：
getTime()，返回自1970.1.1以来的毫秒数

java.sql.Data 和数据库对应的时间类

Calendar

目前最常用，不过是抽象类

Calendar cd = Calendar.getInstance(); 通过该句会获得它子类GregorianCalendar的对象
Calendar cd = new GregorianCalendar(); 和上句功能相同

样例：

public static void main(String[] args) {
        Calendar cd = Calendar.getInstance();
        System.out.println(cd.getClass().getName());
    }

输出结果：

java.util.GregorianCalendar

Calendar 存在的问题：

可变性：作为一个日期/时间类，应该是不可变的
偏移性：月份从 0 开始
格式化：无法格式化
不是线程安全的
不能处理闰秒（每隔 2 天，会多出 1s）

Calendar常用方法：

方法	功能
get(Field)	获取时间中每个属性的值，注意，月份0-11
getTime()	返回响应的Data对象
getTimeInMills()	返回自1970.1.1以来的毫秒数
set(Field)	设置时间字段
add(field, amount)	根据指定字段增加、减少时间
roll(field, amount)	根据指定字段增加、减少时间，但不影响上一级的时间段

样例：

import java.util.Calendar;

public class CalendarTest {
    Calendar calendar = Calendar.getInstance();

    public void test1() {
        // 获取年
        int year = calendar.get(Calendar.YEAR);
        // 获取月，这里返回的月份为0-11，所以需要加1
        int month = calendar.get(Calendar.MONTH) + 1;
        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        // 获取时
        int hour = calendar.get(Calendar.HOUR); // 12小时表示
        // int hour = calendar.get(Calendar.HOUR_OF_DAY); // 24小时表示
        // 获取分
        int minute = calendar.get(Calendar.MINUTE);
        // 获取秒
        int second = calendar.get(Calendar.SECOND);

        // 星期几,英语国家的星期从星期日开始计算
        int weekday = calendar.get(Calendar.DAY_OF_WEEK);
        
        System.out.println("现在是" + year + "年" + month + "月" + day + "日" + hour 
                            + "时" + minute + "分" + second + "秒" + "星期" + weekday);
    }

    // 一年后的今天
    public void test2() {
        // 同理,下个月的今天可以表示为 calendar.add(Calendar.MONTH, 1)
        calendar.add(Calendar.YEAR, 1);

         // 获取年
         int year = calendar.get(Calendar.YEAR);
         // 获取月，这里返回的月份为0-11，所以需要加1
         int month = calendar.get(Calendar.MONTH) + 1;
         // 获取日
         int day = calendar.get(Calendar.DAY_OF_MONTH);

         System.out.println("一年后的今天: " + year + "年" + month + "月" + day + "日");
    }


    // 获取一个月的最后一天
    public void test3() {
        // 假设求6月的最后一天
        int currentMonth = 6; // 6 就是 7月
        // 先求出7月份第一天,实际中这里6为外部传递进来的currentMonth变量
        // 1
        calendar.set(calendar.get(Calendar.YEAR), currentMonth, 1);

        calendar.add(Calendar.DATE, -1);

        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("6月份最后一天为: " + day + "号");
    }

    // 设置日期
    public void test4() {
        calendar.set(Calendar.YEAR, 2000);
        System.out.println("现在是" + calendar.get(Calendar.YEAR) + "年");

        calendar.set(2021, 6, 6);
        // 获取年
        int year = calendar.get(Calendar.YEAR);
        // 获取月，这里返回的月份为0-11，所以需要加1
        int month = calendar.get(Calendar.MONTH) + 1;
        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("现在是" + year + "年" + month + "月" + day + "日");
    }

    public void test5() {
        calendar.set(2021, 6, 6);
        calendar.add(Calendar.DAY_OF_MONTH, -6);

        // 获取年
        int year = calendar.get(Calendar.YEAR);
        // 获取月，这里返回的月份为0-11，所以需要加1
        int month = calendar.get(Calendar.MONTH) + 1;
        // 获取日
        int day = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("2021.7.6, 用add减少6天, 现在是" + year + "年" + month + "月" + day + "日");
        // 输出 2021.7.6, 用add减少6天, 现在是2021年6月30日

        calendar.set(2021, 6, 6);
        // roll函数做加减法, 只影响当前字段, 不影响进位
        calendar.roll(Calendar.DAY_OF_MONTH, -8);

        // 获取年
        year = calendar.get(Calendar.YEAR);
        // 获取月，这里返回的月份为0-11，所以需要加1
        month = calendar.get(Calendar.MONTH) + 1;
        // 获取日
        day = calendar.get(Calendar.DAY_OF_MONTH);

        System.out.println("2021.7.6, 用roll减少8天, 现在是" + year + "年" + month + "月" + day + "日");
        // 输出 2021.7.6, 用roll减少8天, 现在是2021年7月29日
    }


    public static void main(String[] args) {
        CalendarTest c = new CalendarTest();
        c.test1();
        System.out.println(">>>>>>>>>>>>>>>>>");
        c.test2();
        System.out.println(">>>>>>>>>>>>>>>>>");
        c.test3();
        System.out.println(">>>>>>>>>>>>>>>>>");
        c.test4();
        System.out.println(">>>>>>>>>>>>>>>>>");
        c.test5();
        System.out.println(">>>>>>>>>>>>>>>>>");
    }
}

输出：

现在是2021年6月9日10时22分7秒星期4
>>>>>>>>>>>>>>>>>
一年后的今天: 2022年6月9日
>>>>>>>>>>>>>>>>>
6月份最后一天为: 30号
>>>>>>>>>>>>>>>>>
现在是2000年
现在是2021年7月6日
>>>>>>>>>>>>>>>>>
2021.7.6, 用add减少6天, 现在是2021年6月30日
2021.7.6, 用roll减少8天, 现在是2021年7月29日
>>>>>>>>>>>>>>>>>

time

java.time包。
旧的设计有不好的地方，诸如重名类、线程不安全（Calendar）。
新版本优点：

不变性，适合在在多线程环境下使用
遵循设计模式，设计更好，扩展性更强

概述：

java.time包：新的Java日期/时间API的基础包
java.time.chrono包：为非ISO的日历系统定义了一些泛化的API
java.time.format包：格式化和解析日期时间对象的类
java.time.temporal包：包含一些时态对象，可以用其找出关于日期、时间对象的某个特定日期或时间
java.time.zone包：包含支持不同时区以及相关规则的类

重点关注java.time包，主要方法为：

LocalDate: 日期类
LocalTime: 时间类（时分秒-纳秒）
LocalDateTime: LocalDate + LocalTime
Instant: 时间戳

public static void main(String[] args) {
        
        LocalDate today = LocalDate.now();
        System.out.println("Current Date: " + today);

        LocalDate firstDay_2021 = LocalDate.of(2021, Month.JANUARY, 1);
        System.out.println("Specific Date: " + firstDay_2021);

        // 给定错误参数,将报异常java.time.DateTimeException
        // LocalDate feb30_2021 = LocalDate.of(2021, Month.FEBRUARY, 30);

        //可以更改时区
        LocalDate todayBeijing = LocalDate.now(ZoneId.of("Asia/Shanghai"));
        System.out.println("Current Date in ShangHai: " + todayBeijing);

        // 从1970.1.1开始365天
        LocalDate dateFromBase = LocalDate.ofEpochDay(365);
        System.out.println("365th day from Base Date: " + dateFromBase);

        // 2021的第100天
        LocalDate hundredDay2021 = LocalDate.ofYearDay(2021, 100);
        System.out.println("100th day of 2021: " + hundredDay2021);
    }

输出结果：

Current Date: 2021-06-09
Specific Date: 2021-01-01
Current Date in ShangHai: 2021-06-09
365th day from Base Date: 1971-01-01
100th day of 2021: 2021-04-10

下一个例子：

public static void main(String[] args) {
        
        LocalTime time = LocalTime.now();
        System.out.println("Current time: " + time);

        LocalTime specificTime = LocalTime.of(12, 20, 25, 40); // 时 分 秒 纳秒
        System.out.println("Specific time: " + specificTime);   

        LocalTime timeSH = LocalTime.now(ZoneId.of("Asia/Shanghai"));
        System.out.println("Current time in SH: " + timeSH);

        // 一天当中第几秒
        LocalTime specificSecond = LocalTime.ofSecondOfDay(10000);
        System.out.println("10000th second time: " + specificSecond);
    }

输出结果：

Current time: 11:07:09.459
Specific time: 12:20:25.000000040
Current time in SH: 11:07:09.461
10000th second time: 02:46:40

格式化相关类

用于字符串、数字类、时间类的格式化输出。
java.text.Format的子类：

NumberFormat、DecimalFormat：数字格式化，抽象类
MessageFormat：字符串格式化
DateFormat、SimpleDateFormat：日期/时间格式化，抽象类

JDK8推出的新的：java.time.format包：

DataTimeFormat

NumberFormat

DecimalFormat 工厂模式
将1234567格式化为1,234,567

public static void main(String[] args) {
        
        DecimalFormat df1,df2;
        
        System.out.println("整数部分为0情况下，0/#的区别");
        // 当整数为0，#无视掉整数部分，只显示 . 和小数部分
        df1 = new DecimalFormat("#.00");
        df2 = new DecimalFormat("0.00");

        System.out.println(df1.format(0.1));    // .10
        System.out.println(df2.format(0.1));    // 0.10

        System.out.println("小数部分0/#的区别");
        // 0代表有且仅有几位，#代表最多有几位
        df1 = new DecimalFormat("0.00");
        df2 = new DecimalFormat("0.##");

        System.out.println(df1.format(0.1));    // 0.10
        System.out.println(df2.format(0.1));    // 0.1

        System.out.println(df1.format(0.006));    // 0.01
        System.out.println(df2.format(0.006));    // 0.01

        System.out.println("整数部分有多位");
        // 0/#一样，有几位写几位
        df1 = new DecimalFormat("0.00");
        df2 = new DecimalFormat("#.00");

        System.out.println(df1.format(2));    // 2.00
        System.out.println(df2.format(2));    // 2.00

        System.out.println(df1.format(20));    // 20.00
        System.out.println(df2.format(20));    // 20.00

    }

public static void main(String[] args) {
        
        DecimalFormat df1 = new DecimalFormat("0.0");

        DecimalFormat df2 = new DecimalFormat("#.#");

        DecimalFormat df3 = new DecimalFormat("000.000");

        DecimalFormat df4 = new DecimalFormat("###.###");

        System.out.println(df1.format(12.34)); // 12.3

        System.out.println(df2.format(12.34)); // 12.3

        System.out.println(df3.format(12.34)); // 012.340

        System.out.println(df4.format(12.34)); // 12.34

        DecimalFormat df5 = new java.text.DecimalFormat("0.00"); // 保留两位小数，四舍五入

        double d1 = 123465789.123465;
        double d2 = 987654321.987654321;

        System.out.println("format1 d1=" + df5.format(d1));
        System.out.println("format1 d2=" + df5.format(d2));

        DecimalFormat df6 = new DecimalFormat("#,##0.00"); // 每三个数一个逗号

        System.out.println("format2 d1=" + df6.format(d1));
        System.out.println("format2 d2=" + df6.format(d2));
    }

MessageFormat

支持变量的自定义格式
将"Hello{1}"根据变量值格式化为Hello World
类似C语言printf

例子：

public static void main(String[] args) {
        // 字符串模板和字符串数组捆绑输出

        // 模板
        String message = "{0}{1}{2}{3}{4}{5}{6}{7}{8}{9}{10}{11}{12}{13}{14}{15}{16}";
        // 数组
        Object[] array = new Object[]{"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q"};

        String value = MessageFormat.format(message, array);

        System.out.println(value); //ABCDEFGHIJKLMNOPQ
        
        // 新模板
        message = "oh, {0,number,#.###} is a good number"; // {0,number,#.###} 0表示对应数组第0个元素，number表示该元素为数字，#.###表示格式
        
        array = new Object[]{new Double(3.1415)};

        value = MessageFormat.format(message, array);

        System.out.println(value); // oh, 3.142 is a good number
    }

DateFormat

simpleDateFormat 工厂模式
parse：将字符串格式化时间对象
format：将时间对象格式化为字符串
如将当前时间格式化为 YYYY-MM-DD HH24:MI:SS 输出

public static void main(String[] args) {
        
        String strDate = "2021-07-01 12:22:22.365";

        String pat1 = "yyyy-MM-dd HH:mm:ss.SSS"; // 模板一，字符串中提取日期数字
        String pat2 = "yyyy年MM月dd月 HH时mm分ss秒SSS毫秒"; // 模板二，将日期数字变为指定格式

        SimpleDateFormat sdf1 = new SimpleDateFormat(pat1); // 实例化模板对象
        SimpleDateFormat sdf2 = new SimpleDateFormat(pat2); // 实例化模板对象
        Date d = null;

        try {
            d = sdf1.parse(strDate); // 将给定的字符串中的日期提取出来
        } catch (Exception e) { // 若出错，进行异常处理
            e.printStackTrace(); // 打印异常处理
        }
        System.out.println(sdf2.format(d)); // 2021年07月01月 12时22分22秒365毫秒
    }

DateFormatter

JDK8发布，线程安全

ofPattern：设定时间格式
parse：将字符串格式化时间对象
format：将时间对象格式化为字符串
如将当前时间格式化为 YYYY-MM-DD HH24:MI:SS 输出

public static void main(String[] args) {
        // 将字符串转换为时间
        String dateStr = "2021年07月01日";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
        LocalDate date = LocalDate.parse(dateStr, formatter);
        System.out.println(date.getYear() + "-" + date.getMonthValue() + "-" + date.getDayOfMonth()); // 2021-7-1

        // 将日期转换为字符串
        LocalDateTime now = LocalDateTime.now();
        DateTimeFormatter format = DateTimeFormatter.ofPattern("yyyy年MM月dd日 hh:mm:ss");
        String nowStr = now.format(format);
        System.out.println(nowStr); // 2021年07月01日 08:27:32
    }