一、JDK1.8前

1、java.util.Date

1、只用于显示系统时间，其大部分操作由Calendar代替。
格林威治时间（GMT）：指的是1970年1月1日0时，不同地区有时间差。
默认输出格式：星期、月、日、时、分、秒、时区、年
2、构造方法：
（1）public Date(); 无参构造创建的对象可以获取本机的当前日期与时间。
（2）public Date(long date); 根据自定义时间创建Date对象。date若为正数，则表示公元后，若为负数，则表示公元前。
3、常用方法：
（1）public long getTime(); 可以获取从1970年开始到现在时间的毫秒数。
（2）public void setTime(long time); 可以自定义date时间。

  1. import java.util.Date;
  3. public class Demo {
  4.     public static void main(String[] args) {
  5.         Date date = new Date();// 实例化一个Date类，用于获取当前系统时间
  6.         System.out.println(date);// 输出时间，Thu May 23 14:10:49 JST 2019
  8.         System.out.println(date.getTime());// 输出毫秒值，1558588249722
  10.         date.setTime(date.getTime() + 1000);// 手动增加1000毫秒
  11.         System.out.println(date.getTime());// 输出毫秒值，1558588250722
  12.     }
  13. }

2、java.text.SimpleDateFormat

1、java1.5版本前，使用该类作用是将字符串（String）与时间（Date）相互转换。
2、构造方法：
（1）public SimpleDateFormat(); 按照系统默认格式将Date转换为String。
（2）public SimpleDateFormat(String pattern); 按照自定义格式pattern转换。
3、常用方法：
（1）public final String format(Date date); 可以将Date转为String。
（2）public Date parse(String source) throws ParseException; 可以将String转为Date，使用时需要抛出异常（ParseException）。
4、格式规则：
y—年 M—月 d—日 E—星期 h—12进制小时 H—24进制小时 m—分 s—秒

  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  5. public class Demo {
  6.     public static void main(String[] args) {
  7.         Date date = new Date();// 实例化一个Date类，用于获取当前系统时间
  8.         System.out.println(date);// 输出时间，Thu May 23 14:36:10 JST 2019
  10.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd E HH-mm-ss");
  11.         String str = sdf.format(date);// 按照指定格式转为字符串
  12.         System.out.println(str);// 输出转换后的时间，2019-05-23 星期四 14-36-10
  13.         try {
  14.             // 将字符串转为Date，Thu May 23 14:36:10 JST 2019
  15.             System.out.println(sdf.parse(str));
  16.         } catch (ParseException e) {
  17.             System.out.println("格式转换异常。");
  18.         }
  19.     }
  20. }

3、java.util.Calendar

1、Calendar类是一个抽象类，不能被实例化，可以通过静态方法getInstance()初始化一个日历对象。默认为当前系统时间。该类用于封装日历信息，并对时间分量（年、月、日、时、分、秒）进行计算。
2、常用方法：
（1）public final Date getTime(); 将Calendar转为Date型。
（2）public final void setTime(Date date); 将Date型转为Calendar。
（3）public int get(int field);用于获取时间分量。其中field使用Calendar类的静态变量表示。

注意：
Calendar.Month 从0开始计数，即0表示1月，11表示12月。
Calendar.DAY_OF_WEEK 从1开始计数，即1表示星期天，7表示星期六。

