Java时间类

已于 2023-10-29 11:42:09 修改
阅读量101 收藏
点赞数
分类专栏： JavaSe 文章标签： java 开发语言
于 2023-10-23 11:37:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ICfzx030721/article/details/133986051
版权

目录

Date类 

Date概述 

Date常用方法

SimpleDateFormat类 

构造方法

常用方法

 Calendar类

概述

常用方法

 get方法示例

set方法示例

add方法示例

 JDK8时间相关类

ZoneId 时区 

Instant 时间戳 

ZoneDateTime 带时区的时间

DateTimeFormatter用于时间的格式化和解析

LocalDate 年、月、日 

LocalTime 时、分、秒

LocalDateTime 年、月、日、时、分、秒

Duration 时间间隔（秒，纳，秒）

Period 时间间隔（年，月，日） 

ChronoUnit 时间间隔（所有单位）

Date类 

Date概述 

java.util.Date类 表示特定的瞬间，精确到毫秒。

继续查阅Date类的描述，发现Date拥有多个构造函数，只是部分已经过时，我们重点看以下两个构造函数

  • public Date()：从运行程序的此时此刻到时间原点经历的毫秒值,转换成Date对象，分配Date对象并初始化此对象，以表示分配它的时间（精确到毫秒）。
  • public Date(long date)：将指定参数的毫秒值date,转换成Date对象，分配Date对象并初始化此对象，以表示自从标准基准时间（称为“历元（epoch）”，即1970年1月1日00:00:00 GMT）以来的指定毫秒数。

tips: 由于中国处于东八区（GMT+08:00）是比世界协调时间/格林尼治时间（GMT）快8小时的时区，当格林尼治标准时间为0:00时，东八区的标准时间为08:00。

简单来说：使用无参构造，可以自动设置当前系统时间的毫秒时刻；指定long类型的构造参数，可以自定义毫秒时刻。例如：

public class Main {
    public static void main(String[] args) {
        //创建日期对象，输出为当前时间
        Date d = new Date();
        System.out.println(d);//Mon Oct 16 17:47:18 CST 2023
        //创建日期对象，把当前的毫秒值转成日期对象
        System.out.println(new Date(0L));//Thu Jan 01 08:00:00 CST 1970
    }
}

tips:在使用println方法时，会自动调用Date类中的toString方法。Date类对Object类中的toString方法进行了覆盖重写，所以结果为指定格式的字符串。

Date常用方法

Date类中的多数方法已经过时，常用的方法有：

  • public long getTime() 把日期对象转换成对应的时间毫秒值。
  • public void setTime(long time) 把方法参数给定的毫秒值设置给日期对象

示例代码

public class Main02 {
    public static void main(String[] args) {
        Date d = new Date();
        System.out.println(d.getTime());//1697449826180
        
        //public void setTime(long time):设置时间，给的是毫秒值
        long time = 1000*60*60;
        d.setTime(time);
        System.out.println(d);//Thu Jan 01 09:00:00 CST 1970
    }
}

SimpleDateFormat类 

java.text.SimpleDateFormat 是日期/时间格式化类，我们通过这个类可以帮我们完成日期和文本之间的转换,也就是可以在Date对象与String对象之间进行来回转换。

  • 格式化：按照指定的格式，把Date对象转换为String对象。
  • 解析：按照指定的格式，把String对象转换为Date对象。

构造方法

由于DateFormat为抽象类，不能直接使用，所以需要常用的子类java.text.SimpleDateFormat。这个类需要一个模式（格式）来指定格式化或解析的标准。构造方法为：

  • public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格式符号构造SimpleDateFormat。参数pattern是一个字符串，代表日期时间的自定义格式。

格式规则 

标识字母（区分大小写）含义
y年
M月
d日
H时
m分
s秒

 备注：更详细的格式规则，可以参考SimpleDateFormat类的API文档。

常用方法

