Java基础--常用API--日期相关API

一、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时间。

import java.util.Date;

public class Demo {
    public static void main(String[] args) {
        Date date = new Date();// 实例化一个Date类，用于获取当前系统时间
        System.out.println(date);// 输出时间，Thu May 23 14:10:49 JST 2019

        System.out.println(date.getTime());// 输出毫秒值，1558588249722

        date.setTime(date.getTime() + 1000);// 手动增加1000毫秒
        System.out.println(date.getTime());// 输出毫秒值，1558588250722
    }
}

二、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--秒

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

public class Demo {
    public static void main(String[] args) {
        Date date = new Date();// 实例化一个Date类，用于获取当前系统时间
        System.out.println(date);// 输出时间，Thu May 23 14:36:10 JST 2019

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd E HH-mm-ss");
        String str = sdf.format(date);// 按照指定格式转为字符串
        System.out.println(str);// 输出转换后的时间，2019-05-23 星期四 14-36-10
        try {
            // 将字符串转为Date，Thu May 23 14:36:10 JST 2019
            System.out.println(sdf.parse(str));
        } catch (ParseException e) {
            System.out.println("格式转换异常。");
        }
    }
}

三、java.util.Formatter

　　1、java1.5版本前后，使用Formatter转换格式。

　　2、使用String类的format()方法时，默认调用Formatter的format()方法。

　　3、public Formatter format(String format, Object ... args) ; //对参数进行格式化。

　　4、使用 %tx 表示格式， 其中 x 表示日期转换符。若格式化同一日期，则需在格式化模式中增加<,例如%tY%<tm，此时只需写一个new Date()。否则需要对每个格式写一个new Date()或Calendar对象。

　　

　　5、格式规则：
　　　　%tc 输出格式： 星期 月 日 时：分：秒 时区 年
　　　　%tF 输出格式：年-月-日
　　　　%tD 输出格式：月/日/年
　　　　%tr 输出格式：时：分：秒 （12小时制）
　　　　%tT 输出格式：时：分：秒（24小时制）
　　　　%tR 输出格式：时：分（24小时制）

import java.util.Date;
import java.util.Formatter;

public class Demo {
    public static void main(String[] args) {
        Date date = new Date();// 实例化一个Date类，用于获取当前系统时间
        System.out.println(date);// 输出时间，Thu May 23 15:10:46 JST 2019

        Formatter fomat = new Formatter();
        Formatter strDemo1 = fomat.format("%tY年%<tm月%<td日", date);
        System.out.println(strDemo1);// 输出，2019年05月23日，使用<时，只需写一个date。

        String strDemo2 = String.format("%tY年%tm月%td日", date, date, date);
        System.out.println(strDemo2);// 输出，2019年05月23日

        String strDemo3 = String.format("%tc", date);//默认调用Formatter的format方法
        System.out.println(strDemo3);// 输出，星期四 五月 23 15:10:46 JST 2019
    }
}

四、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

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

public class Demo {
    public static void main(String[] args) {
        Date date = new Date();// 获取系统时间
        System.out.println(date);// 输出系统时间，Thu May 23 15:46:00 JST 2019

        date.setTime(date.getTime() + 1000 * 60);// 设置时间

        Calendar calendar = Calendar.getInstance();// 获取日历类
        calendar.setTime(date);// 将Date转为Calendar
        System.out.println(calendar.getTime()); // 将Calendar转为Date，Thu May 23 15:47:00 JST 2019

       System.out.println(calendar.get(Calendar.MONTH)); // 获取月份，输出4，4表示5月
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 获取星期几，输出5，5表示星期四

        calendar.set(Calendar.DAY_OF_WEEK, 6);// 设置星期为星期5
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 输出星期几，输出6，表示星期五。

        System.out.println(calendar.getActualMaximum(Calendar.DAY_OF_MONTH));// 获取这个月最大的天数，输出31

        calendar.add(Calendar.DAY_OF_WEEK, 2);// 给星期加2天
        System.out.println(calendar.get(Calendar.DAY_OF_WEEK));// 输出1，表示星期天。
     }
}

五、获取时间戳的方法、快慢

　　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 8新特性

