15--常用类和基础API--05

1、JDK8之前：日期时间API

1.1 java.lang.System类的方法

System类提供的public static long currentTimeMillis():用来返回当前时间与1970年1月1日0时0分0秒之间以毫秒为单位的时间差。

• 此方法适于计算时间差，又被称作时间戳。

计算世界时间的主要标准有：

• UTC(Coordinated Universal Time)
• GMT(Greenwich Mean Time)
• CST(Central Standard Time)

package com.suyv.date;

import org.junit.Test;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 10:42
*@Description: TODO
*/
public class SystemDemo01 {
    @Test
    public void Test01(){
        long l = System.currentTimeMillis();
        System.out.println(l);		// 1702521763993
    }
}

1.2 java.util.Date

表示特定的瞬间，精确到毫秒。

构造器：

• Date()：使用无参构造器创建的对象可以获取本地当前时间。
• Date(long 毫秒数)：把该毫秒值换算成日期时间对象

常用方法

• getTime(): 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数，即时间戳。
• toString(): 把此 Date 对象转换为以下形式的 String： dow mon dd hh:mm:ss zzz yyyy 其中： dow 是一周中的某一天 (Sun, Mon, Tue, Wed, Thu, Fri, Sat)，zzz是时间标准。
• 其它很多方法都过时了。

举例：

package com.suyv.date;

import org.junit.Test;

import java.util.Date;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 10:39
*@Description: Date类构造器的使用
*/
public class DateDemo01 {

    // public Date()的使用
    @Test
    public void Test01(){
        Date date = new Date();
        System.out.println(date);       // Thu Dec 14 10:54:55 CST 2023
    }

    // Date(long 毫秒数)的使用
    @Test
    public void Test02(){
        long l = System.currentTimeMillis();
        System.out.println(l);      // 1702522524528
        Date date = new Date(l);
        System.out.println(date);   // Thu Dec 14 10:55:24 CST 2023
    }
    
}

package com.suyv.date;

import org.junit.Test;

import java.util.Date;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 10:56
*@Description: Date类方法的使用
*/
public class DateDemo02 {

    // 获取具体的时间，方法均已弃用，了解即可
    @Test
    public void Test01(){
        Date date = new Date();
        // 获取当前年份
        System.out.println(date.getYear() + 1900);  // 2023
        // 获取当前月份
        System.out.println(date.getMonth() + 1);    // 12
        // 获取当前月份第几天
        System.out.println(date.getDate());         // 14
        // 获取小时数
        System.out.println(date.getHours());        // 10
        // 获取分钟数
        System.out.println(date.getMinutes());      // 59
        // 获取秒数
        System.out.println(date.getSeconds());      // 41
    }

    // 日期比较
    @Test
    public void Test02(){
        Date date = new Date();
        Date date1 = new Date(1702522524528L);
        System.out.println(date.before(date1)); // false
        System.out.println(date.after(date1));  // true
        System.out.println(date.equals(date1)); // false
    }

    // getTime()的使用--返回时间戳
    @Test
    public void Test03(){
        Date date = new Date();
        long time = date.getTime();
        System.out.println(time);
        long l = System.currentTimeMillis();
        System.out.println(l);
    }

    // toString()的使用
    @Test
    public void Test04(){
        Date date = new Date();
        System.out.println(date.toString());    // Thu Dec 14 11:05:42 CST 2023
        System.out.println(date);               // Thu Dec 14 11:05:42 CST 2023
    }

    // 测试记录的最大日期
    @Test
    public void Test06(){
        long time = Long.MAX_VALUE;
        Date d = new Date(time);
        System.out.println(d);                  // Sun Aug 17 15:12:55 CST 292278994
    }
}

1.3 java.sql.Date

java.sql.Date是java.util.Date的子类

构造器使用：

package com.suyv.date;

import org.junit.Test;

import java.sql.Date;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 11:33
*@Description: java.sql.Date类构造器的使用
*/
public class DateDemo03 {
    
