时间日期类详细总结大全

最新推荐文章于 2023-09-20 22:32:12 发布

帕帕尼先生

最新推荐文章于 2023-09-20 22:32:12 发布

阅读量2k

点赞数 5

文章标签： java jdk

本文链接：https://blog.csdn.net/weixin_44928884/article/details/106651553

版权

jdk1.8之前的时间日期类

Date类

java.util.Date(父类)
----java.sql.Date(子类)

1.掌握构造器的使用
java.util.Date() //无参构造器
java.util.Date(long Date) //创建指定毫秒数的Date对象

java.sql.Date(long Date) //java.sql.Date 没有无参构造方法

2.两个常用方法的使用
toString()方法 //直接返回当前时间
getTime()方法 //返回1970年至今的毫秒数//此方法跟System.currentTimeMillis()方法类似

3.java.sql.Date //专门用于数据库的时间
java.util.Date -> java.sql.Date
java.sql.Date -> java.util.Date

package com.Lindom.时间日期;
import java.util.Date;
public class DateDemo {

    public static void main(String[] args) {

        //java.util.Date的无参构造及两个方法的使用
        Date date = new Date();
        System.out.println("date = " + date.toString());    //Sat Jun 06 23:12:31 CST 2020
        System.out.println("date = " + date.getTime());    //1591455534797 //此方法跟System.currentTimeMillis()方法类似
        System.out.println("------------------------");

        //java.util.Date的有参构造及toString方法的使用
        Date date1 = new Date(1591455534797L);  //创建指定毫秒数的Date对象
        System.out.println("date1 = " + date1.toString());  //Sat Jun 06 22:58:54 CST 2020
        System.out.println("------------------------");

        //java.sql.Date的有参构造
        java.sql.Date date2 = new java.sql.Date(1591455534797L);
        System.out.println("date2 = " + date2);    //2020-06-06


        System.out.println("---------关于转换问题---------------");

//        以下这个转换方法肯定报错：因为java.util.Date是父类，java.sql.Date是子类，将父类直接强转为子类的前提是：多态
//        也就是说，父类的引用指向子类对象，这样的情况下才可以进行强转！
//        Date date3 = new Date();
//        java.sql.Date date4 = (java.sql.Date)date3;
//        System.out.println(date4);

        //如下就是父类引用指向子类对象的强转例子,也是java.util.Date转为java.sql.Date 的一个方法
        Date date3 = new java.sql.Date(1111254125632L);
        java.util.Date date4 = (java.sql.Date)date3;
        System.out.println("date3 = " + date3);
        System.out.println("date4 = " + date4);
        System.out.println("------------------------");

        //如下方法是将不涉及多态的data5，转为java.sql.Date的一种的方法
        Date date5 = new Date();
        java.sql.Date date6 = new java.sql.Date(date5.getTime());
        System.out.println("date5 = " + date5);
        System.out.println("date6 = " + date6);
        System.out.println("------------------------");

        //如下方法是将不涉及多态的data7，转为java.util.Date的一种的方法
        java.sql.Date date7 = new java.sql.Date(1232541256321L);
        Date date8 = new Date(date7.getTime());
        System.out.println("date7 = " + date7);
        System.out.println("date8 = " + date8);
        System.out.println("------------------------");
    }
}

运行结果如下图所示：
在这里插入图片描述

Calendar类

Calendar: 日历类 jdk1.8之前

1.没有构造器，因为Calendar类是abstract的，无法通过new实例
只能通过getInstance()方法：获取实例；
或者通过Calendar 的子类 GregorianCalendar 获取实例

2.四个常用方法
get()方法
set()方法
add()方法
getTime()方法：日历类 —> Date
setTime()方法： Date —> 日历类

package com.Lindom.时间日期;
import java.util.Calendar;
import java.util.Date;
public class CalendarDemo {