DateFormat类的常用方法有：

  • public String format(Date date)：将Date对象格式化为字符串。

  • public Date parse(String source)：将字符串解析为Date对象

public class Test01 {
    public static void main(String[] args) throws ParseException {
        /*
            public simpleDateFormat() 默认格式
            public simpleDateFormat(String pattern) 指定格式
            public final string format(Date date) 格式化(日期对象 ->字符串)
            public Date parse(string source) 解析(字符串 ->日期对象)
        */
        //1.定义一个字符串表示时间
        String str = "2023-10-17 22:00:00";
        //2.利用空参构造创建simpleDateFormat对象
        //细节:
        //创建对象的格式要跟字符串的格式完全一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(str);
        System.out.println(date.getTime());
    }
}

 Calendar类

概述

  • java.util.Calendar类表示一个“日历类”，可以进行日期运算。它是一个抽象类，不能创建对象，我们可以使用它的子类：java.util.GregorianCalendar类。
  • 有两种方式可以获取GregorianCalendar对象：
    • 直接创建GregorianCalendar对象；
    • 通过Calendar的静态方法getInstance()方法获取GregorianCalendar对象

常用方法

方法名说明
public static Calendar getInstance()获取一个它的子类GregorianCalendar对象。
public int get(int field)获取某个字段的值。field参数表示获取哪个字段的值，<br />可以使用Calender中定义的常量来表示：<br />Calendar.YEAR : 年<br />Calendar.MONTH ：月<br/>Calendar.DAY_OF_MONTH：月中的日期 <br />Calendar.HOUR：小时<br/>Calendar.MINUTE：分钟  <br />Calendar.SECOND：秒<br/>Calendar.DAY_OF_WEEK：星期
public void set(int field,int value)设置某个字段的值
public void add(int field,int amount)为某个字段增加/减少指定的值

 get方法示例

public class Test01 {
    public static void main(String[] args) {
        //获取一个GregorianCalendar对象
        Calendar instance = Calendar.getInstance();
        System.out.println(instance);
        //获取属性
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH);//Calendar的月份值是0-11
        int day = instance.get(Calendar.DAY_OF_MONTH);
        int hour = instance.get(Calendar.HOUR);
        int min = instance.get(Calendar.MINUTE);
        int second = instance.get(Calendar.SECOND);
        System.out.println(year+"年"+(month+1)+"月"+day+"日"+" "+hour+"时"+min+"分"+second+"秒");
        //2023年91月17日 11时55分32秒
        System.out.println(getWeek(instance.get(Calendar.DAY_OF_WEEK)));
    }
    //查表法，查询星期几
    public static String getWeek(int w){
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w-1];
    }
}

set方法示例

public class Test02 {
    public static void main(String[] args) {
        //设置属性——set(int field,int value):
        Calendar instance = Calendar.getInstance();

        //设置出生时间
        instance.set(Calendar.YEAR,1998);
        instance.set(Calendar.MONTH,6-1);
        instance.set(Calendar.DAY_OF_MONTH,11);

        //获取出生是星期几
        int w = instance.get(Calendar.DAY_OF_WEEK);
        System.out.println(getWeek(w));
    }
    //查表法，查询星期几
    public static String getWeek(int w){
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        //查表
        return weekArray[w-1];
    }
}

add方法示例

public class Test03 {
    public static void main(String[] args) {
        //获取当前日期
        Calendar instance = Calendar.getInstance();

        //给当前日期（2023-10-18）年月日都加2
        instance.add(Calendar.DAY_OF_MONTH,2);
        instance.add(Calendar.MONTH,2);
        instance.add(Calendar.YEAR,2);

        //获取添加后日期的默认格式
        Date d = instance.getTime();//Sat Dec 20 09:08:51 CST 2025

        //指定日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        //将Date 的 d 格式化为指定日期格式
        System.out.println(sdf.format(d));//2025-12-20
    }
}

 JDK8时间相关类

ZoneId 时区 