（4）public void set(int field, int value);设置时间分量，value指要设置的值。
（5）public final void set(int year, int month, int date); 设置年月日。
（6）public int getActualMaximum(int field); 获取时间分量field的最大值。
（7）abstract public void add(int field, int amount); 加时间分量，若加天数时，field需使用Calendar.DAY_OF_YEAR

  1. import java.util.Calendar;
  2. import java.util.Date;
  4. public class Demo {
  5.     public static void main(String[] args) {
  6.         Date date = new Date();// 获取系统时间
  7.         System.out.println(date);// 输出系统时间，Thu May 23 15:46:00 JST 2019
  9.         date.setTime(date.getTime() + 1000 * 60);// 设置时间
  11.         Calendar calendar = Calendar.getInstance();// 获取日历类
  12.         calendar.setTime(date);// 将Date转为Calendar
  13.         System.out.println(calendar.getTime()); // 将Calendar转为Date，Thu May 23 15:47:00 JST 2019
  15.        System.out.println(calendar.get(Calendar.MONTH)); // 获取月份，输出4，4表示5月
  16.         System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 获取星期几，输出5，5表示星期四
  18.         calendar.set(Calendar.DAY_OF_WEEK, 6);// 设置星期为星期5
  19.         System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 输出星期几，输出6，表示星期五。
  21.         System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));// 获取这个月最大的天数，输出31
  23.         calendar.add(Calendar.DAY_OF_WEEK, 2);// 给星期加2天
  24.         System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 输出1，表示星期天。
  25.      }
  26. }

二、JDK1.8后

1、java.time包

java.time包是在JDK 8 之后引入的，提供了用于日期、时间、周期等的API。其所有类均为不可变的，线程安全的。
常用类：
（1）java.time.LocalDateTime：存储了时间与日期，格式为：年-月-日T时：分：秒.毫秒。比如：2019-05-23T12:51:36.494，可以使用withNano(0)将毫秒值设为0。
（2）java.time.LocalDate：存储了日期，格式为：年-月-日。比如：2019-05-23。
（3）java.time.LocalTime：存储了时间，格式为：时：分：秒.毫秒。比如：12:53:44.954。可以使用withNano(0)将毫秒值设为0。
（4）java.time.format.DateTimeFormatter：类似于java.text.SimpleDateFormat。但其只用来创建日期的显示模板，parse()（是一种静态方法）与format()方法需要使用LocalDateTime类来调用。
（5）java.time.Duration： 此类用来计算两同类型日期的时间差。

  1. import java.sql.Time;
  2. import java.time.LocalDate;
  3. import java.time.LocalDateTime;
  4. import java.time.LocalTime;
  5. import java.util.Date;
  7. public class Test {
  8.     public static void main(String args[]) {
  9.         // java.time.LocalDateTime,格式为：年-月-日T时：分：秒.毫秒
  10.         LocalDateTime ldt = LocalDateTime.now();
  11.         System.out.println(ldt);// 输出2019-05-23T12:51:36.494
  12.         System.out.println(ldt.withNano(0));// 将毫秒设为0，输出为2019-05-23T12:55:13
  14.         // java.time.LocalDate，格式为：年-月-日
  15.         LocalDate ld = LocalDate.now();
  16.         System.out.println(ld);// 输出2019-05-23
  18.         // java.time.LocalTime，格式为：时：分：秒.毫秒
  19.         LocalTime lt = LocalTime.now();
  20.         System.out.println(lt);// 输出为12:53:44.954
  21.     }
  22. }