    @Test
    public void Test01(){
        // Date(int year, int month, int day)
        // 已弃用,而是使用构造Date(long date)
        // 第一个参数是举例1900年的值
        Date date = new Date(123,11,14);
        System.out.println(date);       // 2023-12-14
    }
    
    @Test
    public void Test02(){
        // Date(long date)
        // 使用给定的毫秒时间值构造一个 Date对象。
        long l = System.currentTimeMillis();
        Date date = new Date(l);
        System.out.println(date);       // 2023-12-14
    }
}

java.sql.Date类方法的使用

package com.suyv.date;

import org.junit.Test;
import sun.util.resources.LocaleData;

import java.sql.Date;
import java.time.LocalDate;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 12:01
*@Description: java.sql.Date类方法的使用
*/
public class DateDemo04 {
    @Test
    public void Test01(){
        // toString()
        // 格式化日期转义格式yyyy-mm-dd。
        long l = System.currentTimeMillis();
        Date date = new Date(l);
        System.out.println(date.toString());        // 2023-12-14
        System.out.println(date);                   // 2023-12-14
        System.out.println(date.getClass());        // class java.sql.Date
    }
    
    @Test
    public void Test02(){
        // toLocalDate()        将Data对象转成LocalDate对象
        // 格式化日期转义格式yyyy-mm-dd。
        long l = System.currentTimeMillis();
        Date date = new Date(l);
        LocalDate localDate = date.toLocalDate();
        System.out.println(localDate);          // 2023-12-14
        System.out.println(localDate.getClass());       // class java.time.LocalDate
    }
}

怎么将java.util.Date对象转成 java.sql.Date?

	@Test
    public void Test01(){
        // 怎么将java.util.Date对象转成java.sql.Date对象
        java.util.Date date = new Date();
        System.out.println(date.getClass());            // class java.util.Date
        java.sql.Date date1 = new java.sql.Date(date.getTime());
        System.out.println(date1.getClass());           // class java.sql.Date
    }

怎么将字符串转成java.sql.Date对象？

	@Test
    public void Test02() throws ParseException {
        // 怎么将字符串转成java.sql.Date对象？
        String str = "2023-12-20";
        System.out.println(str.getClass());     // class java.lang.String
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");
        Date date = sf.parse(str);
        System.out.println(date.getClass());    // class java.util.Date
        java.sql.Date date1 = new java.sql.Date(date.getTime());
        System.out.println(date1.getClass());   // class java.sql.Date
    }

1.4 java.util.Calendar(日历)

Date类的API大部分被废弃了，替换为Calendar。

Calendar 类是一个抽象类，主用用于完成日期字段之间相互操作的功能。

获取Calendar实例的方法

• 使用Calendar.getInstance()

一个Calendar的实例是系统时间的抽象表示，可以修改或获取 YEAR、MONTH、DAY_OF_WEEK、HOUR_OF_DAY 、MINUTE、SECOND等日历字段对应的时间值。

• public int get(int field)：返回给定日历字段的值
• public void set(int field,int value) ：将给定的日历字段设置为指定的值
• public void add(int field,int amount)：根据日历的规则，为给定的日历字段添加或者减去指定的时间量
• public final Date getTime()：将Calendar转成Date对象
• public final void setTime(Date date)：使用指定的Date对象重置Calendar的时间

注意：

• 获取月份时：一月是0，二月是1，以此类推，12月是11
• 获取星期时：周日是1，周二是2 ， 。。。。周六是7

示例代码：

package com.suyv.date;

import org.junit.Test;

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

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 12:05
*@Description: Calendar类的使用
*/
public class CalendarDemo01 {

    // getInstance()方法和get()方法
    @Test
    public void Test01(){
        // 使用默认时区和区域设置获取日历。
        Calendar calendar = Calendar.getInstance();
        System.out.println(calendar);
        // 获取年份
        int year = calendar.get(Calendar.YEAR);
        // 获取月份
        int month = calendar.get(Calendar.MONTH)+1;
        // 获取日期
        int day = calendar.get(Calendar.DATE);
        // 获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
        // 获取分
        int minute = calendar.get(Calendar.MINUTE);

        System.out.println(year + "-" + month + "-" + day + " " + hour + ":" + minute); // 2023-12-14 12:6
    }

