java日期类学习笔记_objects.equals date-CSDN博客

本文链接：https://blog.csdn.net/qq_42838450/article/details/106438518

文章目录

Java日期
Java8的日期与使用
- 1. 关键类
- 2. java8时间的使用
Java日期格式化

Java日期

1. java中日期类

1.1 继承关系

java.lang.Object

-->java.util.Date

-->java.sql.Date、java.sql.Time、java.sql.Timestamp

java.lang.Object

–>java.util.Calendar

主要讲解加粗的五个类

1.2 简单介绍

java.util.Date日期默认格式为：星期、月、日、小时、分、秒、年
–>java.sql.Date日期格式为：年月日
–>java.sql.Time日期格式为：时分秒
–>java.sql.Timestamp日期格式为：年月日时分秒纳秒（毫微秒）

java.util.Date是java.sql.Date,java.sql.Time,java.sql.Timestamp的父类

要想获得准确日期一般用用getTimestamp()方法。

java.util.Calendar类（日历类）Calendar类是一个抽象基类，主要用于日期之间的各种计算获取Calendar实例的方法：使用Calendar.getInstance()方法或调用它子类GregorianCalendar的构造器。

2. java.util.Date类

java.util 包提供了 Date 类来封装当前的日期和时间。 Date 类表示系统特定的时间戳，是java.sqlDate,Time,Timestamp的父类，可以精确到毫秒。Date 对象表示时间的默认顺序是星期、月、日、小时、分、秒、年。

2.1 构造函数

Date 类提供两个构造函数来实例化 Date 对象。

**Date()：**构造函数使用当前日期和时间来初始化对象。

**Date(long millisec)：**构造函数接收一个参数，该参数是从1970年1月1日起的毫秒数。

示例如下：

Date date1 = new Date();    // 调用无参数构造函数
System.out.println(date1.toString());    // 输出现在的时间
Date date2 = new Date(90000);    // 调用含有一个long类型参数的构造函数
System.out.println(date2);    // 输出：Thu Jan 01 08:01:30 CST 1970

**注意：**Date 类带 long 类型参数的构造方法获取的是距离 GMT 指定毫秒数的时间，60000 毫秒是一分钟，而 GMT（格林尼治标准时间）与 CST（中央标准时间）相差 8 小时，也就是说 1970 年 1 月 1 日 00:00:00 GMT 与 1970 年 1 月 1 日 08:00:00 CST 表示的是同一时间。因此距离 1970 年 1 月 1 日 00:00:00 CST 一分钟30秒的时间为 1970 年 1 月 1 日 00:01:30 CST，即使用 Date 对象表示为 Thu Jan 01 08:01:30 CST 1970。

java.util.Date类中的getYear()要加上1900才可得到实际年份，getMonth()则要加上1

2.2 常用方法

boolean	after(Date date) 若当调用此方法的Date对象在指定日期之后返回true,否则返回false。
boolean	before(Date date) 若当调用此方法的Date对象在指定日期之前返回true,否则返回false。
Object	clone( ) 返回此对象的副本。
int	compareTo(Date date) 比较当调用此方法的Date对象和指定日期。两者相等时候返回0。调用对象在指定日期之前则返回负数。调用对象在指定日期之后则返回正数。
int	compareTo(Object obj) 若obj是Date类型则操作等同于compareTo(Date) 。否则它抛出ClassCastException。
boolean	equals(Object date) 当调用此方法的Date对象和指定日期相等时候返回true,否则返回false。
long	getTime( ) 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
int	hashCode( ) 返回此对象的哈希码值。
void	setTime(long time) 用自1970年1月1日00:00:00 GMT以后time毫秒数设置时间和日期。
String	toString( ) 转换Date对象为String表示形式，并返回该字符串。

1.3 日期比较

Java使用以下三种方法来比较两个日期：

