Java时间API

已于 2025-03-19 17:12:20 修改
阅读量852 收藏 16
点赞数 37
文章标签： 开发语言 java
于 2025-03-19 11:18:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50921885/article/details/146363256
版权

一、Data类（时间对象）

Date 对象记录的时间是用毫秒值来表示的。 Java 语言规定， 1970 年 1 月 1 日 0 时 0 分 0 秒认为是时间的起点，此时记作0，那么 1000 （ 1 秒 =1000 毫秒）就表示 1970 年 1 月 1 日 0 时 0 分 1 秒，以此类推。

用法：

public class Test1Date {
    public static void main(String[] args) {
// 目标：掌握Date日期类的使用。
// 1、创建一个Date的对象：代表系统当前时间信息的。
        Date d = new Date();
        System.out.println(d);    
// 2、拿到时间毫秒值。
        long time = d.getTime();
        System.out.println(time);

// 3、把时间毫秒值转换成日期对象： 2s之后的时间是多少。
        time += 2 * 1000;
        Date d2 = new Date(time);
        System.out.println(d2);
// 4、直接把日期对象的时间通过setTime方法进行修改
        Date d3 = new Date();
        d3.setTime(time);  //time += 2 * 1000;这里的time
        System.out.println(d3);
    }
}

、、结果如下

二、SimpleDateFormat类（日期格式化）

用来格式化时间

把 Date 对象转换为指定格式的日期字符串这个操作，叫做 日期格式化，
反过来把指定格式的日期符串转换为 Date 对象的操作，叫做 日期解析。

用法:

常见时间格式(按照下面的格式可以任意拼接，但是字母不能写错) 
public class Test2SimpleDateFormat {
    public static void main(String[] args) throws ParseException {
// 目标：掌握SimpleDateFormat的使用。
// 1、准备一些时间
        //准备日期对象
        Date d = new Date();
        System.out.println(d);
        //准备时间毫秒值
        long time = d.getTime();
        System.out.println(time);
// 2、格式化日期对象，和时间 毫秒值。
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EEE a");   //SimpleDateFormat sdf = new SimpleDateFormat("时间格式");
        String rs = sdf.format(d); //格式化日期对象
        String rs2 = sdf.format(time);//格式化时间毫秒值
        System.out.println(rs);
        System.out.println(rs2);
        System.out.println("----------------------------------------------");
// 目标：掌握SimpleDateFormat解析字符串时间 成为日期对象。
        String dateStr = "2022-12-12 12:12:11";
// 1、创建简单日期格式化对象 , 指定的时间格式必须与被解析的时间格式一模一样，否则程序会出bug.
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date d2 = sdf2.parse(dateStr);
        System.out.println(d2);
    }
}

案例:

public class kk {
    public static void main(String[] args) throws ParseException {
// 目标：完成秒杀案例。
// 1、把开始时间、结束时间、小贾下单时间、小皮下单时间拿到程序中来。
        String start = "2023年11月11日 0:0:0";
        String end = "2023年11月11日 0:10:0";
        String xj = "2023年11月11日 0:01:18";
        String xp = "2023年11月11日 0:10:57";
// 2、把字符串的时间解析成日期对象。
        SimpleDateFormat f = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        Date startDt = f.parse(start);
        Date endDt = f.parse(end);
        Date xjDt = f.parse(xj);
        Date xpDt = f.parse(xp);
// 3、开始判断小皮和小贾是否秒杀成功了。
// 把日期对象转换成时间毫秒值来判断
        long startTime = startDt.getTime();
        long endTime = endDt.getTime();
        long xjTime = xjDt.getTime();
        long xpTime = xpDt.getTime();

        if (xjTime >= startTime && xjTime <= endTime) {
            System.out.println("小贾秒杀成功");
        } else {
            System.out.println("小贾秒杀失败");
        }

        if(xpTime >= startTime && xpTime <= endTime) {
            System.out.println("小皮秒杀成功");
        }
        else{
            System.out.println("小皮秒杀失败");
        }

    }
}

三、Calendar类（日历）

代表系统此刻时间对应的日历，通过它可以单独获取、修改时间中的年、月、日、时、分、秒等。