JDK8时间类类名作用
ZoneId时区
Instant时间戳
ZoneDateTime带时区的时间
DateTimeFormatter用于时间的格式化和解析
LocalDate年、月、日
LocalTime时、分、秒
LocalDateTime年、月、日、时、分、秒
Duration时间间隔（秒，纳，秒）
Period时间间隔（年，月，日）
ChronoUnit时间间隔（所有单位）
public class Test01 {
    public static void main(String[] args) {
        /*
        public static Set<string> getAvailableZoneIds() 获取Java中支持的所有时区
        public static ZoneId systemDefault() 获取系统默认时区
        public static Zoneld of(string zoneld) 获取一个指定时区
        */

        //1.获取所有的时区名称
        Set<String> zoneIds = ZoneId.getAvailableZoneIds();
        System.out.println(zoneIds.size());//603
        System.out.println(zoneIds);

        //2.获取当前系统的默认时区
        ZoneId zi = ZoneId.systemDefault();
        System.out.println(zi);//Asia/Shanghai

        //3.获取指定的时区
        ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
        System.out.println(zoneId1);//Asia/Pontianak
    }
}

Instant 时间戳 

public class Main {
    public static void main(String[] args) {
        /*
            public static Instant now() 获取当前时间的Instant对象(标准时间)
            public static Instant ofXxxx(long epochMilli) 根据(秒/毫秒/纳秒)获取Instant对象
            public ZonedDateTime atZone(ZoneIdzone) 指定时区
            public boolean isxxx(Instant otherInstant) 判断系列的方法
            public Instant minusXxx(long millisToSubtract) 减少时间系列的方法
            public Instant plusXxx(long millisToSubtract) 增加时间系列的方法
        */

        //1.获取当前时间的Instant对象(标准时间)
        Instant now = Instant.now();
        System.out.println(now);

        //2.根据(秒/毫秒/纳秒)获取Instant对象
        Instant instant1 = Instant.ofEpochMilli(0L);
        //毫秒
        Instant instant2 = Instant.ofEpochSecond(1L);
        //第二个参数为纳秒
        Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
        System.out.println(instant1);//1970-01-01T00:00:00Z
        System.out.println(instant2);//1970-01-01T00:00:01Z
        System.out.println(instant3);//1970-01-01T00:00:02Z

        //3. 指定时区
        ZonedDateTime time = Instant.now().atZone(ZoneId.systemDefault());
        System.out.println(time);//2023-10-18T09:44:07.468873200+08:00[Asia/Shanghai]

        //4.isXxx 判断
        Instant instant4=Instant.ofEpochMilli(0L);
        Instant instant5 =Instant.ofEpochMilli(1000L);

        //5.用于时间的判断
        //isBefore:判断调用者代表的时间是否在参数表示时间的前面
        boolean result1 = instant4.isBefore(instant5);
        System.out.println(result1);//true

        //isAfter:判断调用者代表的时间是否在参数表示时间的后面
        boolean result2 = instant4.isAfter(instant5);
        System.out.println(result2);//false

        //6.Instant minusXxx(long millisToSubtract) 减少时间系列的方法
        Instant instant6 = Instant.ofEpochMilli(3000L);
        System.out.println(instant6);//1970-01-01T00:00:03Z
        //秒
        Instant instant7 = instant6.minusSeconds(1L);
        System.out.println(instant7);//1970-01-01T00:00:02Z

    }
}

ZoneDateTime 带时区的时间