使用getTime( ) 方法获取两个日期（自1970年1月1日经历的微秒数值），然后比较这两个值。
使用方法before()，after()和equals()。例如，一个月的12号比18号早，则new Date(99, 2, 12).before(new Date (99, 2, 18))返回true。
使用compareTo()方法，它是由Comparable接口定义的，Date类实现了这个接口。

3. java.sql.Date

java.sql.Date 是针对SQL语句使用的，它只包含日期而没有时间部分,要想获得准确日期一般用用getTimestamp()

3.1 构造函数

使用给定毫秒时间值构造一个 Date 对象。

Date(long date)

例如:

Date date = new Date(System.currentTimeMillis());
System.out.println(date);

3.2 常用方法

void	setTime(long date) 使用给定毫秒时间值设置现有 Date 对象。
String	toString() 格式化日期转义形式 yyyy-MM-dd 的日期。
static Date	valueOf(String s) 将 JDBC 日期转义形式的字符串转换成 Date 值。

它跟也能通过**getTime()**方法返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。

3.3 互相转换

通过getTime()获得时间戳，互相转换。

//java.util.Date-->java.sql.Date
new java.sql.Date(new java.util.Date().getTime())
//java.sql.Date-->java.util.Date
new java.util.Date(new java.sql.Date(System.currentTimeMillis()).getTime())

4. java.sql.Time类

java.sql.Time类屏蔽了java.util.Date的日期有关的字段,因此，不能通过这个类访问日期有关的信息，比如：如果你通过sqlTime.getYear()方法去获取年有关的信息，此方法会抛出一个IllegalArgumentException异常。这是因为java.sql.Time在继承java.util.Date类的时候对父类进行了重写，禁用了日期访问的方法。之所以这么处理，是为了和数据库的Time数据类型相匹配，数据库的Time数据类行只是保存时间有关的字段。

4.1 构造方法

Time(long time)

使用毫秒时间值构造一个 Time对象。

4.2 可用方法

Instant	toInstant() 此方法总是引发UnsupportedOperationException，因为SQL Time值不具有日期组件，因此不应该使用此方法。
LocalTime	toLocalTime() 将此 Time对象转换为 LocalTime 。
String	toString() 以JDBC时间转义格式格式化。
static Time	valueOf(LocalTime time) 从LocalTime对象获取Time的实例，具有与给定的LocalTime相同的小时，分秒和秒值。
static Time	valueOf(String s) 将JDBC时间转义格式的字符串转换为 Time值。
void	setTime(long time) 使用毫秒时间值设置 Time对象。

5. java.sql.Timestamp

java.sql.Timestamp字段则对java.util.Date这个类进行了扩充，它在java.util.Date类的基础上增加了毫秒的时间访问控制，因此，你可以通过**getNanos()**方法去获取时间的毫微秒数（注意此处获取的时间是以毫微秒为单位的,1秒等于十亿毫微秒），同样的，这也是为了和数据库中的Timestamp数据类型进行匹配。

MySql的timestamp所能存储的时间范围为：‘1970-01-01 00:00:01.000000’ 到 ‘2038-01-19 03:14:07.999999’。

因为MySQL的timestamp类型是4个字节，最大值是2的31次方减1，也就是2147483647，转换成北京时间就是2038-01-19 11:14:07

5.1 构造方法

Timestamp(long time)

使用毫秒时间值构造一个 Timestamp对象。

5.2 所有方法