    public static void main(String[] args) {
        //通过getInstance()方法实例了一个对象,通过getClass()方法可以查看到对象是GregorianCalendar类的
        System.out.println("-----------输出calendar和实例对象的类型-------------");
        Calendar calendar = Calendar.getInstance();
        Class<? extends Calendar> aClass = calendar.getClass();
        System.out.println(calendar);  //返回一长串东西
        System.out.println(aClass);  //class java.util.GregorianCalendar

        //get(Calendar.DAY_OF_MONTH)方法获得今天是本月第几天
        System.out.println("------------获取今天是本月第几天（get()方法）-----------");
        int i = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);

        //set(Calendar.DAY_OF_MONTH, 25): 将今天是本月第几天修改为25天；此方法无返回值
        System.out.println("--------------set()方法---------------------");
        calendar.set(Calendar.DAY_OF_MONTH, 25);
        i = calendar.get(Calendar.DAY_OF_MONTH);  //通过get()方法获取
        System.out.println(i);

        //add(Calendar.DAY_OF_MONTH,5)： 将今天是本月第几天加上5天；此方法无返回值
        System.out.println("--------------add()方法---------------------");
        calendar.add(Calendar.DAY_OF_MONTH,5);
        i = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);

        //getTime()方法将设置好的日历包装成一个Date类日期
        System.out.println("--------------getTime()方法---------------------");
        Date time = calendar.getTime();
        System.out.println(time); //Tue Jun 30 21:55:00 CST 2020

        //setTime(date)方法
        System.out.println("--------------setTime()方法---------------------");
        Date date = new Date();
        calendar.setTime(date);
        i = calendar.get(Calendar.DAY_OF_MONTH);
        System.out.println(i);
    }
}

运行结果如下图所示：
在这里插入图片描述

SimpleDateFormat类

SimpleDateFormat 格式化与解析时间日期类 jdk1.8之前

1.两种构造器的使用
SimpleDateFormat() ：此构造器返回默认的日期格式：20-6-8 下午12:08
SimpleDateFormat(String) :　此构造器返回指定日期格式（常用：yyyy-MM-dd HH:mm:ss）

2.两种方法的使用
format(date) : 格式化: 日期—>字符串
parse(date) : 解析：字符串—>日期

3.注意
需要 Date date = new Date(); 来创建一个时间

package com.Lindom.时间日期;
import org.junit.Test;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class SimpleDateFormatDemo {

    public static void main(String[] args) throws ParseException {    //这里需要抛出异常

        //无参构造器
        SimpleDateFormat sdf = new SimpleDateFormat();
        Date date = new Date();

        //format():格式化  返回一个中国日期  日期 ---> 字符串
        System.out.println("---------------格式化---------------");
        String format = sdf.format(date);
        System.out.println(date); //Mon Jun 08 12:08:57 CST 2020
        System.out.println(format); //20-6-8 下午12:08

        //parse():解析： 格式化的逆过程  字符串 ---> 日期
        System.out.println("---------------解析---------------");
        String s1 = "20-6-8 下午12:08";
        Date parse = sdf.parse(s1);
        System.out.println(parse);

        //有参构造器
        System.out.println("---------------有参构造器：指定日期格式---------------");
        //格式化
        new SimpleDateFormat();
        SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format1 = sdf1.format(date);
        System.out.println(format1);
        //解析
        Date date1 = sdf1.parse(format1);
        System.out.println(date1);
    }

    /*
    练习一：将字符串2020-10-21转换为java.sql.Date （项目中需要将用户传来的String类型的日期转为java.sql.Date
                                                    才能存入数据库的表中)
     */
    @Test
    public void test01() throws ParseException {
        System.out.println("---------------练习一---------------");
        String date = "2020-10-21";
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        Date date1 = sdf.parse(date);
        java.sql.Date date2 = new java.sql.Date(date1.getTime());
        System.out.println(date2);
    }
}

运行结果如下图所示：
在这里插入图片描述

System类

1.无法通过new实例化，因为System的构造方法私有化了

2.currentTimeMillis() ：通过这个方法可以获取一个时间戳

package com.Lindom.时间日期;
public class SystemDemo {

    public static void main(String[] args) {
        //此方法表示的时间，是指1970年0时0分0秒到现在时间的毫秒数
        long l = System.currentTimeMillis();
        System.out.println(l);
    }
}

运行结果如下图所示：
在这里插入图片描述