注意：
（1）java.time中，星期一的值为1，星期天的值为7.且月份从 1~12。
（2）java.util.Calendar中，星期天为1，星期六为7，且月份从 0~11。
（3）对于time相关类，属于不可变类，原理类似String（参考String值变化的情况）。若其值改变，会重新创建一个实例。

  1. import java.time.LocalDate;
  2. import java.time.LocalDateTime;
  4. public class Demo {
  5.     public static void main(String[] args) {
  6.         LocalDateTime ldt = LocalDateTime.now(); // 获取当前系统时间
  7.         System.out.println("当前时间为： " + ldt);
  8.         System.out.println("当前年： " + ldt.getYear());
  9.         System.out.println("当前月： " + ldt.getMonthValue());
  10.         System.out.println("当前月中的日：  " + ldt.getDayOfMonth());
  11.         System.out.println("当前星期： " + ldt.getDayOfWeek());
  12.         System.out.println("当前年中的日： " + ldt.getDayOfYear());
  13.         System.out.println("当前时：（24小时制） " + ldt.getHour());
  14.         System.out.println("当前分： " + ldt.getMinute());
  15.         System.out.println("当前秒： " + ldt.getSecond());
  16.         System.out.println("当前毫秒： （末尾加6个0）" + ldt.getNano());
  17.         System.out.println();
  19.         LocalDateTime time = LocalDateTime.of(2019, 05, 23, 11, 24, 21);
  20.         System.out.println("自定义时间为： " + time);
  22.         LocalDateTime newTime = time.plusYears(1);
  23.         System.out.println("给时间增加一年： " + newTime);
  25.         LocalDateTime lastTime = time.minusMonths(2);
  26.         System.out.println("给月份减二月： " + lastTime);
  28.         LocalDateTime changeTime = time.withDayOfMonth(13);
  29.         System.out.println("只修改日： " + changeTime);
  31.         LocalDate ld = LocalDate.now();//此处不是LocalDateTime
  32.         String flag = (ld.isLeapYear() == true) ? "是" : "不是";
  33.         System.out.println("判断是否为闰年： " + ld.getYear() + flag + "闰年");
  34.     }
  35. }
  36. /*
  37. 测试结果：
  38. 当前时间为： 2019-05-23T18:17:01.454
  39. 当前年： 2019
  40. 当前月： 5
  41. 当前月中的日：  23
  42. 当前星期： THURSDAY
  43. 当前年中的日： 143
  44. 当前时：（24小时制） 18
  45. 当前分： 17
  46. 当前秒： 1
  47. 当前毫秒： （末尾加6个0）454000000
  49. 自定义时间为： 2019-05-23T11:24:21
  50. 给时间增加一年： 2020-05-23T11:24:21
  51. 给月份减二月： 2019-03-23T11:24:21
  52. 只修改日： 2019-05-13T11:24:21
  53. 判断是否为闰年： 2019不是闰年
  54. */

2、java.time.LocalDateTime

1、常用方法：
（1）public static LocalDateTime now(); 静态方法，获取当前系统时间。
（2）public static LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second) ; 静态方法，自定义时间
（3）public int getYear();获取年
（4）public LocalDateTime plusYears(long years); 增加年，会返回一个新的实例，若参数为负，也会出现减的效果。，
（5）public LocalDateTime minusMonths(long months);减月，会返回一个新的实例，若参数为负，会出现加的效果。
（6）public LocalDateTime withDayOfMonth(int dayOfMonth); 修改日，会返回一个新的实例。

3、java.time.format.DateTimeFormatter

1、类似于java.text.SimpleDateFormat。但其只用来创建日期的显示模板。
2、parse()方法是一种静态方法，使用LocalDateTime.parse()来调用。
3、format()方法需要使用LocalDateTime等类来调用。

  1. import java.text.ParseException;
  2. import java.text.SimpleDateFormat;
  3. import java.time.LocalDateTime;
  4. import java.time.format.DateTimeFormatter;
  5. import java.time.format.DateTimeParseException;
  6. import java.util.Date;
  8. public class Test {
  9.     public static void main(String args[]) {
  10.         // JDK 8之前，String转Date， Date转String如下：
  11.         Date date = new Date();// 实例化一个Date，用于获取当前系统时间。
  12.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");// 定义一个格式
  13.         System.out.println(date);// 输出当前系统时间
  14.         System.out.println(sdf.format(date)); // 将Date转为String
  15.         try {
  16.             // 将String转为Date，此处需要抛出异常
  17.             System.out.println(sdf.parse("2019-5-24"));
  18.         } catch (ParseException e) {
  19.             System.out.println("格式转换失败！");
  20.         }
  22.         // JDK 8后，引入新的日期类，String与Date互转如下：
  23.         LocalDateTime ldt = LocalDateTime.now();// 获取当前系统时间
  24.         // 定义格式
  25.         DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
  26.         System.out.println(ldt);// 输出当前系统时间
  27.         System.out.println(ldt.format(dtf));// 将Date转为String
  28.         try {
  29.             // 将String转为Date，注意，此处必须严格按照格式匹配，例如：MM不能写成5，只能写成05
  30.             // 此处会抛异常
  31.             System.out.println(LocalDateTime.parse("2019-5-24 12:22:33", dtf));
  32.         } catch (DateTimeParseException e) {
  33.             System.out.println("格式转换失败！");
  34.         }
  35.         // 这是正确的写法。注意LocalDateTime的格式为：yyyy-MM-dd HH:mm:ss
  36.         // 而LlocalDate的格式为：yyyy-MM-dd，此处需要注意一下格式的写法。
  37.         System.out.println(LocalDateTime.parse("2019-05-24 12:22:33", dtf));
  38.     }
  39. }
  40. /*
  41. 测试结果：
  42. Fri May 24 10:58:09 JST 2019
  43. 2019-05-24
  44. Fri May 24 00:00:00 JST 2019
  45. 2019-05-24T10:58:09.681
  46. 2019-05-24 10:58:09
  47. 格式转换失败！
  48. 2019-05-24T12:22:33
  49. */

