• 新手小白学JAVA 日期类Date SimpleDateFormat Calendar

    1. Date日期类
      类 Date 表示一个特定的瞬间，精确到毫秒

    1.1 Date的构造函数
    Date() 分配一个 Date 对象，以表示分配它的时间（精确到毫秒）
    Date(long date) 分配一个 Date 对象，表示自从标准基准时间起指定时间的毫秒数
    标准基准时间：称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00

    1.2 Date的构造函数练习
    创建包：cn.cxy.date
    创建类：TestDate1

    package cn.cxy.date;

import java.util.Date;

/*本类用于Date的入门*/
public class TestDate1 {
    public static void main(String[] args) {
        //1.利用无参构造创建Date类对象，注意导包：import java.util.Date;
        Date d1= new Date();
        System.out.println(d1);//Thu Sep 23 23:14:59 CST 2021

        //2.利用含参构造创建Date对象
        long t = 1000*60*60;//1000ms*60*60->1min*60->1h
        Date d2 = new Date(t);//从标准基础时间1970-1-1-00:00开始往后数1h
        System.out.println(d2);//Thu Jan 01 09:00:00 CST 1970
        //CST是中国时区，所以额外加了8h变成了09:00:00
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    常用时间缩写
    GMT 格林尼治时间 = UTC 协调世界时间
    UTC + 时区差 ＝ 本地时间,我们是在东八区，东加西减，所以
    CST 中国标准时间：China Standard Time UT+8:00

    1.3 Date的常用方法练习
    getTime() 返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒值
    setTime(long time) 设置时间，表示 1970 年 1 月 1 日 00:00:00 GMT 后的毫秒值

    创建包：cn.cxy.date
    创建类：TestDate2

    package cn.cxy.date;

import java.util.Date;

/*本类用于Date的常用方法测试*/
public class TestDate2 {
    public static void main(String[] args) {
        //1.创建Date对象
        Date d1 = new Date();
        //2.获取从标准基准时间到现在时间的毫秒值，是一个时间差
        System.out.println(d1.getTime());//1632404114206
        //*1.0是为了变成浮点型，/1000变成秒，/60变成分，/60变成小时，/24变成天，/365变成年
        System.out.println(d1.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365);//约等于51,从1970到2021

        //3.打印d1就是当前的时间
        System.out.println(d1);//Thu Sep 23 21:39:29 CST 2021
        //4设置一个long值，作为毫秒为单位的时间差
        long t = 1000*60*60;
        d1.setTime(t);
        System.out.println(d1);//打印的就是从标准基准时间经过时间差t的时间
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    1. SimpleDateFormat
      SimpleDateFormat 常用于格式化和解析日期
      日期和时间格式由日期和时间模式字符串指定，字母与日期时间的对应关系如下

    在这里插入图片描述

    2.1 常用构造函数
    SimpleDateFormat() 用默认模式的日期格式构造 SimpleDateFormat
    SimpleDateFormat(String pattern) 用给定模式的日期格式构造 SimpleDateFormat

    2.2 日期转换格式工具类练习
    创建包：cn.cxy.date
    创建类：TestSDF.java

    package cn.cxy.date;

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

/*本类用于测试SimpleDateFormat类*/
public class TestSDF {
    public static void main(String[] args) throws ParseException {
        /*01 格式化：从 Date 到 String*/
        //1.创建日期类对象，包含当前的时间
        Date d = new Date();
        //2.创建日期转换工具类的对象，此时使用的是无参构造
        //SimpleDateFormat sdf = new SimpleDateFormat();
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
        //3.通过刚刚创建好的工具类对象转换日期的格式
        String s = sdf2.format(d);
        //4.打印转换好的时间字符串：
        //默认时间格式：21-9-23 下午11:18
        //自定义时间格式：2021/09/23 10:21:39
        System.out.println(s);
        
        /*解析：从String到 Date*/
        //1.定义一个时间字符串
        String s2 = "2021/9/23 22:24:03";
        //报错：ParseException解析异常: Unparseable date不可分割日期: "2021/9/23 22:24:03"
        //SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日 hh:mm:ss");
        //2.利用含参构造创建工具类对象，指定格式，注意必须是规定格式，否则会抛出异常
        SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy/MM/dd hh:mm:ss");
        //3.利用工具类对象对日期进行转换
        Date d2= sdf3.parse(s2);
        //4.打印转换好的日期
        System.out.println(d2);//Thu Sep 23 22:24:03 CST 2021

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    2.3 日期转换综合练习
    创建包：cn.cxy.date2
    创建工具类：DateUtils.java

    package cn.cxy.date2;

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

/*本类用作日期类的工具类，一般工具类的要求：
* 构造方法私有化 & 成员方法静态化*/
public class DateUtils {
    //1.创建一个私有化的构造方法
    private DateUtils(){}

    //2.创建一个将日期转换为字符串的方法
    //参数：日期对象Date  日期转换的格式：format 返回值类型：String
    public static String dateToString(Date date, String format){
        //1.通过传入的日期格式，创建指定的工具类对象
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        //2.通过工具类对象将字符串转换为对应的日期字符串，并拿到转换后的字符串结果
        String s = sdf.format(date);/*转换*/
        //3.将最终转换的字符串结果返回
        return s;
    }

    //3.创建一个将字符串转换为日期的方法
    //参数：字符串对象String  日期转换的格式：format 返回值类型：Date
    public static Date stringToDate(String s, String format) throws ParseException {
        //1.通过传入的日期格式，创建指定的工具类对象
        SimpleDateFormat sdf = new SimpleDateFormat(format);
        //2.通过工具类对象将日期对象转换为对应的字符串，并拿到转换后的日期对象
        Date d = sdf.parse(s);/*解析*/
        //3.将最终转换的日期对象作为方法的结果返回
        return d;
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35

    创建包：cn.cxy.date2
    创建测试类：TestDate.java

    package cn.cxy.date2;

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

/*本类用于自定义日期工具类的测试类*/
public class TestDate {
    public static void main(String[] args) throws ParseException {
        //1.创建日期类对象
        Date d = new Date();
        //2.调用自定义日期工具类的功能：将日期对象转换成字符串
        String s = DateUtils.dateToString(d, "yyyy年MM月dd日 HH:mm:ss");
        String s2 = DateUtils.dateToString(d, "yyyy年MM月dd日");
        String s3 = DateUtils.dateToString(d, "HH:mm:ss");
        System.out.println(s);//2021年09月23日 10:55:32
        System.out.println(s2);//2021年09月23日
        System.out.println(s3);//10:58:21

        //3.调用自定义工具类的功能，将字符串转换为对应的日期对象
        //注意，此处的format格式必须与s字符串定义时的格式一致！！！否则转换会报错！
        Date d2 = DateUtils.stringToDate(s, "yyyy年MM月dd日 HH:mm:ss");
        System.out.println(d2);//Thu Sep 23 23:01:21 CST 2021
    }
}


    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    3.Calendar日历类
    3.1 概念
    Calendar 类是一个抽象类，不可直接实例化，但是它有一个直接已知子类GregorianCalendar
    它为特定瞬间与还有比如年月日等日历字段之间的转换和操作提供了一些方法

    3.2 常用方法
    Calendar提供了一个方法getInstance()用于获取Calendar对象，它的日历字段就是当前的日期

    int get(int field) 返回给定日历字段的值
    abstract void add(int field, int amount) 根据日历的规则，为给定的日历字段添加或减去指定的时间量
    void set(int year, int month, int date) 设置日历字段 YEAR、MONTH 和 DAY_OF_MONTH 的值

    3.3 入门案例
    创建包：cn.cxy.date3
    创建类：TestCalendar.java

    package cn.cxy.date3;

import org.junit.Test;

import java.util.Calendar;

/*本类用于练习日历类*/
public class TestCalendar {
    @Test
    public void TestGet(){
        //1.获取日历对象
        Calendar c = Calendar.getInstance();
        System.out.println(c);//能获取很多信息，比如MONTH=8，我们现在是9月，说明月份是从0开始的
        //2.通过获取到的日历对象，调用get(),传入对应的日历字段，就可以拿到对应的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        System.out.println(year + "年" + month + "月" + day + "日");//2021年9月24日
    }
    @Test
    public void TestAdd1(){
        //1.获取日历对象
        Calendar c = Calendar.getInstance();
        //2.给指定的日历字段进行指定数目的加减操作，得到10年后的今天
        c.add(Calendar.YEAR,+10);

        //3.通过获取到的日历对象，调用get(),传入对应的日历字段，就可以拿到对应的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        //4.打印的就是10年后的今天：2031年9月24日
        System.out.println(year + "年" + month + "月" + day + "日");
    }

    @Test
    public void TestAdd2(){//需求：打印1年后的7天后
        //1.获取日历对象
        Calendar c = Calendar.getInstance();
        //2.给指定的日历字段进行指定数目的加减操作，得到10年后的今天
        c.add(Calendar.YEAR,+1);
        c.add(Calendar.DAY_OF_MONTH,+7);

        //3.通过获取到的日历对象，调用get(),传入对应的日历字段，就可以拿到对应的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        //4.打印1年后的7天后：2022年10月1日
        System.out.println(year + "年" + month + "月" + day + "日");
    }

    @Test
    public void TestSet(){
        //1.获取日历对象
        Calendar c = Calendar.getInstance();
        //2.测试set方法
        c.set(2099,9,1);
        //3.通过获取到的日历对象，调用get(),传入对应的日历字段，就可以拿到对应的值
        int year = c.get(Calendar.YEAR);
        int month = c.get(Calendar.MONTH)+1;
        int day = c.get(Calendar.DAY_OF_MONTH);
        //4.打印：2099年10月1日
        System.out.println(year + "年" + month + "月" + day + "日");
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64

    3.4 巩固案例
    创建包：cn.cxy.date3
    创建类：TestCalendar.java
    需求：用户任意输入一个年份，输出这年的2月有多少天

    package cn.cxy.date3;

import java.util.Calendar;
import java.util.Scanner;

/*本类用于日历类的巩固练习
 * 需求：获取任意一年的2月有多少天*/
public class TestFeb {
    public static void main(String[] args) {
        //1.提示并接收用户要测试的年份：
        System.out.println("请您输入要查询的年份：");
        int year = new Scanner(System.in).nextInt();
        //2.获取日历类对象，并将时间设置为用户输入那年的3月1日
        Calendar c = Calendar.getInstance();
        c.set(year, 2, 1);
        //3.三月一日往前推一天就是2月的最后一天
        c.add(Calendar.DATE, -1);
        //4.获取这一天输出即可
        int date = c.get(Calendar.DATE);
        System.out.println(year + "年的2月有" + date + "天");
    }
}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
  • 相关阅读:
    JVM - 你们垃圾回收器用的什么？ G1有哪些特点？G1如何实现可预测的停顿时间？漏标问题如何解决的？介绍下三色标记？说说STAB 算法 ？
    精通Nginx（09）-重写
    LeetCode链表练习（下）
    go语言｜数据结构：二叉树可视化（svg树形图改进版）
    具体的多路分发器：EPollPoller
    Scala学习:类和对象
    Spring-AOP 讲解
    结构化日志记录增强网络安全性
    算法基础——时间复杂度和空间复杂度
    angular之formgroup
  • 原文地址：https://blog.csdn.net/weixin_58276266/article/details/127756199