jdk1.8新增的时间日期类

LocalTime类

LocalDate类

LocalDateTime类 (最常用)

这三个类的本质都一样，LocalTime类是获取时间，LocalDate类是获取日期，LocalDateTime类是获取时间日期；三者的使用方法也大体一致，所以这里只举例LocalDateTime类。

1.无法通过new实例化，因为这三个类的构造方法都私有化了
可以通过now()方法进行实例对象；
或者通过of()方法进行指定日期的实例

2.四种常用方法
getXxx()：获取相关的属性
withXxx(): 设置相关的属性，体现出XxxTime类的不可变性
plusXxx(): 添加
minusXxx(): 减

package com.Lindom.时间日期;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
public class TimeDemo {

    public static void main(String[] args) {
        //获取对象
        LocalTime localTime = LocalTime.now();
        LocalDate localDate = LocalDate.now();
        LocalDateTime localDateTime = LocalDateTime.now();
        System.out.println(localTime);  //23:34:04.762
        System.out.println(localDate);  //2020-06-08
        System.out.println(localDateTime);  //2020-06-08T23:34:04.762

        LocalDateTime localDateTime1 = LocalDateTime.of(2020, 10, 21, 10, 10, 10, 100000000);
        System.out.println(localDateTime1);  //2020-10-21T10:10:10.100

        //getXxx()：获取相关的属性
        System.out.println(localDateTime.getDayOfMonth());  //8
        System.out.println(localDateTime.getDayOfWeek());  //MONDAY
        System.out.println(localDateTime.getDayOfYear());  //160
        System.out.println(localDateTime.getMonth());      //JUNE
        System.out.println(localDateTime.getMonthValue());  //6
        System.out.println(localDateTime.getMinute());   //34

        //withXxx():设置相关的属性，体现出XxxTime类的不可变性
        LocalDateTime localDateTime2 = localDateTime.withDayOfMonth(30);
        System.out.println(localDateTime);   //2020-06-08T23:34:04.762
        System.out.println(localDateTime2);   //2020-06-30T23:34:04.762

        //plusXxx():添加
        LocalDateTime localDateTime3 = localDateTime.plusMonths(3);
        System.out.println(localDateTime);   //2020-06-08T23:34:04.762
        System.out.println(localDateTime3);   //2020-09-08T23:34:04.762

        //minusXxx():减
        LocalDateTime localDateTime4 = localDateTime.minusMonths(1);
        System.out.println(localDateTime);   //2020-06-08T23:34:04.762
        System.out.println(localDateTime4);   //2020-05-08T23:34:04.762

    }
}

运行结果如下图所示：
在这里插入图片描述

Instant类

1.无法通过new实例化，因为这个类的构造方法被私有化了
可以通过now()方法实例对象

2.四个常用方法
now()
atOffset()方法：设置时间偏移量
toEpochMilli()方法：获取1970年到现在的时间戳
ofEpochMilli()方法：通过给定的毫秒数，获取Instant实例

package com.Lindom.时间日期;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.time.ZoneOffset;
public class InstantDemo {

    public static void main(String[] args) {
        //通过now()方法实例化，输出的时间为本初子午线上的时间，比当前时间晚8个小时
        Instant instant = Instant.now();
        System.out.println(instant);

        //atOffset()方法设置时间偏移量，加上八个钟就是当前时间了
        OffsetDateTime offsetDateTime = instant.atOffset(ZoneOffset.ofHours(8));
        System.out.println(offsetDateTime);

        //toEpochMilli()方法获取1970年到现在的时间戳，相当于java.util.Date的getTime()方法
        long l = instant.toEpochMilli();
        System.out.println(l);

        //ofEpochMilli()方法，通过给定的毫秒数，获取Instant实例，相当于Date(long millis)
        Instant instant1 = instant.ofEpochMilli(15146321545L);
        System.out.println(instant1);
    }
}

运行结果如下图所示：
在这里插入图片描述

DateTimeFormatter类

DateTimeFormatter类 jdk1.8 : 格式化与解析时间日期类似于SimpleDateFormat

1.无法通过new实例化
通过 ISO_LOCAL_DATE_TIME 实例一个对象