`boolean`	`after(Timestamp ts)`表示是否 `Timestamp`对象晚于给定 `Timestamp`对象。
`boolean`	`before(Timestamp ts)`指示此 `Timestamp`对象是否早于给定的 `Timestamp`对象。
`int`	`compareTo(Date o)`将此 `Timestamp`对象与给定的 `Date`对象进行比较。
`int`	`compareTo(Timestamp ts)`将此 `Timestamp`对象与给定的 `Timestamp`对象进行比较。
`boolean`	`equals(Object ts)`测试这个 `Timestamp`对象是否等于给定的对象。
`boolean`	`equals(Timestamp ts)`测试看看这个 `Timestamp`对象是否等于给定的 `Timestamp`对象。
`static Timestamp`	`from(Instant instant)`从`Instant`对象获取一个`Timestamp`的实例。
`int`	`getNanos()`获取此 `Timestamp`对象的 `nanos`值。
`long`	`getTime()`返回自1970年1月1日以来，由此 `Timestamp`对象表示的00:00:00 GMT的毫秒 `Timestamp` 。
`int`	`hashCode()`返回此对象的哈希码值。
`void`	`setNanos(int n)`将此 `Timestamp`对象的 `nanos`字段设置为给定值。
`void`	`setTime(long time)`设置此 `Timestamp`对象以表示1970年1月1日00:00:00 GMT后的 `time`毫秒的时间点。
`Instant`	`toInstant()`将此 `Timestamp`对象转换为 `Instant` 。
`LocalDateTime`	`toLocalDateTime()`将此 `Timestamp`对象转换为 `LocalDateTime` 。
`String`	`toString()`以JDBC时间戳转义格式格式化时间戳。
`static Timestamp`	`valueOf(LocalDateTime dateTime)`从 `LocalDateTime`对象获取 `Timestamp`的实例，具有与提供的相同年份，月份，月份，小时，分钟，秒和纳秒日期时间值作为提供的 `LocalDateTime` 。
`static Timestamp`	`valueOf(String s)`将JDBC时间戳转义格式的 `String`对象转换为 `Timestamp`值。

5.3 往数据库里存日期数据

java.sql.Date 只存储日期数据不存储时间数据

   // 会丢失时间数据 
   preparedStatement.setDate(1, newjava.sql.Date(date.getTime())); 
   //可以这样来处理 
   preparedStatement.setTimestamp(1, new Timestamp(new java.util.Date().getTime()));

5.4 从数据库中取数据

  //想要得到完整的数据，包括日期和时间，可以这样 
  java.util.Date d = resultSet.getTimestamp(1); 
  //这样处理更合适一些，可以避免一些潜在Timestamp问题 
  java.util.Date d = new java.util.Date(resultSet.getTimestamp(1).getTime());

注：
往数据库存储的时候可以接收java.util.Date类型再用getTime()方法得到代表那个Date对象的long值，再以这个long值构造一个Timestamp对象存进数据库中。

从存数据库里取的时候，可以先得到Timestamp用它的getTime()方法得到long值，再以这个long值构造一个java.util.Date对象，这样就可以对这个Date对象操作了。

6. java.util.Calendar类

java.util.Calendar类是java.util.Date类的一个更加深入，更加全面的替代。Java.util.Calendar类支持java.util.Date的所有功能，此外，Calendar还引入了多语言，多区域的特性，可以根据需要获取不同区域，不同时区的时间，Calendar还增加了比Date更加方便和快捷的许多操作，如获取一年当中的第几个星期，各个月的天数等便捷的方法。

几个注意点：首先，Calendar增加了毫秒的时间段，通过它可以获取时间点的毫秒值，而java.util.Date只是精确到秒。其次，Calendar过去年的时候是当前年份比如：2010，而Date获取年份的时获取到的是当前年份-1900的一个值（2010-1900=110，因此，你调用getYear后过去的值就是110）。最后Calendar是一个抽象类，所以只能够实例化，是因为此处的Calendar充当了一个类似于工厂的作用，在getInstance方法中实例化了Calendar子类GregorianCalendar，并把它返回给用户使用。

6.1 构造方法

创建 Calendar 对象不能使用 new 关键字，因为 Calendar 类是一个抽象类，但是它提供了一个 getInstance() 方法来获得 Calendar类的对象。getInstance() 方法返回一个 Calendar 对象，其日历字段已由当前日期和时间初始化。

Calendar c = Calendar.getInstance// 如果不设置时间，则默认为当前时间
c.set(2020, 5, 19); // 设置年月日，时分秒将默认采用当前值

6.2 常用方法