4、java.time.Duration

此类用来计算两同类型日期的时间差。

  1. import java.time.Duration;
  2. import java.time.LocalDateTime;
  4. public class Demo {
  5.     public static void main(String[] args) {
  6.         LocalDateTime start = LocalDateTime.of(2019, 5, 2, 12, 1);// 获取开始日期
  7.         LocalDateTime end = LocalDateTime.of(2019, 6, 1, 13, 1);// 获取结束日期
  9.         Duration result = Duration.between(start, end);// 用于计算相差的日期
  10.         System.out.println(result.toDays());// 相差的天
  11.         System.out.println(result.toHours());// 相差的时间
  12.         System.out.println(result.toMinutes());// 相差的分钟
  13.         System.out.println(result.toMillis());// 相差的秒数
  14.         System.out.println(result.toNanos());// 相差的毫秒数
  15.     }
  16. }
  17. /*
  18. 测试结果：
  19. 30
  20. 721
  21. 43260
  22. 2595600000
  23. 2595600000000000
  24. */

三、时间戳

1、java.sql.Timestamp

时间戳是指格林威治时间1970年01月01日00时00分00秒(北京时间1970年01月01日08时00分00秒)起至现在的总秒数。
时间戳就是一种精度很高的类型，通常用来防止数据出现脏读现象，主要用在数据库上。
一般数据库里用Date这个类取出来的时候只能到精确到某一日;
但是Timestamp的话，可以精准到时间纳秒级别。

  1. package cn.xxs;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  6. public class Time {
  7.     public static void main(String[] args) {
  8.         String res = "2018-12-18 10:04:59";/** 时间 */
  9.         int s = 1545098699;/** 时间戳 */        
  10.         System.out.println("时间戳转换为时间:"+stampToDate(s));/** 时间戳转换为时间 */
  11.         System.out.println("时间转换为时间戳:"+dateToStamp(res));/** 时间转换为时间戳 */
  12.     }
  14.     /* 
  15.      * 将时间转换为时间戳
  16.      */    
  17.     public static String dateToStamp(String s){
  18.         SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  19.         String res = "";    
  20.         if (!"".equals(s)) {
  21.             try {
  22.                 res = String.valueOf(sdf.parse(s).getTime()/1000);
  23.             } catch (Exception e) {
  24.                 System.out.println("传入了null值");
  25.             }            
  26.         }else {    
  27.             long time = System.currentTimeMillis();  
  28.             res = String.valueOf(time/1000);
  29.         }
  31.         return res;         
  32.     }
  34.     /* 
  35.      * 将时间戳转换为时间
  36.      */
  37.     public static String stampToDate(int time){
  38.         SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  39.         String times = format.format(new Date(time * 1000L));
  40. //        System.out.println("日期格式---->" + times);
  41.         return times;
  42.     }
  43. }

2、获取时间戳的方法

1、public static native long currentTimeMillis(); //java.lang.System类，获取时间戳
2、public long getTime(); //java.util.Date类，可以获取从1970年开始到现在时间的毫秒数。
3、public long getTimeInMillis();//java.util.Calendar类，获取时间戳。
4、currentTimeMillis获取时间戳的速度最快。

参考资料： Java基础—常用API—日期相关API