public class Test4Calendar {
    public static void main(String[] args) {
// 目标：掌握Calendar的使用和特点。
// 1、得到系统此刻时间对应的日历对象。
        Calendar now = Calendar.getInstance();  、、他是个抽象类，但是有提供静态方法创建对象，所以直接调用方法
        System.out.println(now);
// 2、获取日历中的某个信息
        int year = now.get(Calendar.YEAR);
        System.out.println(year);
        int days = now.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);
// 3、拿到日历中记录的日期对象。
        Date d = now.getTime();
        System.out.println(d);
// 4、拿到时间毫秒值
        long time = now.getTimeInMillis();
        System.out.println(time);
// 5、修改日历中的某个信息
        now.set(Calendar.MONTH, 9); // 修改月份成为10月份。
        now.set(Calendar.DAY_OF_YEAR, 125); // 修改成一年中的第125天。
        System.out.println(now);
// 6、为某个信息增加或者减少多少
        now.add(Calendar.DAY_OF_YEAR, 100);
        now.add(Calendar.DAY_OF_YEAR, -10);
        now.add(Calendar.DAY_OF_MONTH, 6);
        now.add(Calendar.HOUR, 12);
        now.set(2026, 11, 22);
        System.out.println(now);
    }
}

        

JDK8要新增日期类

一、代替Calendar（日历）

1.1、LocalDate、LocalTime、LocalDateTime用法：

大同小异