方法	描述
void add(int field, int amount)	根据日历的规则，为给定的日历字段 field 添加或减去指定的时间量 amount
boolean after(Object when)	判断此 Calendar 表示的时间是否在指定时间 when 之后，并返回判断结果
boolean before(Object when)	判断此 Calendar 表示的时间是否在指定时间 when 之前，并返回判断结果
void clear()	清空 Calendar 中的日期时间值
int compareTo(Calendar anotherCalendar)	比较两个 Calendar 对象表示的时间值（从格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒至现在的毫秒偏移量），大则返回 1，小则返回 -1，相等返回 0
int get(int field)	返回指定日历字段的值
int getActualMaximum(int field)	返回指定日历字段可能拥有的最大值
int getActualMinimum(int field)	返回指定日历字段可能拥有的最小值
int getFirstDayOfWeek()	获取一星期的第一天。根据不同的国家地区，返回不同的值
static Calendar getInstance()	使用默认时区和语言坏境获得一个日历
static Calendar getInstance(TimeZone zone)	使用指定时区和默认语言环境获得一个日历
static Calendar getInstance(TimeZone zone, Locale aLocale)	使用指定时区和语言环境获得一个日历
Date getTime()	返回一个表示此 Calendar 时间值（从格林威治时间 1970 年 01 月 01 日 00 时 00 分 00 秒至现在的毫秒偏移量）的 Date 对象
long getTimeInMillis()	返回此 Calendar 的时间值，以毫秒为单位
void set(int field, int value)	为指定的日历字段设置给定值
void set(int year, int month, int date)	设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值
void set(int year, int month, int date, int hourOfDay, int minute, int second)	设置字段 YEAR、MONTH、DAY_OF_MONTH、HOUR、 MINUTE 和 SECOND 的值
void setFirstDayOfWeek(int value)	设置一星期的第一天是哪一天
void setTimeInMillis(long millis)	用给定的 long 值设置此 Calendar 的当前时间值

6.3 Calendar 类常量

Calendar 类中定义了许多常量，分别表示不同的意义。

Calendar.YEAR：年份。
Calendar.MONTH：月份。
Calendar.DATE：日期。
Calendar.DAY_OF_MONTH：日期，和上面的字段意义完全相同。
Calendar.HOUR：12小时制的小时。
Calendar.HOUR_OF_DAY：24 小时制的小时。
Calendar.MINUTE：分钟。
Calendar.SECOND：秒。
Calendar.DAY_OF_WEEK：星期几。

例如，要获取当前月份可用如下代码：

int month = Calendar.getInstance().get(Calendar.MONTH);

如果整型变量 month 的值是 0，表示当前日历是在 1 月份；如果值是 11，则表示当前日历在 12 月份。

Java8的日期与使用

java8引入了一套全新的时间日期API。新的时间及日期API位于java.time中.

旧版的 Java 中，日期时间 API 存在诸多问题，其中有：

非线程安全 − java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。
设计很差 − Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。
时区处理麻烦 − 日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。

Java 8 在 java.time 包下提供了很多新的 API。以下为两个比较重要的 API：

Local(本地) − 简化了日期时间的处理，没有时区的问题。
Zoned(时区) − 通过制定的时区处理日期时间。

新的java.time包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作

1. 关键类

类名	描述
Instant	它代表的是时间戳。这可以从java.time.Clock类中获取，像这样： Instant current = Clock.system(ZoneId.of(“Asia/Tokyo”)).instant();
LocalDate	不包含具体时间的日期，比如2014-01-14。它可以用来存储生日，周年纪念日，入职日期等。
LocalTime	它代表的是不含日期的时间。
LocalDateTime	它包含了日期及时间，不过还是没有偏移信息或者说时区。
ZonedDateTime	这是一个包含时区的完整的日期时间，偏移量是以UTC/格林威治时间为基准的。

2. java8时间的使用

java8中LocalDate的类能用来表示今天的日期。

这个类与java.util.Date略有不同，因为它只包含日期，没有时间。
```
LocalDate today = LocalDate.now();
System.out.println("今天日期："+today);
```