　　1、上述讲解了几个相关日期类，处理日期比较麻烦，且线程不安全。

　　　　举个例子：（使用上述几个类操作日期）

输入一个日期（String），输出3年、3月、3星期后的星期三的日期（String） 。
分析：
1、先将String转为Date；
2、再将Date转为Calendar；
3、通过Calendar的方法计算时间分量；
4、计算完后将Calendar转为Date；
5、最后再将Date转为String。

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

public class Demo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入日期：格式为yyyy-MM-dd :");
        String str = scanner.nextLine(); // 获取输入的字符串

        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        try {
            Date date = sdf.parse(str);// 将字符串转为Date
            System.out.println(date);

            Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);// 将Date转为Calendar

            calendar.add(Calendar.YEAR, 3);// 给日期加三年
            calendar.add(Calendar.MONTH, 3);// 给日期加三月
            calendar.add(Calendar.WEEK_OF_YEAR, 3);// 给日期加三个星期
            calendar.set(Calendar.DAY_OF_WEEK, 4);// 设置日期为星期三

            date = calendar.getTime();// 将Calendar转为Date
            System.out.println(date);

            str = sdf.format(date);// 将Date转为String
            System.out.println(str);
        } catch (ParseException e) {
            System.out.println("输入格式错误！");
        }
    }
}

/*
测试结果：
请输入日期：格式为yyyy-MM-dd :
2019-5-23
Thu May 23 00:00:00 JST 2019
Wed Sep 14 00:00:00 JST 2022
2022-09-14
*/

　　2、java.time包是在JDK 8 之后引入的，提供了用于日期、时间、周期等的API。其所有类均为不可变的，线程安全的。

　　3、常用类：

　　　　（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; 此类用来计算两同类型日期的时间差。

import java.sql.Time;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.Date;

public class Test {
    public static void main(String args[]) {
        // java.time.LocalDateTime,格式为：年-月-日T时：分：秒.毫秒
        LocalDateTime ldt = LocalDateTime.now();
        System.out.println(ldt);// 输出2019-05-23T12:51:36.494
        System.out.println(ldt.withNano(0));// 将毫秒设为0，输出为2019-05-23T12:55:13

        // java.time.LocalDate，格式为：年-月-日
        LocalDate ld = LocalDate.now();
        System.out.println(ld);// 输出2019-05-23

        // java.time.LocalTime，格式为：时：分：秒.毫秒
        LocalTime lt = LocalTime.now();
        System.out.println(lt);// 输出为12:53:44.954
    }
}

　　4、注意：
　　　　（1）java.time中，星期一的值为1，星期天的值为7.且月份从 1~12。

　　　　（2）java.util.Calendar中，星期天为1，星期六为7，且月份从 0~11。

　　　　（3）对于time相关类，属于不可变类，原理类似String（参考String值变化的情况）。若其值改变，会重新创建一个实例。

七、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); //修改日，会返回一个新的实例。

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

public class Demo {
    public static void main(String[] args) {
        LocalDateTime ldt = LocalDateTime.now(); // 获取当前系统时间
        System.out.println("当前时间为： " + ldt);
        System.out.println("当前年： " + ldt.getYear());
        System.out.println("当前月： " + ldt.getMonthValue());
        System.out.println("当前月中的日：  " + ldt.getDayOfMonth());
        System.out.println("当前星期： " + ldt.getDayOfWeek());
        System.out.println("当前年中的日： " + ldt.getDayOfYear());
        System.out.println("当前时：（24小时制） " + ldt.getHour());
        System.out.println("当前分： " + ldt.getMinute());
        System.out.println("当前秒： " + ldt.getSecond());
        System.out.println("当前毫秒： （末尾加6个0）" + ldt.getNano());
        System.out.println();

        LocalDateTime time = LocalDateTime.of(2019, 05, 23, 11, 24, 21);
        System.out.println("自定义时间为： " + time);

        LocalDateTime newTime = time.plusYears(1);
        System.out.println("给时间增加一年： " + newTime);

        LocalDateTime lastTime = time.minusMonths(2);
        System.out.println("给月份减二月： " + lastTime);

        LocalDateTime changeTime = time.withDayOfMonth(13);
        System.out.println("只修改日： " + changeTime);

        LocalDate ld = LocalDate.now();//此处不是LocalDateTime
        String flag = (ld.isLeapYear() == true) ? "是" : "不是";
        System.out.println("判断是否为闰年： " + ld.getYear() + flag + "闰年");
    }
}
/*
测试结果：
当前时间为： 2019-05-23T18:17:01.454
当前年： 2019
当前月： 5
当前月中的日：  23
当前星期： THURSDAY
当前年中的日： 143
当前时：（24小时制） 18
当前分： 17
当前秒： 1
当前毫秒： （末尾加6个0）454000000

自定义时间为： 2019-05-23T11:24:21
给时间增加一年： 2020-05-23T11:24:21
给月份减二月： 2019-03-23T11:24:21
只修改日： 2019-05-13T11:24:21
判断是否为闰年： 2019不是闰年
*/

