Java中获取和时间日期的类及其常用方法的总结

JDK1.8之前关于获取时间和日期的API

1.java.lang.System类

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

   此方法是用于计算时间差

2.java.util.Date类

  表示特定的瞬间，精确到毫秒数
构造器：
 Date()：提供无参构造器创建的对象可以获取本地当前时间
 Date(long date):提供带参的构造器
    常用方法：
      >getTime()：返回自1970年1月1日以来此Date对象表示的毫秒数,返回的是long类型
      >toString()：把此Date对象转换为以下形式的String：dow mon dd hh;mm ss zzz yyy 其中：dow是一周中的某一天（Sun,Mon,Tue,Wed,Thu,Fir,Sat）,zzz是时间标准

 3.java.sql.Date对应着数据库中的日期类型的变量
      1.如何实例化：通过带参的构造器 Date(long 毫秒数)，只有这一种，别的已过时
        2.java.util.Date转换为java.sql.Date(sql中的date是继承位于util中的date的)
        Date date = new Date();
        java.sql.Date date2 = new java.sql.Date(date.getTime());

注意：sql中date的格式和util中date的格式不一样

import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        //Date的实例化
        //方式一：采用默认的构造器返回现在这个时间点的时间信息
        Date date = new Date();

        System.out.println(date);//自动调用toString方法 Mon Sep 02 00:16:39 CST 2019
        
        //调用date的getTime()方法，获取格林威治时间至今的毫秒数
        System.out.println(date.getTime()); //获取当前时间举例格林威治时间的毫秒数 1567354599454
        
        //方式二：采用带参的构造器，返回离格林威治时间过了多少毫秒数之后对应的时间信息
        Date date2 = new Date(1567085521998L);
        System.out.println(date2);//将毫秒数转换为了时间日期格式  Thu Aug 29 21:32:01 CST 2019

        Date date3 = new Date();
        
        //将Date类的时间信息转化为java.sql.Date类的时间信息,java.sql.Date必须是带参的构造器
        java.sql.Date date4 = new java.sql.Date(date3.getTime());
        System.out.println(date4); //2019-08-29
        
    }
}

SimpleDateFormat的使用

java.text.SimpleDateFormat类，Date类的API不易于国际化，大部分被废弃了，java.text.SimpleDateFormat类是一个不与语言环境有关的方式来格式化和解析日期的具体类，SimpleDateFormat是对Date日期时间信息的格式化和解析

它允许进行格式化：将日期时间信息转换为字符串

格式化的方式：

  1.SimpleDateFormat():默认的模式和语言环境创建对象
  2. public SimpleDateFormat(String pattern):该构造方法可以用参数pattern指定的格式创建一个对象，该对象调用：
  3.public String format(Date date):方法格式化时间对象date

解析：将指定格式的字符串转换为日期时间信息

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

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

public class SimpleDateFormatTest {
    public static void main(String[] args) {
        //SimpleDateFormat的实例化
        //使用默认的构造器创建的，一定要注意格式的统一
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat();

        Date date = new Date();
        System.out.println(date);//Fri Aug 30 21:19:43 CST 2019
        //格式化，将时间日期信息转换为字符串类型
        String format = simpleDateFormat.format(date);  //通过format方法对日期进行格式化
        System.out.println(format);//19-8-30 下午9:19
        //解析：将字符串类型转换为日期时间类型
        try { //parse()函数需要处理异常，因为他对日期时间的格式要求很严格，只能采用下面这个格式
            Date date1 = simpleDateFormat.parse("19-8-30 下午9:17"); //通过parse()方法对字符串进行解析
            System.out.println(date1); //Fri Aug 30 21:17:00 CST 2019
        } catch (ParseException e) {
            e.printStackTrace();
        }

        //使用带参的构造器，自定义日期的格式
        SimpleDateFormat simpleDateFormat1 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");//指定日期格式
        String format1 = simpleDateFormat1.format(date);   //格式化
        System.out.println(format1); //2019-08-30 09:38:51

        try { //parse()参数中要采用指定的日期时间格式，不然会处理异常
            Date parse = simpleDateFormat1.parse("2019-08-28 09:38:51"); //解析
            System.out.println(parse); //Wed Aug 28 09:38:51 CST 2019
        } catch (ParseException e) {
            e.printStackTrace();
        }
    }
}

 4.Calendar类的使用

java.util.Calendar(日历)类的使用
Calendar是一个基类也是一个抽象类，主要用于完成日期字段之间相互操作的功能

