Java日期类 util.Date sql.Date Calendar LocalDateTime 格式化 DateFormat DateTimeFormatter

java 日期类

java.util.Date

Date有两个附加功能。 它允许将日期解释为年，月，日，小时，分钟和第二个值。 它还允许格式化和解析日期字符串。 但这些功能的API不适合国际化。 从JDK 1.1开始， Calendar类应该用于在日期和时间字段之间进行转换，并且DateFormat类应用于格式化和解析日期字符串。 在相应的方法Date被弃用。

一些计算机标准是根据格林尼治标准时间（GMT）定义的，相当于世界时间（UT）。

  • 在类的所有方法Date接受或返回年，月，日，小时，分钟和秒值，以下表述中使用：

y年代表整数y - 1900 。

一个月由0到11的整数表示; 0是1月，1是2月，等等; 11月12日。

日期（月的一天）以通常的方式从1到31的整数表示。

一小时由0到23之间的整数表示。因此，从午夜到凌晨1点的时间是小时0，从中午到下午1点的小时是12小时。

一般以0〜59的整数表示。

第二个由0到61的整数表示; 值60和61仅发生在闰秒上，甚至仅在实际上正确跟踪闰秒的Java实现中发生。 由于目前引入闰秒的方式，在同一分钟内不会发生两个闰秒，但是本规范遵循ISO C的日期和时间约定。

构造方法

构造方法描述
Date()分配一个 Date对象，并初始化它，以便它代表它被分配的时间，测量到最近的毫秒。
Date(long date)分配一个 Date对象，并将其初始化为表示自称为“时代”的标准基准时间以后的指定毫秒数，即1970年1月1日00:00:00 GMT。 使用System.currentTimeMillis()获得

常用方法