public class Main {
    public static void main(String[] args) {
        /*
            public static ZonedDateTime now() 获取当前时间的ZonedDateTime对象
            public static ZonedDateTime ofXxxx(...) 获取指定时间的ZonedDateTime对象
            public ZonedDateTime withXxx(时间) 修改时间系列的方法
            public ZonedDateTime minusXxx(时间) 减少时间系列的方法
            public ZonedDateTime plusXxx(时间) 增加时间系列的方法
         */
        //1.获取当前时间对象(带时区)
        ZonedDateTime now = ZonedDateTime.now();
        System.out.println(now);

        //2.获取指定的时间对象(带时区)1/年月日时分秒纳秒方式指定
        ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
                11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));
        System.out.println(time1);
        Instant instant = Instant.ofEpochMilli(0L);
        ZoneId zoneId = ZoneId.of("Asia/Shanghai");
        ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
        System.out.println(time2);

        //3.withXxx 修改时间系列的方法
        ZonedDateTime time3 = time2.withYear(2000);
        System.out.println(time3);
        //减少时间
        ZonedDateTime time4 = time3.minusMonths(1);
        //增加时间
        ZonedDateTime time5 = time3.plusYears(1);
        System.out.println(time4);
        System.out.println(time5);
    }
}

DateTimeFormatter用于时间的格式化和解析

public class Main {
    public static void main(String[] args) {
        /*
            public static DateTimeFormatter ofPattern(格式) 获取格式对象
            public String format(时间对象) 按照指定方式格式化
        */
        //获取时间对象
        ZonedDateTime time = Instant.now().atZone(ZoneId.systemDefault());

        //解析/格式器
        DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        //格式化
        System.out.println(dtf.format(time));
    }
}

LocalDate 年、月、日 

public class Main {
    public static void main(String[] args) {
        //1.获取当前时间的日历对象(包含 年月日)
        LocalDate nowDate = LocalDate.now();
        System.out.println("今天的日期:" + nowDate);

        //2.获取指定的时间的日历对象
        LocalDate ldDate = LocalDate.of(2023, 1, 1);
        System.out.println("指定日期:" + ldDate);

        System.out.println("----------------------");

        //3.get系列方法获取日历中的每一个属性值//获取年
        int year = ldDate.getYear();
        System.out.println(year);
        //获取月//方式一：
        Month m = ldDate.getMonth();
        System.out.println(m);
        System.out.println(m.getValue());

        //方式二
        int month = ldDate.getMonthValue();
        System.out.println("month:"+month);

        //获取日
        int day = ldDate.getDayOfMonth();
        System.out.println("day:"+day);

        //获取一年的第几天
        int dayOfYear = ldDate.getDayOfYear();
        System.out.println("dayOfYear:"+dayOfYear);

        //获取星期
        DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
        System.out.println("dayofWeek:"+dayOfWeek);

        //is开头的方法表示判断
        System.out.println(ldDate.isAfter(nowDate));
        System.out.println(ldDate.isBefore(nowDate));

        //with开头的方法表示修改，只能修改年月日
        LocalDate withlocalDate = ldDate.withYear(1998);
        System.out.println(withlocalDate);

        //minus开头的方法表示减少，只能减少年月日
        LocalDate minuslocalDate = ldDate.minusMonths(1);
        System.out.println(minuslocalDate);

        //plus开头的方法表示增加，只能增加年月日
        LocalDate pluslocalDate = ldDate.plusDays(1);
        System.out.println(pluslocalDate);

        // 判断今天是否是你的生日
        LocalDate birDate = LocalDate.of(1998, 06, 11);
        LocalDate nowDate1 = LocalDate.now();
        if(birDate.getMonthValue() == nowDate1.getMonthValue()
        && birDate.getDayOfMonth() == nowDate1.getDayOfMonth()){
            System.out.println("今天是你的生日，生日快乐！");
        }
        
        MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
        MonthDay nowMd = MonthDay.from(nowDate1);
        System.out.println("今天是你的生日吗? " + birMd.equals(nowMd));//今天是你的生日吗?
    }
}

LocalTime 时、分、秒