java8中获取当前时间

这里用的是LocalTime类，默认的格式是hh:mm:ss:nnn

//获得时间
LocalTime localTime = LocalTime.now();
System.out.println("现在时间："+localTime);

java8获取当前的年月日

LocalDate类中提供了一些很方便的方法可以用来提取年月日以及其他的日期属性,特别方便，只需要使用对应的get方法就可以了，非常直观

//今天日期，只有包含日期
int year = today.getYear();
int month = today.getMonthValue();
int day = today.getDayOfMonth();
System.out.println("今天日期："+year+"/"+month+"/"+day);

java8中获取某个特定的日期

通过另一个方法，可以创建出任意一个日期，它接受年月日的参数，然后返回一个等价的LocalDate实例。在这个方法里，需要的日期你填写什么就是什么，不像之前的API中月份必须从0开始
```
//指定年月日输出
LocalDate date1 = LocalDate.of(2020,8,6);
System.out.println("指定日期："+date1);
```
java8中检查两个日期是否相等

LocalDate重写了equals方法来进行日期的比较：
```
//equals方法
System.out.println("今天是否为2020-06-06："+today.equals(date1));
```
增加时间里面的小时数

很多时候需要对时间进行操作，比如加一个小时来计算之后的时间，java8提供了更方便的方法如plusHours，这些方法返回的是一个新的LocalTime实例的引用，因为LocalTime是不可变的
```
//获得2个小时后时间
LocalTime twoHour = localTime.plusHours(2);
System.out.println("2个小时后时间："+twoHour);
```

修改日期

LocalDate是用来表示无时间的日期，他又一个plus()方法可以用来增加日，星期，月，ChronoUnit则用来表示时间单位，LocalDate也是不可变的，因此任何修改操作都会返回一个新的实例

//修改日期
LocalDate oneWeek = today.plusWeeks(2);
System.out.println("2周后日期："+oneWeek);

LocalDate pYear = today.minus(1, ChronoUnit.YEARS);
System.out.println("1年前日期："+pYear);

LocalDate nYear = today.plus(1, ChronoUnit.YEARS);
System.out.println("1年后日期："+nYear);

在java8中使用时钟

java8自带了Clock类，可以用来获取某个时区下（所以对时区是敏感的）当前的瞬时时间、日期。用来代替System.currentTimelnMillis()与TimeZone.getDefault()方法
```
Clock clock = Clock.systemUTC();
System.out.println("Clock："+clock);//得到SystemClock[Z]
Clock clock1 = Clock.systemDefaultZone();
System.out.println("Clock："+clock1);//得到SystemClock[Asia/Shanghai]
```
比较日期

如何判断某个日期在另一个日期的前面还是后面或者相等，在java8中，LocalDate类中使用isBefore()、isAfter()、equals()方法来比较两个日期。如果调用方法的那个日期比给定的日期要早的话，isBefore()方法会返回true。
java8中处理不同的时区

java8中不仅将日期和时间进行了分离，同时还有时区。比如ZonId代表的是某个特定时区，ZonedDateTime代表带时区的时间，等同于以前的GregorianCalendar类。使用该类，可以将本地时间转换成另一个时区中的对应时间。
```
ZoneId zoneId = ZoneId.of(ZoneId.SHORT_IDS.get("ACT"));
ZonedDateTime nowDateTimeInAustralia = ZonedDateTime.of(localDateTime,zoneId);
System.out.println("澳大利亚时区时间：："+nowDateTimeInAustralia);
```
检查闰年

LocalDate类由一个isLeapYear()方法来返回当前LocalDate对应的那年是否是闰年
```
//检查闰年
System.out.println("今年是否为闰年："+today.isLeapYear());
```
两个日期之间包含多少天，多少月

计算两个日期之间包含多少天、周、月、年。可以用java.time.Period类完成该功能。下面例子中将计算日期与将来的日期之间一共有几个月
```
//两个日期之间包含多少天，多少月
Period period = Period.between(today,date1);
System.out.println("今天和"+date1+"相差"+period.getMonths()+"月"+period.getDays()+"天");
```
使用ZoneOffset来新建OffsetDateTime获得偏移时间

