Java日期和时间(二)

发布时间:2024年01月01日

新增的日期和时间

为什么要学习新增的日期和时间

1、代替Calendar

? ??????LocalDate:年、月、日

? ? ? ? LocalTime:时、分、秒

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

? ? ? ? ZoneId:时区

? ? ? ? ZoneldDatetime:带时区的时间

2、代替Date?

? ? ? ? Instant:时间戳/时间线

?3、代替SimpleDateForamt

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

4、其他补充?

????????Period:时间间隔(年、月、日)

? ? ? ? Duration:时间间隔(时、分、秒,纳秒)

LocalDate、LocalTime、LocalDateTime

LocalDate:代表本地日期(年、月、日、星期)

LocalTime:代表本地时间(时、分、秒、纳秒)

LocalDateTime:代表本地日期、时间(年、月、日、星期、时、分、秒、纳秒)

它们获取对象的方案

方法名示例
public static Xxxx now():获取系统当前时间对应的该对象

LocalDate ld =?LocaDate.now();

LocalTime ld =?LocalTime.now();

LocalDateTime ld =?LocalDateTime.now();

public static Xxxx of(…):获取指定时间的对象

LocalDate localDate1 = LocalDate.of(2099,11,11)

LocalTime?localTime1 = LocalTime.of(9,8,59)

LocalDateTime?localDateTime1 =?LocalDateTime.of(2025,11,16,14,30,01)

LocalDate?

LocalDate的常用API(都是处理年、月、日、星期相关的)
import java.time.LocalDate;

public class Test {
    public static void main(String[] args){
        // 获取本地日期对象(不可变对象)
        LocalDate ld = LocalDate.now(); // 年 月 日
        System.out.println(ld);

        // 获取日期对象中的信息
        int year = ld.getYear(); // 年
        int month = ld.getMonthValue(); // 月(1-12)
        int day = ld.getDayOfMonth(); // 日
        int dayOfYear = ld.getDayOfYear(); // 一年中的第几天
        int dayOfWeek = ld.getDayOfWeek().getValue(); // 星期几

        // 直接修改某个信息: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);

        // 把某个信息加多少:plusYears、plusMonths、plusDays、plusWeeks
        LocalDate ld4 = ld.plusYears(2);
        LocalDate ld5 = ld.plusMonths(2);

        // 把某个信息减多少:minusYears、minusMonths、minusDays、minusWeeks
        LocalDate ld6 = ld.minusYears(2);
        LocalDate ld7 = ld.minusMonths(2);

        // 获取指定日期的LocalDate对象
        LocalDate ld8 = LocalDate.of(2099,12,12);
        LocalDate ld9 = LocalDate.of(2099,12,12);

        // 判断2个日期对象是否相等,再前还是再后:equals isBefore isAfter
        System.out.println(ld8.equals(ld9));
        System.out.println(ld8.isAfter(ld));
        System.out.println(ld8.isBefore(ld));
    }
}

LocalTime

LocalTime的常用API(都是处理时、分、秒、纳秒相关的)
import java.time.LocalTime;

public class Test {
    public static void main(String[] args){
        // 获取本地时间对象
        LocalTime lt = LocalTime.now(); // 时 分 秒
        System.out.println(lt);

        // 获取时间中的信息
        int hour = lt.getHour(); // 时
        int minute = lt.getMinute(); // 分
        int second = lt.getSecond(); // 秒
        int nano = lt.getNano(); // 纳秒

        // 修改时间
        LocalTime lt2 = lt.withHour(10);
        LocalTime lt3 = lt.withMinute(10);
        LocalTime lt4 = lt.withSecond(10);
        LocalTime lt5 = lt.withNano(10);

        // 加多少:plusHours、plusMinutes、plusSeconds、plusNanos
        LocalTime lt6 = lt.plusHours(10);
        LocalTime lt7 = lt.plusMinutes(10);

        // 减多少:minusHours、minusMinutes、minusSeconds、minusNanos
        LocalTime lt8 = lt.minusHours(10);
        LocalTime lt9 = lt.minusMinutes(10);

        // 获取指定时间的LocalTime对象
        LocalTime lt10 = LocalTime.of(12,12,12);
        LocalTime lt11 = LocalTime.of(12,12,12);

        // 判断2个日期对象是否相等,再前还是再后:equals isBefore isAfter
        System.out.println(lt10.equals(lt11));
        System.out.println(lt10.isAfter(lt));
        System.out.println(lt10.isBefore(lt));
    }
}

LocalDateTime

LocalTime的常用API(都是处理年、月、日、时、分、秒、纳秒相关的)
import java.time.LocalDateTime;