    @Test
    public void Test02(){
        TimeZone t = TimeZone.getTimeZone("America/Los_Angeles");
        // 使用特定时区和区域设置获取日历。
        Calendar c = Calendar.getInstance(t);
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DATE);
        int hour = c.get(Calendar.HOUR_OF_DAY);
        int minute = c.get(Calendar.MINUTE);
        System.out.println(year + "-" + month + "-" + day + " " + hour + ":" + minute); // 2023-12-13 20:11
    }

    @Test
    public void test3(){
        Calendar calendar = Calendar.getInstance();
        // 从一个 Calendar 对象中获取 Date 对象
        Date date = calendar.getTime();

        // 使用给定的 Date 设置此 Calendar 的时间
        date = new Date(234234235235L);
        calendar.setTime(date);
        calendar.set(Calendar.DAY_OF_MONTH, 8);
        System.out.println("当前时间日设置为8后,时间是:" + calendar.getTime());
        // 当前时间日设置为8后,时间是:Wed Jun 08 09:03:55 CST 1977

        calendar.add(Calendar.HOUR, 2);
        System.out.println("当前时间加2小时后,时间是:" + calendar.getTime());
        // 当前时间加2小时后,时间是:Wed Jun 08 11:03:55 CST 1977

        calendar.add(Calendar.MONTH, -2);
        System.out.println("当前日期减2个月后,时间是:" + calendar.getTime());
        // 当前日期减2个月后,时间是:Fri Apr 08 11:03:55 CST 1977
    }
}

1.5 java.text.SimpleDateFormat

java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类。

可以进行格式化：日期 --> 文本/字符串

可以进行解析：文本/字符串 --> 日期

构造器：

• SimpleDateFormat() ：默认的模式和语言环境创建对象
• public SimpleDateFormat(String pattern)：该构造方法可以用参数pattern指定的格式创建一个对象

格式化：

• public String format(Date date)：方法格式化时间对象date

解析：

• public Date parse(String source)：从给定字符串的开始解析文本，以生成一个日期。

package com.suyv.date;

import org.junit.Test;

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

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 11:08
*@Description: SimpleDateFormat类的使用--日期格式化的使用
*/
public class SimpleDateFormatDemo01 {

    //格式化
    @Test
    public void Test01(){
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒  E Z");
        //把Date日期转成字符串，按照指定的格式转
        String str = sf.format(date);
        System.out.println(str);        // 2023年12月14日 11时11分26秒 007毫秒  星期四 +0800
    }

    @Test
    public void Test02(){
        Date date = new Date();
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String str = sf.format(date);
        System.out.println(str);        // 2023-12-14 11:11:39
    }


    //解析
    @Test
    public void Test03() throws ParseException {
        String str = "2023年12月14日 11时11分26秒 007毫秒  星期四 +0800";
        SimpleDateFormat sf = new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss秒 SSS毫秒  E Z");
        Date date = sf.parse(str);
        System.out.println(date);      // Thu Dec 14 11:11:26 CST 2023
    }

    @Test
    public void Test04() throws ParseException {
        String str = "2023-12-14 11:11:39";
        SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sf.parse(str);
        System.out.println(date);       // Thu Dec 14 11:11:39 CST 2023
    }
}

2、JDK8：新的日期时间API

对日期和时间的操作一直是Java程序员最痛苦的地方之一。

第三次引入的API是成功的，并且Java 8中引入的java.time API 已经纠正了过去的缺陷，将来很长一段时间内它都会为我们服务。

Java 8 以一个新的开始为 Java 创建优秀的 API。新的日期时间API包含：