使用它的静态方法ZoneOffset.of()方法来获取对应的时区，只要获得了这个偏移量，就可以用这个偏移量和LocalDateTime创建一个新的OffsetDateTime
```
//利用时区偏移量获得新时间
ZoneOffset zoneOffset = ZoneOffset.of("+05:40");
OffsetDateTime date = OffsetDateTime.of(localDateTime,zoneOffset);
System.out.println("日期时间时区偏移后："+date);
```
获取当前时间戳

java8获取时间戳特别简单。Instant类由一个静态的工厂方法now()可以返回当前时间戳
```
//当前时间戳
Instant timestamp = Instant.now();
System.out.println("当前时间戳："+timestamp);
```
可以看到，当前时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是java8以前的Date，可以使用这个两个类中的方法在这两个类型之间进行转换，比如用Date.from(Instant)将Instant转换成java.util.date，用Date.toInstant()将Date转换成Instant
在java8中使用预定义的格式器来对日期进行解析/格式化

在java8之前，时间日期的格式化非常麻烦，经常使用SimpleDateFormat来进行格式化，但是SimpleDateFormat并不是线程安全的。在java8中，引入了一个全新的线程安全的日期与时间格式器。并且预定义好了格式。
```
//解析日期
String date2 = "20201109";
LocalDate date2Format = LocalDate.parse(date2, DateTimeFormatter.BASIC_ISO_DATE);
System.out.println("字符转日期："+date2Format);
```
在java中使用自定义的格式器来解析日期

你可以给DateTimeFormatter的ofPattern静态方法()传入任何的模式，它会返回一个实例，这个模式的字面量与前例中是相同的。比如M代表月，m代表分，无效的模式会抛异常DateTimeParseException。
```
//解析日期2
String date3 = "2020-10-09";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
LocalDate date4 = LocalDate.parse(date3,formatter);
System.out.println("字符转日期2："+date4);
```

在java8中对日期进行格式化，转换成字符串

//格式化日期
DateTimeFormatter formatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss a");
String nowDate = localDateTime.format(formatter1);
System.out.println("日期转字符："+nowDate);

Java日期格式化

1. 继承关系

java.lang.Object

–>java.text.Format

-->java.text.DateFormat

-->java.text.SimpleDateFormat

格式化日期表示将日期/时间格式转换为预先定义的日期/时间格式。例如将日期“Fri May 18 15:46:24 CST2016” 格式转换为 “2016-5-18 15:46:24 星期五”的格式。

在 Java中，可以使用 DateFormat 类和 SimpleDateFormat 类来格式化日期

还可以利用printf或者**String.format()**格式化日期

SimpleDateFormat是一个以语言环境敏感的方式来格式化和分析日期的类。SimpleDateFormat允许你选择任何用户自定义日期时间格式来运行。例如：

public class DateDemo {
   public static void main(String args[]) {

      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
      System.out.println("现在时间: " + ft.format(dNow));
   }
}

2. DateFormat 类

DateFormat 是日期/时间格式化子类的抽象类，它以与语言无关的方式格式化并解析日期或时间。

2.1 构造方法

在创建 DateFormat 对象时不能使用 new 关键字，而应该使用 DateFormat 类中的静态方法 getDateInstance()，示例代码如下：

DateFormat df = DateFormat.getDatelnstance();

在创建了一个 DateFormat 对象后，可以调用该对象中的方法来对日期/时间进行格式化。

2.2 常用方法