public class Test {
    public static void main(String[] args){
        // 获取本地日期、时间对象
        LocalDateTime ldt = LocalDateTime.now(); // 年 月 日 时 分 秒
        System.out.println(ldt);

        // 获取日期、时间中的信息
        int year = ldt.getYear(); // 年
        int month = ldt.getMonthValue(); // 月(1-12)
        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(); // 纳秒

        // 修改时间
        LocalDateTime ldt2 = ldt.withYear(2099);
        LocalDateTime ldt3 = ldt.withMinute(59);

        // 加多少
        LocalDateTime ldt4 = ldt.plusYears(2);
        LocalDateTime ldt5 = ldt.plusMinutes(3);

        // 减多少
        LocalDateTime ldt6 = ldt.minusYears(2);
        LocalDateTime ldt7 = ldt.minusMinutes(3);

        // 获取指定日期、时间的LocalDateTime对象
        LocalDateTime ldt8 = LocalDateTime.of(2099,12,12,12,12,12);
        LocalDateTime ldt9 = LocalDateTime.of(2099,12,12,12,12,12);

        // 判断2个日期、时间对象是否相等,再前还是再后:equals isBefore isAfter
        System.out.println(ldt8.equals(ldt9));
        System.out.println(ldt8.isAfter(ldt));
        System.out.println(ldt8.isBefore(ldt));
    }
}

Zoneld、ZonedDateTime

Zoneld:代表时区id

Zoneld时区的常见方法

ZonedDateTime?

ZonedDateTime带时区时间的常见方法

import java.time.Clock;
import java.time.ZoneId;
import java.time.ZonedDateTime;

public class Test {
    public static void main(String[] args){
        // Zoneld的常见方法
        // 获取系统默认的时区
        ZoneId zoneId = ZoneId.systemDefault();
        System.out.println(zoneId.getId());
        System.out.println(zoneId);

        // 获取Java支持的全部时区id
        System.out.println(ZoneId.getAvailableZoneIds());

        // 把某个时区id封装成Zoneid对象
        ZoneId zoneId1 = ZoneId.of("America/New_York");

        // ZonedDateTime:带时区的时间
        // 获取系统某个时区的ZondDateTime对象
        ZonedDateTime now = ZonedDateTime.now(zoneId1);
        System.out.println(now);

        // 世界标准时间
        ZonedDateTime now1 = ZonedDateTime.now(Clock.systemUTC());
        System.out.println(now1);

        // 获取系统默认时区的ZondDateTime对象
        ZonedDateTime now2 = ZonedDateTime.now();
        System.out.println(now2);
    }
}

?

Instant? 时间线上的某个时刻/时间戳

  • 通过获取Instant的对象可以拿到此刻的时间,该时间由两部分组成:从1970-01-01? 00:00:00开始走到此刻的总秒数 + 不够一秒的纳秒数
import java.time.Instant;

public class Test {
    public static void main(String[] args){
        // 创建Instant对象,获取此刻时间信息
        Instant now = Instant.now();

        // 获取总秒数
        long second = now.getEpochSecond();
        System.out.println(second);

        // 不够一秒的纳秒数
        int nano = now.getNano();
        System.out.println(nano);

        // 增加、减少时间
        Instant instant1 = now.plusNanos(111);
        Instant instant2 = now.minusMillis(2);

        System.out.println(now);

        // Instant对象的作用:做代码的性能分析,或者记录用户的操作时间点
        Instant now1 = Instant.now();
        // 代码行……
        Instant now2 = Instant.now();
    }
}
  • 作用:可以用来记录代码的执行时间,或者记录用户的操作某个时间时间点。
  • 传统的Date类,只能精确到毫秒,并且是可变对象
  • 新增的Instant类,可以精确到纳秒,并且是不可变对象,推荐用Instant代替Date。

DateTimeFormatter

import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class Test {
    public static void main(String[] args) {
        // 创建一个日期时间格式化器对象
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");

        // 对时间进行格式化
        LocalDateTime now = LocalDateTime.now();
        System.out.println(now);

        String rs = formatter.format(now);
        System.out.println(rs);

        // 格式化时间的另一种方案
        String rs2 = now.format(formatter);
        System.out.println(rs2);

        // 解析时间
        String dateStr = "2029年12月12日 12:12:12";
        LocalDateTime ldt = LocalDateTime.parse(dateStr,formatter);
        System.out.println(ldt);
    }
}

?

Period、Duration

Period(一段时期)

  • 可以用于计算两个LocalDate对象相差的年数、月数、天数。
import java.time.LocalDate;
import java.time.Period;

public class Test {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2029,8,10);
        LocalDate end = LocalDate.of(2029,12,15);

        // 创建Period对象,封装两个日期对象
        Period period = Period.between(start,end);

        // 通过Period对象获取两个日期对象相差的信息
        System.out.println(period.getYears());
        System.out.println(period.getMonths());
        System.out.println(period.getDays());
    }
}

?

Duration(持续时间)

  • 可以用于计算两个时间对象相差的天数、小数数、分数、秒数、纳秒数;支持LocalTime、LocalDateTime、Instant等时间。
import java.time.Duration;
import java.time.LocalDateTime;

public class Test {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2029,11,11,11,10,10);
        LocalDateTime end = LocalDateTime.of(2029,11,11,11,11,11);

        // 创建Duration对象,封装两个时间对象
        Duration duration = Duration.between(start,end);

        // 通过Duration对象获取两个时间对象相差的信息
        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());
    }
}
文章来源:https://blog.csdn.net/SU_mu147/article/details/135315652
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。