Modifier and Type方法描述
booleanafter(Date when)测试此日期是否在指定日期之后。
booleanbefore(Date when)测试此日期是否在指定日期之前。
Objectclone()返回此对象的副本。
intcompareTo(Date anotherDate)比较两个日期的顺序。
booleanequals(Object obj)比较两个日期的相等性。
longgetTime()返回自1970年1月1日以来，由此 Date对象表示的00:00:00 GMT的毫秒 数 。
StringtoString()将此 Date对象转换为 String的形式：
intgetYear()日期表示的年份减去 1900。已弃用。由Calendar.get(Calendar.YEAR) - 1900 。
intgetMonth()此日期所表示的月份，返回的值在 0 和 11 之间，值 0 表示 1 月。 已弃用。由Calendar.get(Calendar.MONTH)取代。
StringtoLocaleString()此日期的字符串表示形式，使用区域设置约定。已弃用，由DateFormat.format(Date date)替换。
intgetDate()返回此 Date 对象表示的月份中的某一天。返回的值在 1 和 31 之间，表示包含或开始于此 Date 对象表示的时间的月份中的某一天。 已弃用。由Calendar.get(Calendar.DAY_OF_MONTH)取代 。
intgetDay()返回此日期表示的周中的某一天，返回值 (0 = Sunday, 1 = Monday, ···） 。已弃用。由Calendar.get(Calendar.DAY_OF_WEEK)取代 。
intgetHours()此日期所表示的小时。已弃用。由Calendar.get(Calendar.HOUR_OF_DAY) 取代 。
intgetMinutes()返回此日期所表示的小时已经过去的分钟数。返回值在 0 和 59 之间。 已弃用。由Calendar.get(Calendar.MINUTE)取代。
intgetMonth()此日期所表示的月份。返回的值在 0 和 11 之间，值 0 表示 1 月。 已弃用。由Calendar.get(Calendar.MONTH)取代。
intgetSeconds()返回此日期所表示的分钟已经过去的秒数，返回的值在 0 和 61 之间。已弃用。由Calendar.get(Calendar.SECOND) 取代

实例

public class Test {
    public static void main(String[] args) {
        //java.util.Date:
        Date d = new Date();
        System.out.println(d); //Sun Aug 08 21:21:32 CST 2021
        System.out.println(d.toString()); //Sun Aug 08 21:21:32 CST 2021
        System.out.println(d.toGMTString()); //8 Aug 2021 13:21:32 GMT
        System.out.println(d.toLocaleString()); //2021-8-8 21:21:32
        System.out.println(d.getYear());//121。121+1900=2021
        System.out.println(d.getMonth());//7 :返回的值在 0 和 11 之间，值 0 表示 1 月。
        //返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
        System.out.println(d.getTime());//1628428892448
        System.out.println(System.currentTimeMillis());//1628428892448
    }
}

获取时间差一般用System.currentTimeMillis()，这个方法是静态的，可以类名.方法名直接调用，无方法体，其具体实现并不是java实现，一般会去衡量一些算法所用的时间

java.sql.Date

一个大约一毫秒值的薄包装，允许JDBC将其标识为SQL DATE值。 毫秒值表示1970年1月1日00：00：00.000 GMT之后的毫秒数。

为了符合SQL DATE ，由java.sql.Date实例包装的毫秒值必须通过在实例关联的特定时区中将小时，分钟，秒和毫秒设置为零来“归一化”。

java.sql.Date和java.util.Date的

  • 区别：
    • java.util.Date：年月日 时分秒
    • java.sql.Date：年月日
  • 联系：
    `java.sql.Date(子类) extends java.util.Date （父类）

构造方法

  • Date(long date) 使用给定毫秒时间值构造一个 Date 对象。
    • @param date自1970年1月1日00:00:00 GMT以来的毫秒数。
    • @see java.lang.System.currentTimeMillis（）

转换

相互转化

  • util --> sql:

  • 方式1：向下转型

    java.util.Date date = new Date(1628431958441L);//创建util.Date的对象

    Date date1 = (Date) date;

    java.sql.Date date1 = (java.sql.Date) date;

  • 方式2：利用构造器
    Date date2 = new Date(date.getTime());

    Date date2 = new Date(System.currentTimeMillis());👍

  • sql --> util:
  Date d = new Date(1628431958441L);
  																																												
  java.util.Date date3 = d;

字符转换

  • String–>java.sql.Date
public static void main(String[] args) {
    //（1）String--->java.sql.Date
    java.sql.Date date = java.sql.Date.valueOf("2015-9-24");
    //（2）java.sql.Date--->java.util.Date
    java.util.Date date2 = date;
    System.out.println(date2.toString());
}

但代码有局限性，字符串的格式只能是年-月-日拼接的形式，换成其它类型，就会出现异常

DateFormat

构造方法

  • protected DateFormat() 创建一个新的日期格式。

  • SimpleDateFormat(子类) extends DateFormat（父类是一个抽象类）

  • 指定格式化标准

  • DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

日期和时间模式
字母日期或时间组件描述示例
G纪元指示符TextAD
y年Year1996; 96
YWeek yearYear2009; 09
M年中月份（上下文相关sensitive）MonthJuly; Jul; 07
L年中月份（独立形式）MonthJuly; Jul; 07
wWeek in yearNumber]27
WWeek in monthNumber2
DDay in yearNumber189
dDay in monthNumber10
F一个月中的星期几Day of week in monthNumber2
E周中的日名称Day name in weekTextTuesday; Tue
u星期几(1 = Monday, …, 7 = Sunday)Number1
a上午/下午 标记TextPM
H一天中的小时 (0-23)Number0
k一天中的小时 (1-24)Number24
K上午/下午的小时 (0-11)Number0
h上午/下午的小时 (1-12)Number12
mMinute in hourNumber30
sSecond in minuteNumber55
S毫秒Number978
z时区Time zoneGeneral time zonePacific Standard Time; PST; GMT-08:00
Z时区Time zoneRFC 822 time zone-0800
X时区Time zoneISO 8601 time zone-08; -0800; -08:00
常用方法
Modifier and Type方法描述
Objectclone()重写 Cloneable
booleanequals(Object obj)重写 equals
Stringformat(Date date)将一个 Date 格式化为日期/时间字符串。
abstract StringBufferformat(Date date, StringBuffer toAppendTo, FieldPosition fieldPosition)将一个 Date 格式化为日期/时间字符串。
StringBufferformat(Object obj, StringBuffer toAppendTo, FieldPosition fieldPosition)重写 Format。
CalendargetCalendar()获取与此日期/时间格式器关联的日历。
TimeZonegetTimeZone()获取时区。
inthashCode()重写 hashCode
booleanisLenient()判断日期/时间解析是否为不严格的。
Dateparse(String source)从给定字符串的开始解析文本，以生成一个日期。
abstract Dateparse(String source, ParsePosition pos)根据给定的解析位置开始解析日期/时间字符串。
ObjectparseObject(String source, ParsePosition pos)解析字符串中的文本，以生成一个 Date。
voidsetCalendar(Calendar newCalendar)设置此日期格式所使用的日历。
voidsetLenient(boolean lenient)指定日期/时间解析是否不严格。
voidsetNumberFormat(NumberFormat newNumberFormat)允许用户设置数字格式器。
voidsetTimeZone(TimeZone zone)为此 DateFormat 对象的日历设置时区。
static CalendargetInstance()使用默认时区和语言环境获得一个日历。
static CalendargetInstance([TimeZone zone][, Locale aLocale])使用指定时区和语言环境获得一个日历。每一参数可有可无
实例

通过DateFormat可以将日期按照自定义格式输出

public static void main(String[] args) {
    //格式化的标准定义：
    DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    //String-->Date
    Date d = null;
    try {
        d = df.parse("2021-8-8 12:26:8");
    } catch (ParseException parseException) {
        parseException.printStackTrace();
    }
    System.out.println(d); //Sun Aug 08 12:26:08 CST 2021
    //Date-->String
    String format = df.format(new Date());
    System.out.println(format); //2021-08-08 23:26:34
    
    Date date = new Date();
    System.out.println(date.toString()); //Sun Aug 08 23:26:34 CST 2021
    System.out.println(date.toGMTString()); //8 Aug 2021 15:26:34 GMT
    System.out.println(date.toLocaleString()); //2021-8-8 23:26:34
}

Calendar

所述Calendar类是一个抽象类，可以为在某一特定时刻和一组之间的转换的方法calendar fields如YEAR ， MONTH ， DAY_OF_MONTH ， HOUR ，等等，以及用于操纵该日历字段，如获取的日期下个星期。 时间上的瞬间可以用毫秒值表示，该值是从1970年1月1日00:00 00：00.000 GMT（Gregorian）的Epoch的偏移量。

日历字段可以用三种方法来改变set() ， add()和roll() 。

  • **set(f, value)**将日历字段f改为value 。
  • **add(f, delta)**增加delta到现场f 。
  • **roll(f, delta)**增加delta到现场f不更改更大的字段。

构造方法

  • protected Calendar() 构造一个带有默认时区和语言环境的 Calendar。
  • protected Calendar(TimeZone zone, Locale aLocale) 构造一个带有指定时区和语言环境的 Calendar。

字段field

Modifier and Type字段描述
static intALL_STYLES指示所有风格名称的 getDisplayNames 的风格说明符，比如 “January” 和 “Jan”。
static intAM指示从午夜到中午之前这段时间的 AM_PM字段值。
static intAM_PMget 和 set 的字段数字，指示 HOUR 是在中午之前还是在中午之后。
static intDATEget 和 set 的字段数字，指示一个月中的某天。
static intDAY_OF_MONTHget 和 set 的字段数字，指示一个月中的某天。
static intDAY_OF_WEEKget 和 set 的字段数字，指示一个星期中的某天。
static intDAY_OF_WEEK_IN_MONTHget 和 set 的字段数字，指示当前月中的第几个星期。
static intDAY_OF_YEARget 和 set 的字段数字，指示当前年中的天数。
static intDST_OFFSETget 和 set 的字段数字，以毫秒为单位指示夏令时的偏移量。
static intERA指示年代的 get 和 set 的字段数字，比如罗马儒略历中的 AD 或 BC。
static intFIELD_COUNTget 和 set 可识别的不同字段的数量。
protected int[]fields此日历当前设置时间的日历字段值。
static intHOURget 和 set 的字段数字，指示上午或下午的小时。
static intHOUR_OF_DAYget 和 set 的字段数字，指示一天中的小时。
static intMONTH指示月份的 get 和 set 的字段数字。
static intJanuary,February,March, April,May,June,July, August,September,October, November,December指示在格里高利历和罗马儒略历中一年中第N个月的 January February March April May June July August September October November December字段值。
static intLONG指示长名称的 getDisplayName 和 getDisplayNames 的风格说明符，比如 “January”。
static intMILLISECONDget 和 set 的字段数字，指示一秒中的毫秒。
static intMINUTEget 和 set 的字段数字，指示一小时中的分钟。
static intMonday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday指示Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday的 DAY_OF_WEEK 字段值。
static intPM指示从中午到午夜之前这段时间的 AM_PM字段值。
static intSECONDget 和 set 的字段数字，指示一分钟中的秒。
static intSHORT指示短名称的 getDisplayName 和 getDisplayNames 的风格说明符，比如 “Jan”。
static intUNDECIMBER指示一年中第十三个月的 MONTH 字段值。
static intWEEK_OF_MONTHget 和 set 的字段数字，指示当前月中的星期数。
static intWEEK_OF_YEARget 和 set 的字段数字，指示当前年中的星期数。
static intYEAR指示年的 get 和 set 的字段数字。
static intZONE_OFFSETget 和 set 的字段数字，以毫秒为单位指示距 GMT 的大致偏移量。
protected longtime日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间 1970 年 1月 1 日 0:00:00 后经过的时间。
protected boolean[]isSet通知是否设置了该日历某一指定日历字段的标志。
protected booleanisTimeSet如果 time 值是一个有效值，则返回 true。
protected booleanareFieldsSet如果 fields[] 与当前的设置时间同步，则返回 true。

字段组合

  • For the date fields ：

    YEAR + MONTH + DAY_OF_MONTH
YEAR + MONTH + WEEK_OF_MONTH + DAY_OF_WEEK
YEAR + MONTH + DAY_OF_WEEK_IN_MONTH + DAY_OF_WEEK
YEAR + DAY_OF_YEAR
YEAR + DAY_OF_WEEK + WEEK_OF_YEAR

  • For the time of day fields ：

HOUR_OF_DAY
AM_PM + HOUR

常用方法

Modifier and Type方法描述
intget(int field)返回给定日历字段的值。
intgetActualMaximum(int field)给定此 Calendar 的时间值，返回指定日历字段可能拥有的最大值。
intgetActualMinimum(int field)给定此 Calendar 的时间值，返回指定日历字段可能拥有的最小值。
intgetFirstDayOfWeek()获取一星期的第一天；例如，在美国，这一天是 SUNDAY，而在法国，这一天是 MONDAY。
abstract intgetGreatestMinimum(int field)返回此 Calendar 实例给定日历字段的最高的最小值。
abstract intgetLeastMaximum(int field)返回此 Calendar 实例给定日历字段的最低的最大值。
abstract intgetMaximum(int field)返回此 Calendar 实例给定日历字段的最大值。
intgetMinimalDaysInFirstWeek()获取一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则此方法将返回 1。
abstract intgetMinimum(int field)返回此 Calendar 实例给定日历字段的最小值。
DategetTime()返回一个表示此 Calendar 时间值（从格林威治标准时间 1970 年 1 月 1 日的 00:00:00.000，至现在的毫秒偏移量）的 Date 对象。
longgetTimeInMillis()返回此 Calendar 的时间值，以毫秒为单位。
TimeZonegetTimeZone()获得时区。
voidset(int field, int value)将给定的日历字段设置为给定值。
voidset(int year, int month, int date)设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值。
voidset(int year, int month, int date, int hourOfDay, int minute)设置日历字段 YEAR、MONTH、DAY_OF_MONTH、HOUR_OF_DAY 和 MINUTE 的值。
voidset(int year, int month, int date, int hourOfDay, int minute, int second)设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、MINUTE 和 SECOND 的值。
voidsetFirstDayOfWeek(int value)设置一星期的第一天是哪一天；例如，在美国，这一天是 SUNDAY，而在法国，这一天是 MONDAY。
voidsetMinimalDaysInFirstWeek(int value)设置一年中第一个星期所需的最少天数，例如，如果定义第一个星期包含一年第一个月的第一天，则使用值 1 调用此方法。
voidsetTime(Date date)使用给定的 Date 设置此 Calendar 的时间。
voidsetTimeInMillis(long millis)用给定的 long 值设置此 Calendar 的当前时间值。
voidsetTimeZone(TimeZone value)使用给定的时区值来设置时区。
StringtoString()返回此日历的字符串表示形式。

实例

public class Test4 {
    public static void main(String[] args) {
        //Calendar是一个抽象类，不可以直接创建对象
        //GregorianCalendar()子类 extends Calendar（父类是一个抽象类）
        Calendar cal = new GregorianCalendar();
        Calendar cal2 = Calendar.getInstance();
        System.out.println(cal);   /*java.util.GregorianCalendar[time=1628436852586,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=31,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2021,MONTH=7,WEEK_OF_YEAR=33,WEEK_OF_MONTH=2,DAY_OF_MONTH=8,DAY_OF_YEAR=220,DAY_OF_WEEK=1,DAY_OF_WEEK_IN_MONTH=2,AM_PM=1,HOUR=11,HOUR_OF_DAY=23,MINUTE=34,SECOND=12,MILLISECOND=586,ZONE_OFFSET=28800000,DST_OFFSET=0]        */
        //常用的方法：2021
        // get()方法，传入参数：Calendar中定义的常量
        System.out.println(cal.get(Calendar.YEAR)); //2021
        System.out.println(cal.get(Calendar.MONTH)); //7
        System.out.println(cal.get(Calendar.DATE)); //8
        System.out.println(cal.get(Calendar.DAY_OF_WEEK)); //1
        System.out.println(cal.getActualMaximum(Calendar.DATE));//31。获取当月日期的最大天数
        System.out.println(cal.getActualMinimum(Calendar.DATE));//1。获取当月日期的最小天数
        // set方法：可以改变Calendar中的内容
        cal.set(Calendar.YEAR,1990);
        cal.set(Calendar.MONTH,3);
        cal.set(Calendar.DATE,16);
        System.out.println(cal);
/*...YEAR=1990,MONTH=3,...DAY_OF_MONTH=16,...*/
        
        //String--->Calendar:
        //分解：
        //String--->java.sql.Date:
        java.sql.Date date = java.sql.Date.valueOf("2020-4-5");
        //java.sql.Date-->Calendar:
        cal.setTime(date);
        System.out.println(cal);
/*...YEAR=2020,MONTH=3,...DAY_OF_MONTH=5...*/
    }
}

生成日历

public class Test5 {
    public static void main(String[] args) {
        //录入日期的String：
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入你想要查看的日期：（YYYY-MM--dd格式）");
        String strDate = sc.next();
        //String-->Date-->Calendar:
        //String-->Date:
        java.sql.Date date = java.sql.Date.valueOf(strDate);
        //Date-->Calendar:
        getCalendar(date);
    }

    static void getCalendar(java.sql.Date date) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(date);
        //后续操作：
        //星期提示：
        System.out.println("日\t一\t二\t三\t四\t五\t六\t");
        //获取本月的最大天数：
        int maxDay = cal.getActualMaximum(Calendar.DATE);
        //获取当前日期中的日：
        int nowDay = cal.get(Calendar.DATE);
        //将日期调为本月的1号：
        cal.set(Calendar.DATE, 1);
        //获取这个一号是本周的第几天：
        int num = cal.get(Calendar.DAY_OF_WEEK);
        //前面空出来的天数为：
        int day = num - 1;
        //引入一个计数器：
        int count = 0;//计数器最开始值为0
        //在日期前将空格打印出来：
        for (int i = 1; i <= day; i++) {
            System.out.print("\t");
        }
        //空出来的日子也要放入计数器：
        count = count + day;
        //遍历：从1号开始到maxDay号进行遍历：
        for (int i = 1; i <= maxDay; i++) {
            if (i == nowDay) {//如果遍历的i和当前日子一样的话，后面多拼一个*
                System.out.print(i + "*" + "\t");
            } else {
                System.out.print(i + "\t");
            }
            count++;//每在控制台输出一个数字，计数器做加1操作
            if (count % 7 == 0) {//当计数器的个数是7的倍数的时候，就换行操作
                System.out.println();
            }
        }
    }
}
请输入你想要查看的日期：（YYYY-MM--dd格式）
2021-8-9
日	一	二	三	四	五	六	
1	2	3	4	5	6	7	
8	9*	10	11	12	13	14	
15	16	17	18	19	20	21	
22	23	24	25	26	27	28	
29	30	31

小结

  1. JDK1.0中使用java.util.Date类 -->第一代日期时间API

  2. JDK1.1引入Calendar类 -->第二代日期时间API

    缺陷：

    • 可变性 : 日期和时间类应该是不可变的。
    • 偏移性 : Date中年份从1900开始，而月份从0开始。
    • 格式化 : 格式化只对Date有用，Calendar则不行。

  3. JDK1.8新增日期时间API -->第三代日期时间API

Local-Date-Time

LocalDate

  • LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日。 也可以访问其他日期字段，例如日期，星期几和星期。

  • 该类不存储或表示时间或时区。 相反，它是日期的描述，用于生日。 它不能代表时间线上的即时信息，而没有附加信息，如偏移或时区。

  • static LocalDate MAX 最大支持 LocalDate，999999999-12-31。

  • static LocalDate MIN 最低支持 LocalDate ，-999999999-01-01。

Modifier and TypeMethodDescription
TemporaladjustInto(Temporal temporal)调整指定的时间对象与此对象的日期相同。
LocalDateTimeatStartOfDay()将此日期与午夜时间结合 LocalDateTime ，在此日期开始时创建一个 LocalDateTime 。
ZonedDateTimeatStartOfDay(ZoneId zone)根据时区中的规则，在最早的有效时间内从此日期返回划分的日期时间。
LocalDateTimeatTime(int hour, int minute[, int second[, int nanoOfSecond]])结合此日期与时间创建一个 LocalDateTime 。
LocalDateTimeatTime(LocalTime time)结合此日期与时间创建一个 LocalDateTime 。
OffsetDateTimeatTime(OffsetTime time)将此日期与偏移时间相结合以创建 OffsetDateTime 。
intcompareTo(ChronoLocalDate other)将此日期与另一个日期进行比较。
booleanequals(Object obj)检查这个日期是否等于另一个日期。
Stringformat(DateTimeFormatter formatter)使用指定的格式化程序格式化此日期。
static LocalDatefrom(TemporalAccessor temporal)从时间对象获取一个 LocalDate的实例。
intget(TemporalField field)从此日期获取指定字段的 int 。
IsoChronologygetChronology()获取这个日期的时间顺序，即ISO日历系统。
intgetDayOfMonth()获取月份字段。
DayOfWeekgetDayOfWeek()获取星期几字段，这是一个枚举 DayOfWeek 。
intgetDayOfYear()获得日期字段。
EragetEra()获得这个时代适用的时代。
longgetLong(TemporalField field)从此日期获取指定字段的值为 long 。
MonthgetMonth()使用 Month枚举获取月份字段。
intgetMonthValue()将月份字段从1到12。
intgetYear()获取年份字段。
inthashCode()这个日期的哈希码。
booleanisAfter(ChronoLocalDate other)检查此日期是否在指定日期之后。
booleanisBefore(ChronoLocalDate other)检查此日期是否在指定日期之前。
booleanisEqual(ChronoLocalDate other)检查此日期是否等于指定的日期。
booleanisLeapYear()根据ISO培训日历系统规则，检查年份是否是闰年。
booleanisSupported(TemporalField field)检查指定的字段是否受支持。
booleanisSupported(TemporalUnit unit)检查指定的单位是否受支持。
intlengthOfMonth()返回由此日期表示的月份的长度。
intlengthOfYear()返回由此日期表示的年份的长度。
LocalDateminus(long amountToSubtract, TemporalUnit unit)返回此日期的副本，减去指定的金额。
LocalDateminus(TemporalAmount amountToSubtract)返回此日期的副本，减去指定的金额。
LocalDateminusDays(long daysToSubtract)返回此 LocalDate的副本，并减去指定的天数。
LocalDateminusMonths(long monthsToSubtract)返回此 LocalDate的副本，指定的时间间隔减去。
LocalDateminusWeeks(long weeksToSubtract)返回此 LocalDate一个副本，其中指定的周期以周为单位减去。
LocalDateminusYears(long yearsToSubtract)返回此 LocalDate的副本，以减去的年份为单位。
static LocalDatenow()从默认时区的系统时钟获取当前日期。
static LocalDatenow(Clock clock)从指定的时钟获取当前日期。
static LocalDatenow(ZoneId zone)从指定时区的系统时钟获取当前日期。
static LocalDateof(int year, int month, int dayOfMonth)从一年，一个月和一天获得一个 LocalDate的实例。
static LocalDateof(int year, Month month, int dayOfMonth)从一年，一个月和一天获得一个 LocalDate的实例。
static LocalDateofEpochDay(long epochDay)从时代天数获得一个 LocalDate的实例。
static LocalDateofYearDay(int year, int dayOfYear)从一年和一年的一年中获得 LocalDate的实例。
static LocalDateparse(CharSequence text)从一个文本字符串（如 2007-12-03获取一个 LocalDate的实例。
static LocalDateparse(CharSequence text, DateTimeFormatter formatter)使用特定格式化 LocalDate从文本字符串获取 LocalDate的实例。
LocalDateplus(long amountToAdd, TemporalUnit unit)返回此日期的副本，并添加指定的金额。
LocalDateplus(TemporalAmount amountToAdd)返回此日期的副本，并添加指定的金额。
LocalDateplusDays(long daysToAdd)返回指定天数的 LocalDate的副本。
LocalDateplusMonths(long monthsToAdd)返回这个 LocalDate的副本，其指定的时间段以月为单位。
LocalDateplusWeeks(long weeksToAdd)返回这个 LocalDate的副本，并以指定的周期添加周数。
LocalDateplusYears(long yearsToAdd)返回这个 LocalDate的副本，其中指定的时间段以添加的年数表示。
<R> Rquery(TemporalQuery<R> query)使用指定的查询查询此日期。
ValueRangerange(TemporalField field)获取指定字段的有效值的范围。
longtoEpochDay()将此日期转换为大纪元日。
StringtoString()将此日期输出为 String ，如 2007-12-03 。
Perioduntil(ChronoLocalDate endDateExclusive)将此日期和其他日期之间的期间计算为 Period 。
longuntil(Temporal endExclusive, TemporalUnit unit)根据指定的单位计算直到另一个日期的时间量。
LocalDatewith(TemporalAdjuster adjuster)返回此日期的调整副本。
LocalDatewith(TemporalField field, long newValue)返回此日期的副本，并将指定的字段设置为新值。
LocalDatewithDayOfMonth(int dayOfMonth)返回此日期的副本，并更改日期。
LocalDatewithDayOfYear(int dayOfYear)返回此日期的副本，并更改日期。
LocalDatewithMonth(int month)返回这个日期的副本，并更改年月日。
LocalDatewithYear(int year)返回此日期的副本，并更改年份。

LocalTime

LocalTime是一个不可变的日期时间对象，代表一个时间，通常被看作是小时 - 秒。 时间表示为纳秒精度。 例如，值13：45.30.123456789可以存储在LocalTime 。

它不存储或表示日期或时区。 相反，它是在挂钟上看到的当地时间的描述。 它不能代表时间线上的即时信息，没有附加信息，如偏移或时区。

  • 字段

static LocalTime MAX最大支持LocalTime，LocalTime ：59：59.999999999。

static LocalTime MIDNIGHT午夜开始的时候，00：00。

static LocalTime MIN最低支持LocalTime ，`00：00’。

static LocalTime NOON中午的时候，12：00。

Modifier and TypeMethodDescription
TemporaladjustInto(Temporal temporal)调整指定的时间对象与此对象具有相同的时间。
LocalDateTimeatDate(LocalDate date)结合这个时间与创建一个 LocalDateTime的日期。
OffsetTimeatOffset(ZoneOffset offset)结合这个时间与偏移创建一个 OffsetTime 。
intcompareTo(LocalTime other)比较这个 LocalTime到另一个时间。
booleanequals(Object obj)检查这次是否等于另一次。
Stringformat(DateTimeFormatter formatter)此时使用指定的格式化程序格式化。
static LocalTimefrom(TemporalAccessor temporal)从时间对象获取一个 LocalTime的实例。
intget(TemporalField field)从此时间获取指定字段的 int 。
intgetHour()获取时间字段。
longgetLong(TemporalField field)从此时间获取指定字段的值为 long 。
intgetMinute()获取小时字段。
intgetNano()获得纳秒第二场。
intgetSecond()获得第二分钟的字段。
inthashCode()这个时候的哈希码。
booleanisAfter(LocalTime other)检查 LocalTime是否在指定的时间之后。
booleanisBefore(LocalTime other)检查这个 LocalTime是否在指定的时间之前。
booleanisSupported(TemporalField field)检查指定的字段是否受支持。
booleanisSupported(TemporalUnit unit)检查指定的单位是否受支持。
LocalTimeminus(long amountToSubtract, TemporalUnit unit)返回此次的副本，减去指定的金额。
LocalTimeminus(TemporalAmount amountToSubtract)返回此次的副本，减去指定的金额。
LocalTimeminusHours(long hoursToSubtract)以指定的时间段返回此 LocalTime的副本， LocalTime数字。
LocalTimeminusMinutes(long minutesToSubtract)返回此 LocalTime的副本，其中指定的时间间隔以分钟为单位。
LocalTimeminusNanos(long nanosToSubtract)以指定的时间段返回此 LocalTime的副本，以纳秒为单位。
LocalTimeminusSeconds(long secondsToSubtract)返回此 LocalTime的副本，其中指定的时间间隔以秒为单位。
static LocalTimenow()从默认时区的系统时钟获取当前时间。
static LocalTimenow(Clock clock)从指定的时钟获取当前时间。
static LocalTimenow(ZoneId zone)从指定时区的系统时钟获取当前时间。
static LocalTimeof(int hour, int minute)从一小时分钟获取一个 LocalTime的实例。
static LocalTimeof(int hour, int minute, int second)从一小时，一分钟和秒钟获得一个 LocalTime的实例。
static LocalTimeof(int hour, int minute, int second, int nanoOfSecond)从一小时，分钟，秒和纳秒获取 LocalTime一个实例。
static LocalTimeofNanoOfDay(long nanoOfDay)从 LocalTime值获取 LocalTime的实例。
static LocalTimeofSecondOfDay(long secondOfDay)从第二天的值获取一个 LocalTime的实例。
static LocalTimeparse(CharSequence text)从一个文本字符串（如 10:15获取一个 LocalTime的实例。
static LocalTimeparse(CharSequence text, DateTimeFormatter formatter)使用特定的格式化 LocalTime从文本字符串获取 LocalTime的实例。
LocalTimeplus(long amountToAdd, TemporalUnit unit)返回此时添加了指定数量的副本。
LocalTimeplus(TemporalAmount amountToAdd)返回此时添加了指定数量的副本。
LocalTimeplusHours(long hoursToAdd)以指定的时间（以小时为单位）返回此 LocalTime的副本。
LocalTimeplusMinutes(long minutesToAdd)以指定的时间（以分钟为单位）返回此 LocalTime的副本。
LocalTimeplusNanos(long nanosToAdd)返回这个 LocalTime的副本，指定的时间段以纳秒为单位。
LocalTimeplusSeconds(long secondstoAdd)以指定的时间段（以秒为单位）返回此 LocalTime的副本。
<R> Rquery(TemporalQuery<R> query)此时使用指定的查询进行查询。
ValueRangerange(TemporalField field)获取指定字段的有效值的范围。
longtoNanoOfDay()提取时间为天数，从 0到 24 * 60 * 60 * 1,000,000,000 - 1 。
inttoSecondOfDay()提取时间为一天的时间，从 0到 24 * 60 * 60 - 1 。
StringtoString()此时输出为 String ，如 10:15 。
LocalTimetruncatedTo(TemporalUnit unit)返回此 LocalTime的副本， LocalTime时间。
longuntil(Temporal endExclusive, TemporalUnit unit)根据指定的单位计算直到另一次的时间量。
LocalTimewith(TemporalAdjuster adjuster)返回此次调整后的副本。
LocalTimewith(TemporalField field, long newValue)返回此时间的副本，并将指定的字段设置为新值。
LocalTimewithHour(int hour)返回此日期值更改的 LocalTime的副本。
LocalTimewithMinute(int minute)返回这个 LocalTime的副本，小时值更改。
LocalTimewithNano(int nanoOfSecond)返回这个 LocalTime的副本，纳秒变化值。
LocalTimewithSecond(int second)返回这个 LocalTime的副本，其中二分之一值更改。

LocalDateTime

LocalDateTime是一个不可变的日期时间对象，代表日期时间，通常被视为年 - 月 - 日 - 时 - 分 - 秒。 也可以访问其他日期和时间字段，例如日期，星期几和星期。 时间表示为纳秒精度。 例如，值2007-10-2T13：45.30.123456789可以存储在LocalDateTime 。

该类不存储或表示时区。 相反，它是对日子的描述，如用于生日，结合当地时间在挂钟上看到的。 它不能代表时间线上的即时信息，没有附加信息，如偏移或时区。

以上LocalDate，LocalTime方法均可使用

public class Test6 {
    public static void main(String[] args) {
        //1.完成实例化：
        //方法1：now()--获取当前的日期，时间，日期+时间
        LocalDate localDate = LocalDate.now();
        System.out.println(localDate); //2021-08-09
        LocalTime localTime = LocalTime.now();
        System.out.println(localTime); //07:50:21.523
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localDateTime); //2021-08-09T07:50:21.523
        //方法2：of()--设置指定的日期，时间，日期+时间
        LocalDate of = LocalDate.of(2016, 8, 6);
        System.out.println(of); //2016-08-06
        LocalTime of1 = LocalTime.of(12, 38, 26);
        System.out.println(of1); //12:38:26
        LocalDateTime of2 = LocalDateTime.of(1992, 6, 24, 16, 28, 52);
        System.out.println(of2); //1992-06-24T16:28:52
        //LocalDate,LocalTime用的不如LocalDateTime多
        //下面讲解用LocalDateTime：
        //get()
        System.out.println(localDateTime.getYear());//2021
        System.out.println(localDateTime.getMonth());//AUGUST
        System.out.println(localDateTime.getMonthValue());//8
        System.out.println(localDateTime.getDayOfMonth());//9
        System.out.println(localDateTime.getDayOfWeek());//MONDAY
        System.out.println(localDateTime.getHour());//7
        System.out.println(localDateTime.getMinute());//50
        System.out.println(localDateTime.getSecond());//21
        //不是set()，而是with()，不可变性
        LocalDateTime localDateTime2 = localDateTime.withMonth(8);
        System.out.println(localDateTime); //2021-08-09T07:50:21.523
        System.out.println(localDateTime2);//2021-08-09T07:50:21.523
        //提供了加减方法
        //加：
        LocalDateTime localDateTime1 = localDateTime.plusMonths(4);
        System.out.println(localDateTime1); //2021-12-09T07:50:21.523
        //减：
        LocalDateTime localDateTime3 = localDateTime.minusMonths(5);
        System.out.println(localDateTime3); //2021-03-09T07:50:21.523
    }
}