方法	描述
String format(Date date)	将 Date 格式化日期/时间字符串
Calendar getCalendar()	获取与此日期/时间格式相关联的日历
static DateFormat getDateInstance()	获取具有默认格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style)	获取具有指定格式化风格和默认语言环境的日期格式
static DateFormat getDateInstance(int style, Locale locale)	获取具有指定格式化风格和指定语言环境的日期格式
static DateFormat getDateTimeInstance()	获取具有默认格式化风格和默认语言环境的日期/时间格式
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle)	获取具有指定日期/时间格式化风格和默认语言环境的日期/时间格式
static DateFormat getDateTimeInstance(int dateStyle,int timeStyle,Locale locale)	获取具有指定日期/时间格式化风格和指定语言环境的日期/时间格式
static DateFormat getTimeInstance()	获取具有默认格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style)	获取具有指定格式化风格和默认语言环境的时间格式
static DateFormat getTimeInstance(int style, Locale locale)	获取具有指定格式化风格和指定语言环境的时间格式
void setCalendar(Calendar newCalendar)	为此格式设置日历
Date parse(String source)	将给定的字符串解析成日期/时间

2.3 DateFormat 类格式化样式

DateFormat的格式化样式主要通过 DateFormat 常量设置。将不同的常量传入到上表所示的方法中，以控制结果的长度。DateFormat 类的常量如下。

SHORT：完全为数字，如 20.5.10 或 5:30pm。
MEDIUM：较长，如 May 10，2020。
LONG：更长，如 May 12，2020 或 11:15:32am。
FULL：是完全指定，如 Tuesday、May 10、2020 AD 或 11:l5:42am CST。

// 获取不同格式化风格和中国语言环境的日期
DateFormat df1 = DateFormat.getDateInstance(DateFormat.SHORT, Locale.CHINA);
// 获取不同格式化风格和中国语言环境的时间
DateFormat df5 = DateFormat.getTimeInstance(DateFormat.SHORT, Locale.CHINA);
// 将不同格式化风格的日期格式化为日期字符串
String date1 = df1.format(new Date());
// 将不同格式化风格的时间格式化为时间字符串
String time1 = df5.format(new Date());
System.out.println("完全为数字 SHORT：" + date1 + " " + time1);

3. SimpleDateFormat 类

如果使用 DateFormat 类格式化日期/时间并不能满足要求，那么就需要使用 DateFormat 类的子类——SimpleDateFormat。

SimpleDateFormat 是一个以与语言环境有关的方式来格式化和解析日期的具体类，它允许进行格式化（日期→文本）、解析（文本→日期）和规范化。SimpleDateFormat 使得可以选择任何用户定义的日期/时间格式的模式。

3.1 构造方法

SimpleDateFormat 类主要有如下 3 种构造方法：

SimpleDateFormat()：用默认的格式和默认的语言环境构造 SimpleDateFormat。
SimpleDateFormat(String pattern)：用指定的格式和默认的语言环境构造 SimpleDateFormat。
SimpleDateFormat(String pattern,Locale locale)：用指定的格式和指定的语言环境构造 SimpleDateFormat。

3.2 常用的字母及含义

SimpleDateFormat 自定义格式中常用的字母及含义如下表所示。