public class Main {
    public static void main(String[] args) {
        // 获取本地时间的日历对象。(包含 时分秒)
        LocalTime nowTime = LocalTime.now();
        System.out.println("今天的时间:" + nowTime);

        int hour = nowTime.getHour();//时
        System.out.println("hour: " + hour);

        int minute = nowTime.getMinute();//分
        System.out.println("minute: " + minute);

        int second = nowTime.getSecond();//秒
        System.out.println("second:" + second);

        int nano = nowTime.getNano();//纳秒
        System.out.println("nano:" + nano);
        System.out.println("------------------------------------");
        System.out.println(LocalTime.of(8, 20));//时分
        System.out.println(LocalTime.of(8, 20, 30));//时分秒
        System.out.println(LocalTime.of(8, 20, 30, 150));//时分秒纳秒
        LocalTime mTime = LocalTime.of(8, 20, 30, 150);//08:20:30.000000150

        //is系列的方法
        System.out.println(nowTime.isBefore(mTime));
        System.out.println(nowTime.isAfter(mTime));

        //with系列的方法，只能修改时、分、秒
        System.out.println(nowTime.withHour(10));

        //plus系列的方法，只能修改时、分、秒
        System.out.println(nowTime.plusHours(10));
    }
}

LocalDateTime 年、月、日、时、分、秒

public class Main {
    public static void main(String[] args) {
        // 当前时间的的日历对象(包含年月日时分秒)
        LocalDateTime nowDateTime = LocalDateTime.now();

        System.out.println("今天是:" + nowDateTime);//今天是：2023-10-18T15:05:32.327198700
        System.out.println(nowDateTime.getYear());//年
        System.out.println(nowDateTime.getMonthValue());//月
        System.out.println(nowDateTime.getDayOfMonth());//日
        System.out.println(nowDateTime.getHour());//时
        System.out.println(nowDateTime.getMinute());//分
        System.out.println(nowDateTime.getSecond());//秒
        System.out.println(nowDateTime.getNano());//纳秒

        // 日:当年的第几天
        System.out.println("dayofYear:" + nowDateTime.getDayOfYear());//291
        //星期
        System.out.println(nowDateTime.getDayOfWeek());
        System.out.println(nowDateTime.getDayOfWeek().getValue());
        //月份
        System.out.println(nowDateTime.getMonth());
        System.out.println(nowDateTime.getMonth().getValue());

        //LocalDate是跟年月日有关
        LocalDate ld = nowDateTime.toLocalDate();
        System.out.println(ld);//2023-10-18

        //LocalTime是跟时分秒有关
        LocalTime lt = nowDateTime.toLocalTime();
        System.out.println(lt.getHour());//15
        System.out.println(lt.getMinute());//5
        System.out.println(lt.getSecond());//32
    }
}

Duration 时间间隔（秒，纳，秒）

public class Main {
    public static void main(String[] args) {
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);

        //出生的日期时间对象
        LocalDateTime birthDate = LocalDateTime.of(1998, 06, 11, 0, 0, 0);
        System.out.println(birthDate);

        Duration duration = Duration.between(birthDate, today);//第二个参数减第一个参数
        System.out.println("相差的时间间隔对象:" + duration);

        System.out.println("-------------------------------");
        System.out.println(duration.toDays());//两个时间差的天数
        System.out.println(duration.toHours());//两个时间差的小时数
        System.out.println(duration.toMinutes());//两个时间差的分钟数
        System.out.println(duration.toMillis());//两个时间差的毫秒数
        System.out.println(duration.toNanos());//两个时间差的纳秒数
    }
}

Period 时间间隔（年，月，日） 

public class Main {
    public static void main(String[] args) {
        // 当前本地 年月日
        LocalDate today = LocalDate.now();
        System.out.println(today);

        // 生日的 年月日
        LocalDate birthDate = LocalDate.of(2003, 7, 21);
        System.out.println(birthDate);

        Period period = Period.between(birthDate, today);

        System.out.println("相差的时间间隔对象:" + period);
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());

        //20*12+2
        System.out.println(period.toTotalMonths());
    }
}

ChronoUnit 时间间隔（所有单位）