• java.time – 包含值对象的基础包
• java.time.chrono – 提供对不同的日历系统的访问。
• java.time.format – 格式化和解析时间和日期
• java.time.temporal – 包括底层框架和扩展特性
• java.time.zone – 包含时区支持的类

说明：新的 java.time 中包含了所有关于时钟（Clock），本地日期（LocalDate）、本地时间（LocalTime）、本地日期时间（LocalDateTime）、时区（ZonedDateTime）和持续时间（Duration）的类。

尽管有68个新的公开类型，但是大多数开发者只会用到基础包和format包，大概占总数的三分之一。

2.1 本地日期时间：LocalDate、LocalTime、LocalDateTime

方法	描述
now()/ now(ZoneId zone)	静态方法，根据当前时间创建对象/指定时区的对象
of(xx,xx,xx,xx,xx,xxx)	静态方法，根据指定日期/时间创建对象
getDayOfMonth()/getDayOfYear()	获得月份天数(1-31) /获得年份天数(1-366)
getDayOfWeek()	获得星期几(返回一个 DayOfWeek 枚举值)
getMonth()	获得月份, 返回一个 Month 枚举值
getMonthValue() / getYear()	获得月份(1-12) /获得年份
getHours()/getMinute()/getSecond()	获得当前对象对应的小时、分钟、秒
withDayOfMonth()/withDayOfYear()/withMonth()/withYear()	将月份天数、年份天数、月份、年份修改为指定的值并返回新的对象
with(TemporalAdjuster ?t)	将当前日期时间设置为校对器指定的日期时间
plusDays(), plusWeeks(), plusMonths(), plusYears(),plusHours()	向当前对象添加几天、几周、几个月、几年、几小时
minusMonths() / minusWeeks()/minusDays()/ minusYears()/minusHours()	从当前对象减去几月、几周、几天、几年、几小时
plus(TemporalAmount t)/ minus(TemporalAmount t)	添加或减少一个 Duration 或 Period
isBefore()/isAfter()	比较两个 LocalDate
isLeapYear()	判断是否是闰年（在LocalDate类中声明）
format(DateTimeFormatter ?t)	格式化本地日期、时间，返回一个字符串
parse(Charsequence text)	将指定格式的字符串解析为日期、时间

package com.suyv.date;

import org.junit.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 12:34
*@Description: TODO
*/
public class DateDemo06 {
    @Test
    public void Test01(){
        LocalDate now = LocalDate.now();
        System.out.println(now);        // 2023-12-14
    }
    
    @Test
    public void Test02(){
        LocalTime now = LocalTime.now();
        System.out.println(now);        // 13:07:22.717
    }
    
    @Test
    public void Test03(){
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);        // 2023-12-14T13:07:36.330
    }
    
    @Test
    public void Test04(){
        LocalDate lai = LocalDate.of(2019, 5, 13);
        System.out.println(lai);        // 2019-05-13
    }
    
    @Test
    public void Test05(){
        LocalDate lai = LocalDate.of(2019, 5, 13);
        System.out.println(lai.getDayOfYear());     // 133
    }
    
    @Test
    public void Test06(){
        LocalDate lai = LocalDate.of(2019, 5, 13);
        LocalDate go = lai.plusDays(160);
        System.out.println(go);     // 2019-10-20
    }
    
    @Test
    public void Test07(){
        LocalDate now = LocalDate.now();
        LocalDate before = now.minusDays(100);
        System.out.println(before);     // 2023-09-05
    }
}

2.2 瞬时：Instant

Instant：时间线上的一个瞬时点。 这可能被用来记录应用程序中的事件时间戳。

• 时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。

java.time.Instant表示时间线上的一点，而不需要任何上下文信息，例如，时区。概念上讲，它只是简单的表示自1970年1月1日0时0分0秒（UTC）开始的秒数。