字母	含义	示例
y	年份。一般用 yy 表示两位年份，yyyy 表示 4 位年份	使用 yy 表示的年扮，如 11；使用 yyyy 表示的年份，如 2011
M	月份。一般用 MM 表示月份，如果使用 MMM，则会根据语言环境显示不同语言的月份	使用 MM 表示的月份，如 05；使用 MMM 表示月份，在 Locale.CHINA 语言环境下，如“十月”；在 Locale.US 语言环境下，如 Oct
d	月份中的天数。一般用 dd 表示天数	使用 dd 表示的天数，如 10
D	年份中的天数。表示当天是当年的第几天，用 D 表示	使用 D 表示的年份中的天数，如 295
E	星期几。用 E 表示，会根据语言环境的不同，显示不同语言的星期几	使用 E 表示星期几，在 Locale.CHINA 语言环境下，如“星期四”；在 Locale.US 语言环境下，如 Thu
H	一天中的小时数（0~23)。一般用 HH 表示小时数	使用 HH 表示的小时数，如 18
h	一天中的小时数（1~12)。一般使用 hh 表示小时数	使用 hh 表示的小时数，如 10 (注意 10 有可能是 10 点，也可能是 22 点）
m	分钟数。一般使用 mm 表示分钟数	使用 mm 表示的分钟数，如 29
s	秒数。一般使用 ss 表示秒数	使用 ss 表示的秒数，如 38
S	毫秒数。一般使用 SSS 表示毫秒数	使用 SSS 表示的毫秒数，如 156

3.3 格式化(日期->String)

public static void main(String[] args) {
	 Date now = new Date(); // 创建一个Date对象，获取当前时间
     // 指定格式化格式
     SimpleDateFormat f = new SimpleDateFormat("yyyy 年 MM 月 dd 日 E HH 点 mm 分 ss 秒");
     System.out.println(f.format(now)); // 将当前时间袼式化为指定的格式
 }

结果：

2020 年 05 月 19 日 星期二 22 点 59 分 38 秒

3.4 解析(String->日期)

//将字符串转化为时间
SimpleDateFormat sdf1=new SimpleDateFormat("dd-MM-yy");
String str="18-5-21";
try {
    Date date1=sdf1.parse(str);
    System.out.println("字符串转时间："+date1);
} catch (ParseException e) {
    e.printStackTrace();
}

结果：

字符串转时间：Tue May 18 00:00:00 CST 2021

4. 使用字符串格式化日期

4.1 日期和时间转换字符

printf方法可以很轻松地格式化时间和日期。使用两个字母格式，它以t开头并且以下面表格中的一个字母结尾。

字符	描述	例子
c	完整的日期和时间	Mon May 04 09:51:52 CDT 2009
F	ISO 8601 格式日期	2004-02-09
D	U.S. 格式日期 (月/日/年)	02/09/2004
T	24小时时间	18:05:19
r	12小时时间	06:05:19 pm
R	24小时时间，不包含秒	18:05
Y	4位年份(包含前导0)	2004
y	年份后2位(包含前导0)	04
C	年份前2位(包含前导0)	20
B	月份全称	February
b	月份简称	Feb
n	2位月份(包含前导0)	02
d	2位日子(包含前导0)	03
e	2位日子(不包含前导0)	9
A	星期全称	Monday
a	星期简称	Mon
j	3位年份(包含前导0)	069
H	2位小时(包含前导0), 00 到 23	18
k	2位小时(不包含前导0), 0 到 23	18
I	2位小时(包含前导0), 01 到 12	06
l	2位小时(不包含前导0), 1 到 12	6
M	2位分钟(包含前导0)	05
S	2位秒数(包含前导0)	19
L	3位毫秒(包含前导0)	047
N	9位纳秒(包含前导0)	047000000
P	大写上下午标志	PM
p	小写上下午标志	pm
z	从GMT的RFC 822数字偏移	-0800
Z	时区	PST
s	自 1970-01-01 00:00:00 GMT的秒数	1078884319
Q	自 1970-01-01 00:00:00 GMT的毫妙	1078884319047

实例：

 // 初始化 Date 对象     
 Date date = new Date();      
 // 显示完整日期和时间 按默认地区格式    
 String str = String.format("现在时间: %tc", date );
 System.out.printf(str);

如果你需要重复提供日期，那么利用这种方式来格式化它的每一部分就有点复杂了。因此，可以利用一个格式化字符串指出要被格式化的参数的索引。

索引必须紧跟在%后面，而且必须以$结束。例如：

public class DateDemo {

   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();
        
       // 使用toString()显示日期和时间
       System.out.printf("%1$s %2$tB %2$td, %2$tY", 
                         "现在时间:", date);
   }
}

也可以使用<标志。它表明先前被格式化的参数要被再次使用。例如：

public class DateDemo {
   public static void main(String args[]) {
       // 初始化 Date 对象
       Date date = new Date();
        
       // 显示格式化时间
       System.out.printf("%s %tB %<te, %<tY",
                           "现在时间:", date);
   }
}