2.三种使用方式：
方式一：预定义的标准格式

方式二：本地化相关的格式
本地4种不同的时间格式： FormatStyle.LONG FormatStyle.FULL FormatStyle.MEDIUM FormatStyle.SHORT

方式三(重点)：自定义格式
自定义常用格式：yyyy-MM-dd HH:mm:ss —> 2020-06-09 17:23:32

3.两种常用方法：
format(): 格式化: 日期—>字符串
parse(): 解析：字符串—>日期

package com.Lindom.时间日期;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.FormatStyle;
import java.time.temporal.TemporalAccessor;
public class DateTimeFormatterDemo {

    public static void main(String[] args) {

        LocalDateTime localDateTime = LocalDateTime.now();  //需要创建一个时间日期
        //方式一：预定义的标准格式
        System.out.println("-----------------------预定义的标准格式--------------------------");
        //format(): 格式化为String类型
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ISO_LOCAL_DATE_TIME;
        String format = dateTimeFormatter.format(localDateTime);      //这里需要传入一个LocalDateTime类型的参数
        System.out.println(localDateTime);  //2020-06-09T17:02:15.241
        System.out.println(format);  //2020-06-09T17:02:15.241   虽然两个看起来一样，但是实质已经变了，
                                    // 一个是LocalDateTime类型，一个是String类型
        //parse(): 解析
        TemporalAccessor parse = dateTimeFormatter.parse("2020-06-09T17:02:15.241");
        System.out.println(parse);   //{},ISO resolved to 2020-06-09T17:02:15.241



        //方式二：本地化相关的格式
        System.out.println("-----------------------本地化相关的格式--------------------------");
        DateTimeFormatter dateTimeFormatter1 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.SHORT);
        //4种不同的时间格式：  FormatStyle.LONG  FormatStyle.FULL  FormatStyle.MEDIUM  FormatStyle.SHORT
        String format1 = dateTimeFormatter1.format(localDateTime);     //格式化
        System.out.println(format1);  //20-6-9 下午5:16
        TemporalAccessor parse1 = dateTimeFormatter1.parse("20-6-9 下午5:16");   //解析
        System.out.println(parse1);   //{},ISO resolved to 2020-06-09T17:16



        //方式三(重点)：自定义格式
        System.out.println("-----------------------自定义格式--------------------------");
        DateTimeFormatter dateTimeFormatter2 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String format2 = dateTimeFormatter2.format(localDateTime);  //格式化
        System.out.println(format2);  //2020-06-09 17:23:32
        TemporalAccessor parse2 = dateTimeFormatter2.parse("2020-06-09 17:23:32");  //解析
        System.out.println(parse2);  //{},ISO resolved to 2020-06-09T17:23:32
    }
}

运行结果如下图所示：
在这里插入图片描述

以上就是学习JAVA时常用的几个时间日期类，jdk1.8新增的时间日期类更易于管理、操作和理解，更值得大家去学习使用。
如果大家使用的是jdk1.7版本，可以通过下载导入joda-time.jar包，便可以使用jdk1.8新增的时间日期类了，这里为了方便大家下载我准备joda-time-2.10.6.jar包的下载，点击链接便可前去我的博客下载 https://download.csdn.net/download/weixin_44928884/12508285

其次，如果大家使用的是maven项目，也可以直接在pom.xml中导入如下：

<dependency>
  <groupId>joda-time</groupId>
  <artifactId>joda-time</artifactId>
  <version>2.10.6</version>
</dependency>

感谢大家的访问！

帕帕尼先生

关注

5
点赞
踩
18

收藏

觉得还不错? 一键收藏
4
评论
时间日期类详细总结大全

jdk1.8之前的时间日期类Date类java.util.Date(父类)----java.sql.Date(子类)1.掌握两个构造器的使用 (java.sql.Date 只有一个有参的构造器)Date() //无参构造器Date(long Date) //创建指定毫秒数的Date对象2.两个常用方法的使用toString()方法 //直接返回当前时间getTime()方法 //返回1970年至今的毫秒数//此方法跟System.currentTimeMilli
复制链接

扫一扫