DateTimeFormatter

模式基于简单的字母和符号序列。 使用模式创建一个格式化器使用ofPattern(String)和ofPattern(String, Locale)方法。 从模式创建的格式化程序可以根据需要多次使用，它是不可变的并且是线程安全的。例如， "d MMM uuuu"将格式2011-12-03，为“2011年12月3日”。

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy MM dd");
String text = date.toString(formatter);
LocalDate date = LocalDate.parse(text, formatter);
格式化
SymbolMeaningPresentationExamples
GeratextAD; Anno Domini; A
uyearyear2004; 04
yyear-of-erayear2004; 04
Dday-of-yearnumber189
M/Lmonth-of-yearnumber/text7; 07; Jul; July; J
dday-of-monthnumber10
Q/qquarter-of-yearnumber/text3; 03; Q3; 3rd quarter
Yweek-based-yearyear1996; 96
wweek-of-week-based-yearnumber27
Wweek-of-monthnumber4
Eday-of-weektextTue; Tuesday; T
e/clocalized day-of-weeknumber/text2; 02; Tue; Tuesday; T
Fweek-of-monthnumber3
aam-pm-of-daytextPM
hclock-hour-of-am-pm (1-12)number12
Khour-of-am-pm (0-11)number0
kclock-hour-of-am-pm (1-24)number0
Hhour-of-day (0-23)number0
mminute-of-hournumber30
ssecond-of-minutenumber55
Sfraction-of-secondfraction978
Amilli-of-daynumber1234
nnano-of-secondnumber987654321
Nnano-of-daynumber1234000000
Vtime-zone IDzone-idAmerica/Los_Angeles; Z; -08:30
ztime-zone namezone-namePacific Standard Time; PST
Olocalized zone-offsetoffset-OGMT+8; GMT+08:00; UTC-08:00;
Xzone-offset ‘Z’ for zerooffset-XZ; -08; -0830; -08:30; -083015; -08:30:15;
xzone-offsetoffset-x+0000; -08; -0830; -08:30; -083015; -08:30:15;
Zzone-offsetoffset-Z+0000; -0800; -08:00;
ppad nextpad modifier1
’escape for textdelimiter
‘’single quoteliteral’
[optional section start
]optional section end
#reserved for future use
{reserved for future use
}reserved for future use
字段

