关于日期时间类Date和Calender，存在很多问题：
1.Date的缺陷，我们知道 Date的setYear和getYear等函数是删除线显示的
原因在：比如2009-01-04日，那么获取的年竟然是109，所以是有问题的
2.Calender常常用于时间的回卷，经常使用的就是roll(Day_of_Year,-7)就是七天前
但是如果是2009-01-04日，那么七天前是2009-12-28日，而非2008年，这是因为它只对天回卷了，年没有回卷
3.显示转换和时区问题，都麻烦，不好处理
所以Date类中有很多方法都标有删除线，表示过时了，但是我们还是这戏过时的方法稍稍了解一下，然后看看新的日期时间类！
一、 Date类
Date类对象的创建：
1、创建一个当前时间的Date对象
//创建一个代表系统当前日期的Date对象
Date d = new Date();
import java.util.Date; public class Demo { public static void main(String[] args) { Date date = new Date(); System.out.println(date);//Fri Apr 03 16:04:49 CST 2020 System.out.println(date.getYear());//120 System.out.println(date.getYear()+1900);//2020 Date date2 = new Date(2018-1900,10-1,12); System.out.println(date2);//Fri Oct 12 00:00:00 CST 2018 } }
2、创建一个我们指定的时间的Date对象：
使用带参数的构造方法Date(int year, int month, int day) ，可以构造指定日期的Date类对象，Date类中年份的参数应该是实际需要代表的年份减去1900，实际需要代表的月份减去1以后的值。
//创建一个代表2014年6月12号的Date对象
Date d1 = new Date(2014-1900, 6-1, 12); （注意参数的设置）
3、正确获得一个date对象所包含的信息
如：
Date d2 = new Date(2014-1900, 6-1, 12);
//获得年份 （注意年份要加上1900，这样才是日期对象d2所代表的年份）
int year = d2.getYear() + 1900;
//获得月份 （注意月份要加1，这样才是日期对象d2所代表的月份）
int month = d2.getMonth() + 1;
//获得日期
int date = d2.getDate();
//获得小时
int hour = d2.getHours();//不设置默认为0
//获得分钟
int minute = d2.getMinutes();
//获得秒
int second = d2.getSeconds();
//获得星期 （注意：0代表星期日、1代表星期1、2代表星期2，其他的一次类推了）
int day = d2.getDay();
二、Calendar类
Calendar类的功能要比Date类强大很多，可以方便的进行日期的计算,获取日期中的信息时考虑了时区等问题。而且在实现方式上也比Date类要复杂一些
import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; public class Demo { public static void main(String[] args) { Calendar calendar = Calendar.getInstance(); System.out.println(calendar); Calendar calendar2 = calendar.getInstance(); calendar2.set(2018,10-1,13);//设置日期 calendar2.set(calendar.DATE, 10); System.out.println(calendar2.get(Calendar.DAY_OF_MONTH));//获取月份 GregorianCalendar gCalendar = new GregorianCalendar(); //GregorianCalendar方法判别是否为闰年 System.out.println(gCalendar.isLeapYear(2018)); } }
1、Calendar类对象的创建
Calendar类是一个抽象类，由于Calendar类是抽象类，且Calendar类的构造方法是protected的，所以无法使用Calendar类的构造方法来创建对象，API中提供了getInstance方法用来创建对象。
2、创建一个代表系统当前日期的Calendar对象
Calendar c = Calendar.getInstance();//默认是当前日期
3、创建一个指定日期的Calendar对象
使用Calendar类代表特定的时间，需要首先创建一个Calendar的对象，然后再设定该对象中的年月日参数来完成。
//创建一个代表2014年5月9日的Calendar对象
Calendar c1 = Calendar.getInstance();
c1.set(2014, 5 - 1, 9)；//调用：public final void set(int year,int month,int date)
4、Calendar类对象信息的设置与获得
1）Calendar类对象信息的设置
A、Set设置
如：Calendar c1 = Calendar.getInstance();
调用：public final void set(int year,int month,int date)
c1.set(2014, 6- 1, 9);//把Calendar对象c1的年月日分别设这为：2014、6、9
B、利用字段类型设置
如果只设定某个字段，例如日期的值，则可以使用public void set(int field,int value)
//把 c1对象代表的日期设置为10号，其它所有的数值会被重新计算
c1.set(Calendar.DATE,10);
//把c1对象代表的年份设置为2014年，其他的所有数值会被重新计算
c1.set(Calendar.YEAR,2015);
其他字段属性set的意义以此类推
Calendar类中用一下这些常量表示不同的意义，jdk内的很多类其实都是采用的这种思想
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——星期几
C、Add设置(可用与计算时间)
Calendar c1 = Calendar.getInstance();
//把c1对象的日期加上10，也就是c1所表的日期的10天后的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, 10);
//把c1对象的日期加上-10，也就是c1所表的日期的10天前的日期，其它所有的数值会被重新计算
c1.add(Calendar.DATE, -10);
其他字段属性的add的意义以此类推
2）、Calendar类对象信息的获得(使用get（）)
Calendar c1 = Calendar.getInstance();
// 获得年份
int year = c1.get(Calendar.YEAR);
// 获得月份
int month = c1.get(Calendar.MONTH) + 1;（MONTH+1）
// 获得日期
int date = c1.get(Calendar.DATE);
// 获得小时
int hour = c1.get(Calendar.HOUR_OF_DAY);
// 获得分钟
int minute = c1.get(Calendar.MINUTE);
// 获得秒
int second = c1.get(Calendar.SECOND);
// 获得星期几（注意（这个与Date类是不同的）：1代表星期日、2代表星期1、3代表星期二，以此类推）
int day = c1.get(Calendar.DAY_OF_WEEK);
三、 GregorianCalendar类
GregorianCalendar 是 Calendar 的一个具体子类，提供了世界上大多数国家使用的标准日历系统。
1、GregorianCalendar类对象的创建
GregorianCalendar有自己的构造方法，而其父类Calendar没有公开的构造方法。
GregorianCalendar() 在具有默认语言环境的默认时区内使用当前时间构造一个默认的 GregorianCalendar。
在具有默认语言环境的默认时区内构造一个带有给定日期设置的 GregorianCalendar。
GregorianCalendar(int year, int month, int dayOfMonth)
GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute) 。
GregorianCalendar(int year, int month, int dayOfMonth, int hourOfDay, int minute, int second)
2、创建一个代表当前日期的GregorianCalendar对象
GregorianCalendar gc = new GregorianCalendar();
//创建一个代表2014年6月19日的GregorianCalendar对象(注意参数设置，与其父类是一样，月份要减去1)
GregorianCalendar gc = new GregorianCalendar(2014,6-1,19);
3、另外：GregorianCalendar有一个方法：boolean isLeapYear(int year) 确定给定的年份是否为闰年
四、DateFormat类和SimpleDateFormat类
public class SimpleDateFormat extends DateFormat
是一个以与语言环境相关的方式来格式化和分析日期的具体类。
(日期时间输出的工具类)
它允许进行日期格式化（日期 -> 文本）、分析（文本 -> 日期）和规范化。所以SimpleDateFormat类可以实现：String 到 Date，Date到String的互转
五、日期类对象之间的互转
Date类对象与long型时间的互转
//1.将Date类的对象转换为long型时间
Date d= new Date();
//使用对象的getTime（）方法完成
long dLong = d.getTime();
//2.将long型时间转换为Date类的对象
long time = 1290876532190L;
//使用Date的构造方法完成
Date d2 = new Date(time);
Calendar对象和long型时间之间的互转
// 将Calendar对象转换为相对时间
Calendar c = Calendar.getInstance();
long t1 = c.getTimeInMillis();
// 将long转换为Calendar对象
Calendar c1 = Calendar.getInstance();
long t = 1252785271098L;
c1.setTimeInMillis(t1);
Calendar对象和Date对象之间的互转
//1 .将Calendar对象转换为Date(c.getTime())
Calendar c = Calendar.getInstance();
Date d = c.getTime();
// 2.将Date转换为Calendar对象(s.setTime(date))
Calendar c1 = Calendar.getInstance();
Date d1 = new Date();
//通过setTime（）方法后，日历c1所表示的日期就d1的日期
c1.setTime(d1);
//1.Date 转化String
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
String dateStr=sdf.format(new Date());
//2.String 转化Date
String str="2010-5-27";
SimpleDateFormat sdf= new SimpleDateFormat("yyyy-MM-dd");
Date birthday = sdf.parse(str);
六、利用以上各个类的功能，我们可以很简单的实现一些时间计算的功能，下面看几个方法：
l、判断是否是闰年
/**
* 给定一个年份判断该年份是否为闰年
*/
public static boolean isLeapYear(int year) {
GregorianCalendar calendar = new GregorianCalendar();
return calendar.isLeapYear(year);
}
2、获取当前日期的字符串表示形式
/**
* 利用SimpleDateFormat获取当前日期的字符串表示形式 格式：2009-5-05
*/
public static String getCurrentDate() {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
return dateFormat.format(System.currentTimeMillis());
}
3、给出任意一个年月日得到该天是星期几
/**
* 给出任意一个年月日得到该天是星期几
*/
public static int getWeek(String date) {
// 注意参数的大小写格式
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
Calendar c = Calendar.getInstance();
try {
Date d = dateFormat.parse(date);
c.setTime(d);
} catch (ParseException e) {
}
return c.get(Calendar.DAY_OF_WEEK)-1;
}
4、 获得今天n天以后或者n天以前是那一天
/**
* 获得距离今天n天的那一天的日期
*/
public static String getDistanceDay(int day) {
Calendar calen = Calendar.getInstance();
calen.add(Calendar.DAY_OF_MONTH, day);
Date date = calen.getTime();
// 这里也个用SimpleDateFormat的format（）进行格式化，然后以字符串形式返回格式化后的date
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
return dateFormat.format(date);
}
5、获得给定两个日期相差的天数
/**
* 获得给定两个日期相差的天数
*
*/
public static long getGapDays(String date1, String date2) {
String[] d1 = date1.split("-");
String[] d2 = date2.split("-");
Calendar c = Calendar.getInstance();
c.set(Integer.parseInt(d1[0]), Integer.parseInt(d1[1]), Integer
.parseInt(d1[2]), 0, 0, 0);
long l1 = c.getTimeInMillis();
c.set(Integer.parseInt(d2[0]), Integer.parseInt(d2[1]), Integer
.parseInt(d2[2]), 0, 0, 0);
long l2 = c.getTimeInMillis();
return (Math.abs(l1 - l2) / (24 * 60 * 60 * 1000));
}
java8引入了一套全新的时间日期API
GMT - 格林尼治标准时间,格林威治平均时间
Greenwich Mean Time
由于地球轨道并非圆形，其运行速度又随着地球与太阳的距离改变而出现变化，因此视太阳时欠缺均匀性。
视太阳日的长度同时亦受到地球自转轴相对轨道面的倾斜度所影响。
为着要纠正上述的不均匀性，天文学家计算地球非圆形轨迹与极轴倾斜对视太阳时的效应。
平太阳时就是指经修订后的视太阳时。在格林尼治子午线上的平太阳时称为世界时(UT0)，又叫格林尼治平时(GMT)。
UTC - 协调世界时
Universal Time Coordinated
UTC是国际无线电咨询委员会制定和推荐的，UTC相当于本初子午线(即经度0度)上的平均太阳时。
它是经过平均太阳时(以格林威治标准时间GMT)、地轴运动修正后的新时标以及以「秒」为单位的国际原子时所综合精算而成的时间，
计算过程相当严谨精密，因此若以「世界标准时间」的角度来说，UTC比GMT来得更加精准。
其误差值必须保持在0.9秒以内，若大于0.9秒则由位于巴黎的国际地球自转事务中央局发布闰秒，使UTC与地球自转周期一致。
所以基本上UTC的本质强调的是比GMT更为精确的世界时间标准.它其实是个更精确的GMT.
我们一般认为GMT和UTC是一样的，都与英国伦敦的本地时相同。
CST（Central Standard Time ）：却同时可以代表如下 4 个不同的时区：
Central Standard Time (USA) UT-6:00
Central Standard Time (Australia) UT+9:30
China Standard Time UT+8:00
Cuba Standard Time UT-4:00
CST可以同时表示美国，澳大利亚，中国，古巴四个国家的标准时间。
java.time包中的是类是不可变且线程安全的。新的时间及日期API位于java.time中，下面是一些关键类
●Instant——它代表的是时间戳
●LocalDate——不包含具体时间的日期，比如2014-01-14。它可以用来存储生日，周年纪念日，入职日期等。
●LocalTime——它代表的是不含日期的时间
●LocalDateTime——它包含了日期及时间，不过还是没有偏移信息或者说时区。
●ZonedDateTime——这是一个包含时区的完整的日期时间，偏移量是以UTC/格林威治时间为基准的。
java8是如何处理时间及日期的
public class Demo { public static void main(String[] args) { Date date = new Date(); System.out.println(date);//打印当前日期 Sun Apr 05 14:10:23 CST 2020 System.out.println(date.getYear()+1900);//打印当前年份 2020 System.out.println(date.getMonth());//打印当前月份 3 Date date2 = new Date(2018-1900,10-1,10);//自定义日期 System.out.println(date2);//打印date2时间 Wed Oct 10 00:00:00 CST 2018 //java8 LocalDate date1 = LocalDate.now();//java8下的时间表示 System.out.println(date1);//打印当前日期 2020-04-05 LocalTime time = LocalTime.now(); System.out.println(time);//打印当前时间 System.out.println(date1.getYear());//打印当前年份 System.out.println(date1.getMonthValue());//打印当前月份 System.out.println(date1.getDayOfMonth());//打印当前几号 LocalDate date3 = LocalDate.of(1997, 06, 29);//java8下的自定义日期 System.out.println(date3);//打印自定义日期 } }
1、如何在java8中获取当天的日期
java8中有个叫LocalDate的类，能用来表示今天的日期。这个类与java.util.Date略有不同，因为它只包含日期，没有时间。
可以看到，他创建了今天的日期却不包含时间信息，并且格式化了日期。
2、如何在java8中获取当前的年月日
LocalDate类中提供了一些很方便的方法可以用来提取年月日以及其他的日期属性,特别方便，只需要使用对应的getter方法就可以了，非常直观
3、在java8中如何获取某个指定的日期对象
通过另一个方法，可以创建出任意一个日期，它接受年月日的参数，然后返回一个等价的LocalDate实例。在这个方法里，需要的日期你填写什么就是什么，不想之前的API中月份必须从0开始
4、在java8中检查两个日期是否相等
LocalDate重写了equals方法来进行日期的比较，如下所示：
public class Demo { public static void main(String[] args) { LocalDate date1 = LocalDate.of(1997, 06, 29); LocalDate date2 = LocalDate.of(1997, 06, 29); System.out.println(date1.equals(date2));//true } }
5、在java8中如何检查重复事件对应的特殊日期，比如生日
在java中还有一个与时间日期相关的任务就是检查重复事件，比如每月的账单日
如何在java中判断是否是某个节日或者重复事件，使用MonthDay类。这个类由月日组合，不包含年信息，可以用来代表每年重复出现的一些日期或其他组合。他和新的日期库中的其他类一样也都是不可变且线程安全的，并且它还是一个值类（value class）。
public class Demo { public static void main(String[] args) { LocalDate date1 = LocalDate.of(1997, 06, 29); MonthDay birthday = MonthDay.from(date1); LocalDate date2 = LocalDate.now(); MonthDay toDay = MonthDay.from(date2); if (birthday == toDay) { System.out.println("今天是你的生日"); } else { System.out.println("今天不是你的生日"); } } }
通过列子可以看到MonthDay只存储了月日，对比两个日期的月日即可知道是否是特定的某个日子
6、如何在java8中获取当前时间
这个与第一个例子获取当前日期非常相似，这里用的是LocalTime类，默认的格式是hh:mm:ss:nnn
可以看到，这个时间是不包含日期的
7、如何增加时间里面的小时数
很多时候需要对时间进行操作，比如加一个小时来计算之后的时间，java8提供了更方便的方法 如plusHours，这些方法返回的是一个新的LocalTime实例的引用，因为LocalTime是不可变的
public class Demo { public static void main(String[] args) { LocalTime time1 = LocalTime.now(); System.out.println(time1);//16:17:02.485 LocalTime time2 = time1.plusHours(1); System.out.println(time2);//17:17:02.485 //有一个通用的增加方法 LocalTime time3 = time1.plus(1, ChronoUnit.HOURS); System.out.println(time3);//17:17:02.485 } }
8、如何获取1周后的日期
这个与前一个获取2小时后的时间的例子很相似，这里我们获取的是1周后的日期。LocalDate是用来表示无时间的日期，他又一个plus()方法可以用来增加日，星期，月，ChronoUnit则用来表示时间单位，LocalDate也是不可变的，因此任何修改操作都会返回一个新的实例
可以看到一周后的日期是什么，也可以用这个方法来增加一个月，一年，一小时，一分等等
public class Demo { public static void main(String[] args) { LocalDate date = LocalDate.now(); System.out.println(date);//2020-04-05 LocalDate date2 = date.plusWeeks(1); System.out.println(date2);//2020-04-12 LocalDate date3 = date.plus(1,ChronoUnit.WEEKS); System.out.println(date3); LocalDate date4 = date.minus(1, ChronoUnit.YEARS); System.out.println(date4); } }
9、一年前后的日期
在上个例子中我们使用了LocalDate的plus()方法来给日期增加日周月，现在我们用minus()方法来找出一年前的那天
10、在java8中使用时钟
java8自带了Clock类，可以用来获取某个时区下（所以对时区是敏感的）当前的瞬时时间、日期。用来代替System.currentTimelnMillis()与TimeZone.getDefault()方法
public class Demo { public static void main(String[] args) { System.out.println(System.currentTimeMillis());//1586076213903 System.out.println(Clock.systemUTC().millis());//1586076213904 System.out.println(TimeZone.getDefault());//un.util.calendar.ZoneInfo[id="Asia/Shanghai",offse System.out.println(Clock.systemDefaultZone());//SystemClock[Asia/Shanghai] } }
11、在java8中如何判断某个日期在另一个日期的前面还是后面
如何判断某个日期在另一个日期的前面还是后面或者相等，在java8中，LocalDate类中使用isBefore()、isAfter()、equals()方法来比较两个日期。如果调用方法的那个日期比给定的日期要早的话，isBefore()方法会返回true。equals()方法在前面的例子中已经说明了，这里就不举例了
可以看到java8中比较日期非常简单，不再需要使用Calendar这样另外的类来完成类似的任务了
public class Demo { public static void main(String[] args) { LocalDateTime d1 = LocalDateTime.of(2018, 10,10,10,10); LocalDateTime d2 = LocalDateTime.of(2018, 10,10,10,11); System.out.println(d1.isBefore(d2));//true System.out.println(d1.isAfter(d2));//false } }
12、在java8中处理不同的时区
java8中不仅将日期和时间进行了分离，同时还有时区。比如ZonId代表的是某个特定时区，ZonedDateTime代表带时区的时间，等同于以前的GregorianCalendar类。使用该类，可以将本地时间转换成另一个时区中的对应时间。
public class Demo { public static void main(String[] args) { // 在亚洲上海的这个时区，怎么获取utc时间 ZoneId zone = ZoneId.of("UTC"); ZonedDateTime zdt = ZonedDateTime.now(zone); System.out.println(zdt);//第一种获取utc时间 Instant instant = Instant.now(); System.out.println(instant); ZonedDateTime zdt1 = ZonedDateTime.ofInstant(instant,ZoneId.of("UTC")); System.out.println(zdt1);//通过时间戳获取utc时间 LocalDateTime cT = zdt.toLocalDateTime(); System.out.println(cT);//本地日期 // 在utc时间，怎么获取不同时区的时间 ZonedDateTime chinaTime = ZonedDateTime.of(cT, ZoneId.of(ZoneId.SHORT_IDS.get("CTT"))); System.out.println(chinaTime);//2020-04-05T14:27:40.996+08:00[Asia/Shanghai] ZonedDateTime losTime = ZonedDateTime.of(cT, ZoneId.of("America/Los_Angeles")); System.out.println(losTime);//2020-04-05T14:27:40.996-07:00[America/Los_Angeles] } }
13、YearMonth
正如MonthDay表示的是某个重复出现的日子，YearMonth是另外一个组合，你可以用这个类找出这个月有多少天，LengthOfMonth()这个方法返回的是这个YearMonth实例对应的月有多少天，这对于检查2月是否润2月很有用
public class Demo { public static void main(String[] args) { YearMonth yearMonth = YearMonth.of(2019, 12); System.out.println(yearMonth.lengthOfMonth());//31 System.out.println(yearMonth.lengthOfYear());//365 } }
14、如何在java8中检查闰年
LocalDate类由一个isLeapYear()方法来返回当前LocalDate对应的那年是否是闰年
public class Demo { public static void main(String[] args) { LocalDate date = LocalDate.of(2020, 1, 1); System.out.println(date.isLeapYear());//true } }
15、两个日期之间包含多少天，多少月，多少年（必须连起来）
计算两个日期之间对应相差多少天、月、年。可以用java.time.Period类完成该功能。
public class Demo { public static void main(String[] args) { LocalDate birthday = LocalDate.of(2000, 10, 9); LocalDate date = LocalDate.of(2020, 1, 1); Period period = Period.between(birthday, date); System.out.println(period.getYears()); System.out.println(period.getMonths()); System.out.println(period.getDays()); } }
16、在java8中获取当前时间戳
java8获取时间戳特别简单。Instant类由一个静态的工厂方法now()可以返回当前时间戳
public class Demo { public static void main(String[] args) { Instant instant = Instant.now(); System.out.println(instant);//2020-04-05T15:09:55.497Z Date date = Date.from(instant); System.out.println(date);//Sun Apr 05 23:09:55 CST 2020 Instant instan2 = date.toInstant(); System.out.println(instan2);//2020-04-05T15:11:07.203Z } }
可以看到，当前时间戳是包含日期和时间的，与java.util.Date很类似，事实上Instant就是java8以前的Date，可以使用这个两个类中的方法在这两个类型之间进行转换，比如Date.from(Instant)就是用来把Instant转换成java.util.date的，而Date.toInstant()就是将Date转换成Instant的
17、如何在java8中使用预定义的格式器来将String转换为日期对象
在java8之前，时间日期的格式化非常麻烦，经常使用SimpleDateFormat来进行格式化，但是SimpleDateFormat并不是线程安全的。在java8中，引入了一个全新的线程安全的日期与时间格式器。并且预定义好了很多格式。比如，BASICISODATE格式会将字符串20160414格式化成2016-04-14格式的日期对象
但是大多时候预置的不能满足需要，就只能自定义日期格式器了，下面的例子中的日期格式是"MM dd yyyy".你可以给DateTimeFormatter的ofPattern静态方法()传入任何的模式，它会返回一个实例，这个模式的字面量与前例中是相同的。比如M代表月，m仍代表分，无效的模式会抛异常DateTimeParseException。
public class Demo { public static void main(String[] args) { //String 转日期 String sdate = "20121012"; LocalDate date =LocalDate.parse(sdate,DateTimeFormatter.BASIC_ISO_DATE); System.out.println(date);//2012-10-12 } }
public class Demo { public static void main(String[] args) { //String 转日期 String sdate = "10 20 2013"; //自定义格式 LocalDate date =LocalDate.parse(sdate,DateTimeFormatter.ofPattern("MM dd yyyy")); System.out.println(date);//2013-10-20 } }
注意传入的字符串格式不对会报错：
19、如何在java8中对日期进行格式化，转换成字符串
前面的两个例子中，我们主要是对日期字符串来进行解析转换成日期，在这个例子我们相反，是把日期转换成字符。这里我们有个LocalDateTime类的实例，我们要把他转换成一个格式化好的日期串，与前例相同的是，我们仍需要制定模式串去创建一个DateTimeFormatter类的实例，但调用的是LocalDate.format()。这个方法会返回一个代表当前日期的字符串，对应的模式就是传入的DateTimeFormatter实例中定义好的。
public class Demo { public static void main(String[] args) { //日期转字符串 LocalDate date = LocalDate.now(); DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日"); String sdate1 = date.format(dtf); System.out.println(sdate1);//2020年04月05日 } }
java8中日期与时间API的几个关键点
经过上面的例子，我们已经对java8的时间日期有了一定的了解，现在回顾一下
●它提供了javax.time.ZoneId用来处理时区。
●它提供了LocalDate与LocalTime类
●Java 8中新的时间与日期API中的所有类都是不可变且线程安全的，这与之前的Date与Calendar API中的恰好相反，那里面像java.util.Date以及SimpleDateFormat这些关键的类都不是线程安全的。
●新的时间与日期API中很重要的一点是它定义清楚了基本的时间与日期的概念，比方说，瞬时时间，持续时间，日期，时间，时区以及时间段。它们都是基于ISO日历体系的。
每个Java开发人员都应该至少了解这套新的API中的这五个类：
●Instant 它代表的是时间戳，比如2016-04-14T14:20:13.592Z
●LocalDate 它表示的是不带时间的日期，比如2016-04-14。它可以用来存储生日，周年纪念日，入职日期等。
●LocalTime - 它表示的是不带日期的时间
●LocalDateTime - 它包含了时间与日期，不过没有带时区的偏移量
●ZonedDateTime - 这是一个带时区的完整时间，它根据UTC/格林威治时间来进行时区调整
关于日期时间类Date和Calender，存在很多问题：
1.Date的缺陷，我们知道 Date的setYear和getYear等函数是删除线显示的
原因在：比如2009-01-04日，那么获取的年竟然是109，所以是有问题的
2.Calender常常用于时间的回卷，经常使用的就是roll(Day_of_Year,-7)就是七天前
但是如果是2009-01-04日，那么七天前是2009-12-28日，而非2008年，这是因为它只对天回卷了，年没有回卷
3.显示转换和时区问题，都麻烦，不好处理
所以Date类中有很多方法都标有删除线，表示过时了，但是我们还是这戏过时的方法稍稍了解一下，然后看看新的日期时间类！