获取Calendar实例的方法

      》使用Calendar.getInstance（）静态方法，这种其实还是调用了子类GregorianCalendar的构造器
      》调用它的子类GregorianCalendar的构造器

一个Calendar的实例是系统时间的抽象表示，通过get(int field)方法获取想要的时间信息，如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()     //将日历类--->Date类
  》public fianl void setTime(Date date)  //将Date--->日历类

注意：获取月份时：一月是0，二月是1.。。。依次类推，12月为11
           获取雄起时，周日是1

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

public class CalendarTest {
    public static void main(String[] args) {
        //Calendar是抽象类
        //实例化
        //方式一：调用Calendar.getInstance（）方法
        //方式二：创建Calendar的子类GregorianCalendar对象

        Calendar instance = Calendar.getInstance();
        System.out.println(instance.getClass());//class java.util.GregorianCalendar

       //调用get()方法,参数为固定的那几个，看API，获取常用的时间息
        int i = instance.get(Calendar.DAY_OF_MONTH);//获取今天是这个月的几号，还可以get别的看API
        System.out.println(i);//1

        //调用set()方法，修改时间信息,将今天修改为这个月的23号
        instance.set(Calendar.DAY_OF_MONTH,23); //这里就是可变性
        i = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);//23

        //调用add()方法，增加时间信息，如增加天数,在几天是几号的基础上加3天
        instance.add(Calendar.DAY_OF_MONTH,3); //若是想减几天，可以将amount设置为负数
        i = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);//26

        //getTime方法 将日历类---->Date
        Date date = instance.getTime();
        System.out.println(date);//Thu Sep 26 09:51:37 CST 2019

        //setTime方法 将Date--->日历类
        Date date1 = new Date();
        instance.setTime(date1);
        i = instance.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);//1
    }
}

JDK8中新的时间日期API

  新日期时间API出现的背景

JDK1.0中包含了一个java.util.Date类，但是他的大多数方法已经在JDK1.1引入Calendar类之后被弃用，而Calendar并不比Date好多少，主要面临以下问题：

可变性：像日期和时间这样的类应该是不可变的，add、set方法会把时间日期给改变
偏移性：Date中的年份是从1900年开始的，而月份是从0开始的，创建Date带参数的构造器时可以指定年月日
格式化：格式化只对date有用。而calendar则不行

而且他们是线程不安全的

LocalTime、LocalDate、LocalDateTime

LocalDate、LocalTime、LocalDateTime类是其中比较重要的几个类，他们的实例是不可变的对象
LocalDate代表IOS格式（yyyy-MM-dd）的日期，可以存储生日、纪念日等日期
LocalTime表示一个时间而不是日期
LocalDateTime是用来表示日期和时间的，这是一个最常用的类之一

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

public class TimeTest {
    public static void main(String[] args) {
        //实例化
        //调用静态的now()方法，创建对象,当前的时间
        LocalTime localTime = LocalTime.now(); //获取当前时间
        LocalDate localDate = LocalDate.now(); //当前日期
        LocalDateTime localDateTime = LocalDateTime.now(); //当前日期时间

        System.out.println(localDate);//2019-09-01
        System.out.println(localTime);//10:32:02.515
        System.out.println(localDateTime);//2019-09-01T10:32:02.516

        //调用静态的of()方法，可以指定日期时间，没有偏移量
        LocalDateTime localDateTime1 = LocalDateTime.of(2019, 9, 1, 13, 23, 47);
        System.out.println(localDateTime1); //2019-09-01T13:23:47

        //getXXX()获取相关的时间信息
        System.out.println(localDateTime.getDayOfMonth());//1 这月的第几天
        System.out.println(localDateTime.getDayOfWeek());//SUNDAY 一周的星期几
        System.out.println(localDateTime.getDayOfYear());//244    一年的第几天
        System.out.println(localDateTime.getMonth());//9          获取月份
        System.out.println(localDateTime.getHour());//10          获取几点

        //with（）方法，设置时间信息
        LocalDateTime localDateTime2 = localDateTime.withDayOfMonth(5); //设置为5号
        //不可变性
        System.out.println(localDateTime2); //2019-09-05T10:45:34.100
        System.out.println(localDateTime);//2019-09-01T10:45:34.100

        //plusXXX()方法，对时间信息进行增加操作
        LocalDateTime localDateTime3 = localDateTime.plusDays(3); //增加三天3
        //不可变性
        System.out.println(localDateTime3); //2019-09-04T10:45:34.100
        System.out.println(localDateTime);//2019-09-01T10:45:34.100

        //minusXXX()方法，对时间信息进行减操作
        LocalDateTime localDateTime4 = localDateTime.minusMonths(3);
        //不可变性
        System.out.println(localDateTime4); //2019-06-04T10:45:34.100
        System.out.println(localDateTime);//2019-09-01T10:45:34.100
    }
}