Modifier and Type均为static DateTimeFormatter

FieldDescription
BASIC_ISO_DATE格式化或解析没有偏移量的日期的ISO日期格式化程序，例如“20111203”。
ISO_DATEISO日期格式化程序格式化或解析具有偏移量的日期（如可用），如“2011-12-03”或“2011-12-03 + 01：00”。
ISO_DATE_TIME类似ISO的日期格式化程序，用于格式化或解析具有偏移量和区域（如果有的话）的日期时间，如“2011-12-03T10：15：30”，2011-12-03T10：15：30 + 01 ：00'或’2011-12-03T10：15：30 + 01：00 [欧洲/巴黎]’。
ISO_INSTANTISO即时格式化程序，用于格式化或解析UTC中的即时消息，例如“2011-12-03T10：15：30Z”。
ISO_LOCAL_DATEISO日期格式化程序格式化或解析没有偏移量的日期，如“2011-12-03”。
ISO_LOCAL_DATE_TIMEISO日期格式化程序格式化或解析没有偏移量的日期时间，例如“2011-12-03T10：15：30”。
ISO_LOCAL_TIMEISO时间格式化程序格式化或解析一个没有偏移量的时间，例如“10：15”或“10：15：30”。
ISO_OFFSET_DATEISO日期格式化程序格式化或解析具有偏移量的日期，例如“2011-12-03 + 01：00”。
ISO_OFFSET_DATE_TIMEISO日期格式化程序格式化或解析具有偏移量的日期时间，例如“2011-12-03T10：15：30 + 01：00”。
ISO_OFFSET_TIME格式化或解析时间偏移的ISO时间格式化程序，如“10：15 + 01：00”或“10：15：30 + 01：00”。
ISO_ORDINAL_DATEISO日期格式化程序格式化或解析没有偏移量的序数日期，例如“2012-337”。
ISO_TIME格式化或解析时间的ISO时间格式化程序，如果可用的偏移量，如“10：15”，“10：15：30”或“10：15：30 + 01：00”。
ISO_WEEK_DATEISO日期格式化程序，用于格式化或解析不带偏移量的基于周的日期，例如“2012-W48-6”。
ISO_ZONED_DATE_TIME类似ISO的日期格式化程序，用于格式化或解析具有偏移和区域的日期时间，例如“2011-12-03T10：15：30 + 01：00 [Europe / Paris]”。
RFC_1123_DATE_TIMERFC-1123日期格式化程序，如“星期二，2008年6月3日11:05:30 GMT”。
方法
Modifier and TypeMethodDescription
Stringformat(TemporalAccessor temporal)使用此格式化程序格式化日期时间对象。
voidformatTo(TemporalAccessor temporal, Appendable appendable)格式化一个日期时间对象到 Appendable使用这个格式化程序。
ChronologygetChronology()获得在格式化期间使用的压倒一记的年表。
DecimalStylegetDecimalStyle()获取在格式化期间使用的DecimalStyle。
LocalegetLocale()获取格式化期间要使用的区域设置。
Set<TemporalField>getResolverFields()获取在解析期间使用的解析器字段。
ResolverStylegetResolverStyle()获取在解析过程中使用的解析器样式。
ZoneIdgetZone()获取在格式化期间使用的覆盖区域。
static DateTimeFormatterofLocalizedDate(FormatStyle dateStyle)返回ISO年表的区域设置特定日期格式。
static DateTimeFormatterofLocalizedDateTime(FormatStyle dateTimeStyle)返回ISO时代的区域设置特定的日期时间格式化程序。
static DateTimeFormatterofLocalizedDateTime(FormatStyle dateStyle, FormatStyle timeStyle)返回ISO时代的特定日期和时间格式。
static DateTimeFormatterofLocalizedTime(FormatStyle timeStyle)返回ISO时代的区域设置特定时间格式。
static DateTimeFormatterofPattern(String pattern)使用指定的模式创建格式化程序。
static DateTimeFormatterofPattern(String pattern, Locale locale)使用指定的模式和区域设置创建格式化程序。
TemporalAccessorparse(CharSequence text)完全解析产生时间对象的文本。
TemporalAccessorparse(CharSequence text, ParsePosition position)使用此格式化器解析文本，提供对文本位置的控制。
<T> Tparse(CharSequence text, TemporalQuery<T> query)完全解析产生指定类型对象的文本。
TemporalAccessorparseBest(CharSequence text, TemporalQuery<?>... queries)完全解析产生指定类型之一的对象的文本。
static TemporalQuery<Period>parsedExcessDays()一个查询，可以访问已解析的多余天数。
static TemporalQuery<Boolean>parsedLeapSecond()提供访问是否解析了跨越秒的查询。
TemporalAccessorparseUnresolved(CharSequence text, ParsePosition position)使用此格式化程序解析文本，而无需解析结果，用于高级用例。
FormattoFormat()将此格式化程序作为 java.text.Format实例返回。
FormattoFormat(TemporalQuery<?> parseQuery)将此格式化器返回为 java.text.Format实例，将使用指定的查询进行解析。
StringtoString()返回底层格式化程序的描述。
DateTimeFormatterwithChronology(Chronology chrono)使用新的覆盖年表返回此格式化程序的副本。
DateTimeFormatterwithDecimalStyle(DecimalStyle decimalStyle)使用新的DecimalStyle返回此格式化程序的副本。
DateTimeFormatterwithLocale(Locale locale)使用新的语言环境返回此格式化程序的副本。
DateTimeFormatterwithResolverFields(Set<TemporalField> resolverFields)使用一组新的解析器字段返回此格式化程序的副本。
DateTimeFormatterwithResolverFields(TemporalField... resolverFields)使用一组新的解析器字段返回此格式化程序的副本。
DateTimeFormatterwithResolverStyle(ResolverStyle resolverStyle)使用新的解析器样式返回此格式化程序的副本。
DateTimeFormatterwithZone(ZoneId zone)使用新的覆盖区域返回此格式化程序的副本。
格式化实例
  • 预定义的标准格式。如: ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;IS0_LOCAL_TIME
  • 本地化相关的格式。如: oflocalizedDateTime(para)，para参数
    • FormatStyle.LONG 2021年8月9日 上午08时37分39秒
    • FormatStyle.MEDIUM 2021-8-9 8:36:55
    • FormatStyle.SHORT 21-8-9 上午8:35
  • 自定义的格式。如:ofPattern( "yyyy-MM-dd hh:mm:ss")