LocalDate类的基本使用
public class Test1_LocalDate {
    public static void main(String[] args) {
// 0、获取本地日期对象(不可变对象)
        LocalDate ld = LocalDate.now(); // 年 月 日
        System.out.println(ld);
// 1、获取日期对象中的信息
        int year = ld.getYear(); // 年
        int month = ld.getMonthValue(); // 月(1-12)
        int day = ld.getDayOfMonth(); // 日
        int dayOfYear = ld.getDayOfYear(); // 一年中的第几天
        int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几
        System.out.println(year);
        System.out.println(day);
        System.out.println(dayOfWeek);
// 2、直接修改某个信息: withYear、withMonth、withDayOfMonth、withDayOfYear
        LocalDate ld2 = ld.withYear(2099);
        LocalDate ld3 = ld.withMonth(12);
        System.out.println(ld2);
        System.out.println(ld3);
        System.out.println(ld);
// 3、把某个信息加多少: plusYears、plusMonths、plusDays、plusWeeks
        LocalDate ld4 = ld.plusYears(2);
        LocalDate ld5 = ld.plusMonths(2);
// 4、把某个信息减多少：minusYears、minusMonths、minusDays、minusWeeks
        LocalDate ld6 = ld.minusYears(2);
        LocalDate ld7 = ld.minusMonths(2);
// 5、获取指定日期的LocalDate对象： public static LocalDate of(int year, int month, int
        dayOfMonth)
        LocalDate ld8 = LocalDate.of(2099, 12, 12);
        LocalDate ld9 = LocalDate.of(2099, 12, 12);
// 6、判断2个日期对象，是否相等，在前还是在后： equals isBefore isAfter
        System.out.println(ld8.equals(ld9));// true
        System.out.println(ld8.isAfter(ld)); // true
        System.out.println(ld8.isBefore(ld)); // false
    }
}
LocalTime类的基本使用
public class Test2_LocalTime {
    public static void main(String[] args) {
// 0、获取本地时间对象
        LocalTime lt = LocalTime.now(); // 时 分 秒 纳秒 不可变的
        System.out.println(lt);
// 1、获取时间中的信息
        int hour = lt.getHour(); //时
        int minute = lt.getMinute(); //分
        int second = lt.getSecond(); //秒
        int nano = lt.getNano(); //纳秒
// 2、修改时间：withHour、withMinute、withSecond、withNano
        LocalTime lt3 = lt.withHour(10);
        LocalTime lt4 = lt.withMinute(10);
        LocalTime lt5 = lt.withSecond(10);
        LocalTime lt6 = lt.withNano(10);
// 3、加多少：plusHours、plusMinutes、plusSeconds、plusNanos
        LocalTime lt7 = lt.plusHours(10);
        LocalTime lt8 = lt.plusMinutes(10);
        LocalTime lt9 = lt.plusSeconds(10);
        LocalTime lt10 = lt.plusNanos(10);
// 4、减多少：minusHours、minusMinutes、minusSeconds、minusNanos
        LocalTime lt11 = lt.minusHours(10);
        LocalTime lt12 = lt.minusMinutes(10);
        LocalTime lt13 = lt.minusSeconds(10);
        LocalTime lt14 = lt.minusNanos(10);
// 5、获取指定时间的LocalTime对象：
// public static LocalTime of(int hour, int minute, int second)
        LocalTime lt15 = LocalTime.of(12, 12, 12);
        LocalTime lt16 = LocalTime.of(12, 12, 12);
// 6、判断2个时间对象，是否相等，在前还是在后： equals isBefore isAfter
        System.out.println(lt15.equals(lt16)); // true
        System.out.println(lt15.isAfter(lt)); // false
        System.out.println(lt15.isBefore(lt)); // true
    }
}
LocalDateTime类的基本使用
public class Test3_LocalDateTime {
    public static void main(String[] args) {
// 0、获取本地日期和时间对象。
        LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒 纳秒
        System.out.println(ldt);
// 1、可以获取日期和时间的全部信息
        int year = ldt.getYear(); // 年
        int month = ldt.getMonthValue(); // 月
        int day = ldt.getDayOfMonth(); // 日
        int dayOfYear = ldt.getDayOfYear(); // 一年中的第几天
        int dayOfWeek = ldt.getDayOfWeek().getValue(); // 获取是周几
        int hour = ldt.getHour(); //时
        int minute = ldt.getMinute(); //分
        int second = ldt.getSecond(); //秒
        int nano = ldt.getNano(); //纳秒
// 2、修改时间信息：
// withYear withMonth withDayOfMonth withDayOfYear withHour
// withMinute withSecond withNano
        LocalDateTime ldt2 = ldt.withYear(2029);
        LocalDateTime ldt3 = ldt.withMinute(59);
// 3、加多少:
// plusYears plusMonths plusDays plusWeeks plusHours plusMinutes plusSeconds
        plusNanos
        LocalDateTime ldt4 = ldt.plusYears(2);
        LocalDateTime ldt5 = ldt.plusMinutes(3);
// 4、减多少：
// minusDays minusYears minusMonths minusWeeks minusHours minusMinutes minusSeconds
        minusNanos
        LocalDateTime ldt6 = ldt.minusYears(2);
        LocalDateTime ldt7 = ldt.minusMinutes(3);
// 5、获取指定日期和时间的LocalDateTime对象：
// public static LocalDateTime of(int year, Month month, int dayOfMonth, int hour,
// int minute, int second, int nanoOfSecond)
        LocalDateTime ldt8 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);
        LocalDateTime ldt9 = LocalDateTime.of(2029, 12, 12, 12, 12, 12, 1222);
// 6、 判断2个日期、时间对象，是否相等，在前还是在后： equals、isBefore、isAfter
        System.out.println(ldt9.equals(ldt8));
        System.out.println(ldt9.isAfter(ldt));
        System.out.println(ldt9.isBefore(ldt));
// 7、可以把LocalDateTime转换成LocalDate和LocalTime
// public LocalDate toLocalDate()
// public LocalTime toLocalTime()
// public static LocalDateTime of(LocalDate date, LocalTime time)
        LocalDate ld = ldt.toLocalDate();
        LocalTime lt = ldt.toLocalTime();
        LocalDateTime ldt10 = LocalDateTime.of(ld, lt);
    }
}

时区：

1.2、ZoneId类(获取时区id)

ZoneId:用于获取时区id,用于后续获得某时区的时间

用法

1.获取系统默认时区:

ZoneId zoneId = ZoneId.systemDefault();    

System.out.println(zoneId.getId());或System.out.println(zoneId);    两种写法都可以获取时区id 

2.获取全部时区id:

System.out.println(ZoneId.getAvailableZoneIds());     返回全世界各地的时区id

3.把某个时区id封装成ZoneId对象:

ZoneId zoneId1 = ZoneId.of("America/New_York");

1.3、ZonedDateTime类(获取带时区id的时间)

获取某个时区的ZonedDateTime对象。参数用zoneid对象

ZonedDateTime now = ZonedDateTime.now(zoneId1);

System.out.println(now);

世界标准时间

ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());

System.out.println(now1);

获取系统默认时区的ZonedDateTime对象

ZonedDateTime now2 = ZonedDateTime.now();

System.out.println(now2);

其余与localdatetime用法一样