Instant类的使用

Instance：时间线上的一个瞬时点，这可能被用来记录应用程序中的事件时间戳
在处理时间和日期的时候，我们通常会想到年、月、日、时、分、秒。然而，这只是时间的一个模型，是面向人类的。第二种通用模型是面向机器的，
或者说是连续的，在此模型中，时间线中的一个点表示为一个很大的数，这有利于计算机的处理，在UNIX中，这个数从1970年开始，以秒为单位，有利于
计算机的处理。在JAVA中，也是从1970年开始的，但以毫秒为单位。
java.time包通过值类型instance提供机器视图，不提供处理人类意义上的时间单位。instance表示时间线上的一个点，而不需要任何上下文信息，它只是简单的表示
自1970年1月1号0时0分0秒开始的秒数。因为java.time包是基于纳秒计算的，所以instant的精度可以达到纳秒级

import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;

public class InstantTest {
    public static void main(String[] args) {
        //instant的实例化
        //调用Instant类的now()的静态方法，得到的是本初子午线对应的时间
        Instant instant = Instant.now();
        System.out.println(instant);//2019-09-01T12:33:32.953Z ，现在北京时间为20：33差八个小时

        //可以通过Instant对象的atOffset()方法，处理时区的偏移
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8)); //将本初子午线时间加8个小时，转化为北京时间
        System.out.println(offsetDateTime);//2019-09-01T20:37:07.083+08:00

        //调用instant对象的toEpochMilli()方法，获取距离格林威治时间的毫秒数
        long l = instant.toEpochMilli();
        System.out.println(l);//1567341574767

        //通过静态的ofEpochMilli()方法参数为毫秒数，创建Instant对象
        Instant instant1 = Instant.ofEpochMilli(1567341574767l);//返回的还是本初子午线对应的时间
        System.out.println(instant1);//2019-09-01T12:39:34.767Z
    }
}

DateTimeFormatter的使用

格式化与解析日期和时间
java.time.format.DateTimeForamt类：该类提供了三种格式化的方法；
预定义的标准格式。如：
实例化的三种方式：
方式一：ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
方式二：本地化相关的格式：如：ofLocalizedDateTime(FormatStyle.LONG)
方式三: 重点，自定义的格式。如：ofPattern("yyyy-MM-dd hh:mm:ss E")

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

public class LocalDateFormatTest {
    public static void main(String[] args) {
        //DateTimeFormatter的实例化
        //方式一：预定义的标准格式ISO_LOCAL_DATE_TIME;ISO_LOCAL_DATE;ISO_LOCAL_TIME
        DateTimeFormatter isoLocalDate = DateTimeFormatter.ISO_LOCAL_DATE;
        LocalDateTime now = LocalDateTime.now();
        //格式化 日期-->字符串
        System.out.println(now); //2019-09-01T22:03:55.921
        String format = isoLocalDate.format(now); //返回String类型
        System.out.println(format);//2019-09-01
        //解析：  字符串-->日期
        TemporalAccessor parse = isoLocalDate.parse("2019-09-01");
        System.out.println(parse);//{},ISO resolved to 2019-09-01

        //方式二：ofLocalizedDateTime(),ofLocalizedDate(),ofLocalizedTime()，参数FormatStyle.FULL,
        //FormatStyle.SHORT,FormatStyle.medium,FormatStyle.LONG
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.FULL);//这里的方法由好几个呢参数也好几个

        //方式三:ofPattern()重点：参数自定义 ,例如
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofPattern("yyyy-MM-dd hh-mm-ss");
        //格式化
        String format1 = dateTimeFormatter1.format(LocalDateTime.now());
        System.out.println(format1);//2019-09-01 10-21-14
        //解析 注意这里的解析不需要处理异常
        TemporalAccessor parse1 = dateTimeFormatter1.parse("2019-09-01 10-21-14");
        System.out.println(parse1);//{MinuteOfHour=21, SecondOfMinute=14, MicroOfSecond=0, MilliOfSecond=0, HourOfAmPm=10, NanoOfSecond=0},ISO resolved to 2019-09-01
    }
}