八、java.time.Duration

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

import java.time.Duration;
import java.time.LocalDateTime;

public class Demo {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2019, 5, 2, 12, 1);// 获取开始日期
        LocalDateTime end = LocalDateTime.of(2019, 6, 1, 13, 1);// 获取结束日期

        Duration result = Duration.between(start, end);// 用于计算相差的日期
        System.out.println(result.toDays());// 相差的天
        System.out.println(result.toHours());// 相差的时间
        System.out.println(result.toMinutes());// 相差的分钟
        System.out.println(result.toMillis());// 相差的秒数
        System.out.println(result.toNanos());// 相差的毫秒数
    }
}
/*
测试结果：
30
721
43260
2595600000
2595600000000000
*/

九、java.time.Instant

　　1、用法类似于java.util.Date。

import java.time.Instant;

public class Demo {
    public static void main(String[] args) {
        Instant instant = Instant.now();
        System.out.println(instant);// 输出当前系统时间
        System.out.println(instant.toEpochMilli());// 获取当前的毫秒值
        // 当前时间与参数中的时间进行对比,在参数的时间之前,相同,之后的值分别是(-1,0,1)
        System.out.println(instant.compareTo(instant));
    }
}
/*
测试结果：
2019-05-23T09:41:29.213Z
1558604489213
0
*/

十、java.time.format.DateTimeFormatter　　

　　1、类似于java.text.SimpleDateFormat。但其只用来创建日期的显示模板。

　　2、parse()方法是一种静态方法，使用LocalDateTime.parse()来调用。

　　3、format()方法需要使用LocalDateTime等类来调用。

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Date;

public class Test {
    public static void main(String args[]) {
        // JDK 8之前，String转Date， Date转String如下：
        Date date = new Date();// 实例化一个Date，用于获取当前系统时间。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");// 定义一个格式
        System.out.println(date);// 输出当前系统时间
        System.out.println(sdf.format(date)); // 将Date转为String
        try {
            // 将String转为Date，此处需要抛出异常
            System.out.println(sdf.parse("2019-5-24"));
        } catch (ParseException e) {
            System.out.println("格式转换失败！");
        }

        // JDK 8后，引入新的日期类，String与Date互转如下：
        LocalDateTime ldt = LocalDateTime.now();// 获取当前系统时间
        // 定义格式
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        System.out.println(ldt);// 输出当前系统时间
        System.out.println(ldt.format(dtf));// 将Date转为String
        try {
            // 将String转为Date，注意，此处必须严格按照格式匹配，例如：MM不能写成5，只能写成05
            // 此处会抛异常
            System.out.println(LocalDateTime.parse("2019-5-24 12:22:33", dtf));
        } catch (DateTimeParseException e) {
            System.out.println("格式转换失败！");
        }
        // 这是正确的写法。注意LocalDateTime的格式为：yyyy-MM-dd HH:mm:ss
        // 而LlocalDate的格式为：yyyy-MM-dd，此处需要注意一下格式的写法。
        System.out.println(LocalDateTime.parse("2019-05-24 12:22:33", dtf));
    }
}
/*
测试结果：
Fri May 24 10:58:09 JST 2019
2019-05-24
Fri May 24 00:00:00 JST 2019
2019-05-24T10:58:09.681
2019-05-24 10:58:09
格式转换失败！
2019-05-24T12:22:33
*/