public class Test4_ZoneId_ZonedDateTime {
    public static void main(String[] args) {
// 目标：了解时区和带时区的时间。
// 1、ZoneId的常见方法：
// public static ZoneId systemDefault(): 获取系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId.getId());
        System.out.println(zoneId);
// public static Set<String> getAvailableZoneIds(): 获取Java支持的全部时区Id
        System.out.println(ZoneId.getAvailableZoneIds());
// public static ZoneId of(String zoneId) : 把某个时区id封装成ZoneId对象。
        ZoneId zoneId1 = ZoneId.of("America/New_York");
//----------------
// 2、ZonedDateTime：带时区的时间。
// public static ZonedDateTime now(ZoneId zone): 获取某个时区的ZonedDateTime对象。
        ZonedDateTime now = ZonedDateTime.now(zoneId1);
        System.out.println(now);
// 世界标准时间了
        ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now1);
// public static ZonedDateTime now()：获取系统默认时区的ZonedDateTime对象
        ZonedDateTime now2 = ZonedDateTime.now();
        System.out.println(now2);
// Calendar instance = Calendar.getInstance(TimeZone.getTimeZone(zoneId1));
    }
}

1.4、Instance类

通过获取 Instant 的对象可以拿到此刻的时间，该时间由两部分组成：从 1970-01- 01 00:00:00 开始走到此刻的总秒数 + 不够 1 秒的纳秒数。
最主要做 做代码的性能分析，或者记录用户的操作时间点、用户操作时间点 

public class Test5_Instant {
    public static void main(String[] args) {
// 1、创建Instant的对象，获取此刻时间信息
        Instant now = Instant.now(); // 不可变对象
// 2、获取总秒数
        long second = now.getEpochSecond();
        System.out.println(second);
// 3、不够1秒的纳秒数
        int nano = now.getNano();
        System.out.println(nano);
        System.out.println(now);
        Instant instant = now.plusNanos(111);
// Instant对象的作用：做代码的性能分析，或者记录用户的操作时间点
        Instant now1 = Instant.now();
// 代码执行。。。。
        Instant now2 = Instant.now();
        LocalDateTime l = LocalDateTime.now();
    }
}

二、代替SimpleDateFormat类

2.1、DateTimeFormatter类

public class Test6_DateTimeFormatter {
    public static void main(String[] args) {
// 1、创建一个日期时间格式化器对象出来。
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
// 2、对时间进行格式化
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);
        String rs = formatter.format(now); // 正向格式化
        System.out.println(rs);
// 3、格式化时间，其实还有一种方案。
        String rs2 = now.format(formatter); // 反向格式化
        System.out.println(rs2);
// 4、解析时间：解析时间一般使用LocalDateTime提供的解析方法来解析。
        String dateStr = "2029年12月12日 12:12:11";
        LocalDateTime ldt = LocalDateTime.parse(dateStr, formatter);
        System.out.println(ldt);
    }
}

三、其他

Period 用来计算日期间隔（年、月、日）， Duration 用来计算时间间隔（时、分、秒、纳秒）

3.1、Period类（计算日期间隔（年、月、日））

可以用来计算两个日期之间相隔的年、相隔的月、相隔的日。 只能 两个计算 LocalDate 对象之间的间隔 

public class Test7_Period {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2029, 8, 10);
        LocalDate end = LocalDate.of(2029, 12, 15);
// 1、创建Period对象，封装两个日期对象。
        Period period = Period.between(start, end);
// 2、通过period对象获取两个日期对象相差的信息。
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}

3.2、Duration类（计算时间间隔（时、分、秒、纳秒））

它是用来表示两个时间对象的时间间隔。 可以用于计算两个时间对象相差的天数、小 时数、分数、秒数、纳秒数；支持 LocalTime 、 LocalDateTime 、 Instant 等时间 

public class Test8_Duration {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2025, 11, 11, 11, 10, 10);
        LocalDateTime end = LocalDateTime.of(2025, 11, 11, 11, 11, 11);
// 1、得到Duration对象
        Duration duration = Duration.between(start, end);
// 2、获取两个时间对象间隔的信息
        System.out.println(duration.toDays());// 间隔多少天
        System.out.println(duration.toHours());// 间隔多少小时
        System.out.println(duration.toMinutes());// 间隔多少分
        System.out.println(duration.toSeconds());// 间隔多少秒
        System.out.println(duration.toMillis());// 间隔多少毫秒
        System.out.println(duration.toNanos());// 间隔多少纳秒
    }
}

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值