public class Test7 {
    public static void main(String[] args) {
        //格式化类：DateTimeFormatter

        //方式一:预定义的标准格式。如: ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;IS0_LOCAL_TIME
        DateTimeFormatter df1 = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        //df1就可以帮我们完成LocalDateTime和String之间的相互转换：
        //LocalDateTime-->String:
        LocalDateTime now = LocalDateTime.now();
        String str = df1.format(now);
        System.out.println(str); //2021-08-09T08:38:15.755
        //String--->LocalDateTime
        TemporalAccessor parse = df1.parse("2020-09-26T14:34:25.356");
        System.out.println(parse); //{},ISO resolved to 2020-09-26T14:34:25.356

        //方式二:本地化相关的格式。如: oflocalizedDateTime()
        /*
        参数：FormatStyle.LONG 2021年8月9日 上午08时37分39秒/
        FormatStyle.MEDIUM 2021-8-9 8:36:55/ FormatStyle.SHORT 21-8-9 上午8:35
        */
        DateTimeFormatter df2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        //LocalDateTime-->String:
        LocalDateTime now1 = LocalDateTime.now();
        String str2 = df2.format(now1);
        System.out.println(str2); //21-8-9 上午8:38
        //String--->LocalDateTime
        TemporalAccessor parse1 = df2.parse("21-08-09 上午6:18");
        System.out.println(parse1); //{},ISO resolved to 2021-08-09T06:18

        //方式三: 自定义的格式。如: ofPattern( "yyyy-MM-dd hh:mm:ss")
        DateTimeFormatter df3 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh:mm:ss");
        //LocalDateTime-->String:
        LocalDateTime now2 = LocalDateTime.now();
        String format = df3.format(now2);
        System.out.println(format); //2021-08-09 08:38:15
        //String--->LocalDateTime
        TemporalAccessor parse2 = df3.parse("2021-08-09 08:29:11");
        /*{MinuteOfHour=29, MilliOfSecond=0, HourOfAmPm=8, MicroOfSecond=0, 
        SecondOfMinute=11, NanoOfSecond=0},ISO resolved to 2021-08-09*/
        System.out.println(parse2); 
    }
}
posted @ 2021-08-09 08:48  SKPrimin  阅读(432)  评论(0)  编辑  收藏  举报