方法	描述
now()	静态方法，返回默认UTC时区的Instant类的对象
ofEpochMilli(long epochMilli)	静态方法，返回在1970-01-01 00:00:00基础上加上指定毫秒数之后的Instant类的对象
atOffset(ZoneOffset offset)	结合即时的偏移来创建一个 OffsetDateTime
toEpochMilli()	返回1970-01-01 00:00:00到当前时间的毫秒数，即为时间戳

package com.suyv.date;

import org.junit.Test;

import java.time.Instant;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 13:12
*@Description: TODO
*/
public class DateDemo07 {
    // 1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)
    @Test
    public void Test01(){
        Instant now = Instant.now();
        System.out.println(now);        // 2023-12-14T05:12:52.818Z
    }

    @Test
    public void Test02(){
        long l = System.currentTimeMillis();
        Instant instant = Instant.ofEpochMilli(l);
        System.out.println(instant);     // 2023-12-14T05:15:54.691Z
    }

    @Test
    public void Test03(){
        Instant now = Instant.now();
        long l = now.toEpochMilli();
        System.out.println(l);          // 1702531248897
        System.out.println(System.currentTimeMillis()); // 1702531248897

    }
}

2.3 日期时间格式化：DateTimeFormatter

该类提供了三种格式化方法：

• (了解)预定义的标准格式。如：ISO_LOCAL_DATE_TIME、ISO_LOCAL_DATE、ISO_LOCAL_TIME
• (了解)本地化相关的格式。如：ofLocalizedDate(FormatStyle.LONG)

• 自定义的格式。如：ofPattern(“yyyy-MM-dd hh:mm:ss”)

方法	描述
ofPattern(Stringpattern)	静态方法，返回一个指定字符串格式的DateTimeFormatter
format(TemporalAccessort temporal)	格式化一个日期、时间，返回字符串
parse(CharSequence text)	将指定格式的字符序列解析为一个日期、时间

举例：

package com.suyv.date;

import org.junit.Test;

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;

/**
*@Author: 憨憨浩浩
*@CreateTime: 2023-12-14 13:49
*@Description: DateTimeFormatter的使用
*/
public class DateDemo08 {

    @Test
    public void test1(){
        // 方式一：预定义的标准格式。如：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
        DateTimeFormatter formatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;

        // 格式化:日期-->字符串
        LocalDateTime localDateTime = LocalDateTime.now();
        String str1 = formatter.format(localDateTime);
        System.out.println(localDateTime);      // 2023-12-14T13:50:35.255
        System.out.println(str1);               // 2023-12-14T13:50:35.255

        // 解析：字符串 -->日期
        TemporalAccessor parse = formatter.parse("2023-12-14T13:50:35.255");
        LocalDateTime dateTime = LocalDateTime.from(parse);
        System.out.println(dateTime);           // 2023-12-14T13:50:35.255
    }

    @Test
    public void test2(){
        LocalDateTime localDateTime = LocalDateTime.now();
        // 方式二：
        // 本地化相关的格式。如：ofLocalizedDateTime()
        // FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT :适用于LocalDateTime
        DateTimeFormatter formatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.LONG);

        // 格式化
        String str2 = formatter1.format(localDateTime);
        System.out.println(str2);       // 2023年12月14日 下午01时51分42秒

        // 本地化相关的格式。如：ofLocalizedDate()
        // FormatStyle.FULL / FormatStyle.LONG / FormatStyle.MEDIUM / FormatStyle.SHORT : 适用于LocalDate
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL);
        // 格式化
        String str3 = formatter2.format(LocalDate.now());
        System.out.println(str3);       // 2023年12月14日 星期四
    }

    @Test
    public void test3(){
        //方式三：自定义的方式（关注、重点）
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");

        //格式化
        String strDateTime = dateTimeFormatter.format(LocalDateTime.now());
        System.out.println(strDateTime);    // 2023/12/14 13:52:20
        //解析
        TemporalAccessor accessor = dateTimeFormatter.parse("2023/12/14 13:52:20");
        LocalDateTime localDateTime = LocalDateTime.from(accessor);
        System.out.println(localDateTime);  // 2023-12-14T13:52:20
    }
}