public class Main {
    public static void main(String[] args) {
        // 当前时间
        LocalDateTime today = LocalDateTime.now();
        System.out.println(today);
        // 生日时间
        LocalDateTime birthDate = LocalDateTime.of(2003, 7, 21,0, 0, 0);
        System.out.println(birthDate);

        System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate,today));
        System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));
        System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(birthDate, today));
        System.out.println("相差的天数:" + ChronoUnit.DAYS.between(birthDate, today));
        System.out.println("相差的时数:" + ChronoUnit.HOURS.between(birthDate, today));
        System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(birthDate, today));
        System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(birthDate, today));
        System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(birthDate, today));
        System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(birthDate, today));
        System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(birthDate, today));
        System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(birthDate, today));
        System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(birthDate, today));
        System.out.println("相差的世纪(百年)数:" + ChronoUnit.CENTURIES.between(birthDate, today));
        System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(birthDate, today));
        System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(birthDate, today));
    }
}
szu-fzx
关注
专栏目录
Java时间类（八）-- Instant （时间戳类）（常用于Date与LocalDateTime的相互转化）
PUYALEI的博客
05-04 2295
Java 中的Instant是一个不可变的类，用于表示时间的单个点，精确到纳秒级别。它不包含任何与时区相关的信息，因此可以在不同的时区之间进行平滑的转换。Instant类提供了一些方法来计算时间差，比较时间点等操作。通常情况下，它被用于记录事件的时间戳。
【Java基础知识 29】Java Date类详解
热门推荐
学Java，找哪吒
11-16 3万+
Calendar类的功能要比Date类强大很多，可以方便的进行日期的计算,获取日期中的信息时考虑了时区等问题。而且在实现方式上也比Date类要复杂一些。
java 时间类
04-03
NULL 博文链接：https://pairan1.iteye.com/blog/1464125
Java中的时间类
java面试笔试
06-08 1145
各位小伙伴又来给大家分享知识点了今天我们来分享Java中那些表示时间的类Date类Date类的概述类 Date 表示特定的瞬间，精确到毫秒。 构造方法public Dat...
java时间类
lj15847090684的博客
10-08 191
package aad; import java.text.*; import java.util.*; import java.text.DateFormat; public class gj { public static void main(String args[]){ Date today; DateFormat f1, f2; String s1; String s2...
Java日期时间类及计算
YYniannian的博客
07-25 4467
在有**一些前后端交互的项目中，**可能会遇到一个问题，就是前端选择并保存了一个时间信息，再查询的时候就会发现与设置的时间差了8个小时，这个其实就是后端时区转换设置的问题。
28个java常用的工具类源码
08-07
4. **`java.util.Date`/`java.time.*`**：`Date`是早期处理日期和时间的类，但API设计不佳。Java 8引入了`java.time`包，包含`LocalDate`、`LocalTime`、`LocalDateTime`、`ZonedDateTime`等类，提供了更直观且强大...
java实体类接收Date时间
没有伞的孩子只能快跑，如若不跑，只有一个结果：超过你的人回头鄙视你
09-27 2436
@ApiModelProperty(value = "结束时间") @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8") private Date endTime;
java中的时间类
weixin_44333359的博客
04-09 283
Date，SimpleDateFormat，Calendar类 一. Date类 1.java.uti包，封装当前的日期和时间。两个构造函数Date（）和Date（long millisec）。 例： Date date=new Date（）；**将当前的日期和时间封装在date对象中。** 2.使用Date对象的toString（）方法来打印当前日期和时间。 例： Date date=new ...
Java关于时间的类
LUOZONGW的博客
08-10 634
时间类小结
JAVA时间类
Endless 的博客
08-24 349
package 时间;import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; import
java时间类相互转换
最新发布
02-04
Java中提供了多个用于处理日期和时间的类，其中最常用的是`java.util.Date`、`java.util.Calendar`和`java.time.LocalDateTime`。 1. `java.util.Date`类是Java早期提供的日期和时间处理类，但它已经过时，不推荐...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值