04_使用API_日期和时间

关注

原创最新推荐文章于 2026-05-14 10:48:04 发布 313 阅读 AI 写同款· GEO 优化 ›

【超详细】HIVE 日期函数（当前日期、时间戳转换、前一天日期等）【超详细】HIVE 日期函数（当前日期、时间戳转换、前一天日期等）常量：当前日期、时间戳前一天日期、后一天日期获取日期中的年、季度、月、周、日、小时、分、秒等时间戳转换秒 to 时间戳时间戳 to 秒日期 to 时间戳日期之间月、天数差阅读详情

JDK 8 之前传统的日期、时间

Date 类

代表的是日期和时间

import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // 1. 创建一个Data对象，代表系统当前时间信息的
        Date d = new Date();
        System.out.println(d);  // 输出的是日期与当前的时间信息

        // 2. 拿到时间毫秒值
        long time = d.getTime();
        System.out.println(time);  // 输出毫秒值

        // 3. 把时间毫秒值转换成对象日期：2s之后的时间是多少
        time += 2 * 1000;  // 2 ms * 1000 == 2s
        Date d2 = new Date(time);

        // 4. 直接把日期对象的时间，通过setTime方法进行修改
        Date d3 = new Date();
        d3.setTime(time);
        System.out.println(d3);
    }
}

SimpleDateFormat 类

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

public class Test {
    public static void main(String[] args) throws ParseException {
        // 1. 准备一些时间
        Date d = new Date();
        System.out.println(d);  // 日期+时间

        long time = d.getTime();
        System.out.println(time);  // 时间毫秒值

        // 2. 格式化日期对象，和时间毫秒值
        SimpleDateFormat obj = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
        String res = obj.format(d);
        String res2 = obj.format(time);
        System.out.println(res);
        System.out.println(res2);

        // 3. 常见时间格式
        /*
         *   y   年
         *   M   月
         *   d   日
         *   H   时
         *   m   分
         *   s   秒
         *   EEE 星期几
         *   a   上午/下午
         * */

        // 4. 将已被格式化的时间字符串，转变回原来的时间对象
        String dateStr = "2023--15-20 15:35:21";
        SimpleDateFormat obj2 = new SimpleDateFormat("yyyy--MM-dd HH:mm:ss");
        Date d2 = obj2.parse(dateStr);
        System.out.println(d2);  // 日期+时间

    }
}

Calendar 类

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

import java.util.Calendar;
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        // 1. 得到系统此刻时间对应的日历对象
        Calendar obj = Calendar.getInstance();
        System.out.println(obj);

        // 2. 获取日历中的某个信息
        int year = obj.get(Calendar.YEAR);
        System.out.println(year);  // 输出年份

        int days = obj.get(Calendar.DAY_OF_YEAR);
        System.out.println(days);  // 一年365天中的第x天

        // 3. 拿到日历中记录的日期对象
        Date d = obj.getTime();
        System.out.println(d);

        // 4. 拿到时间毫秒值
        long time = obj.getTimeInMillis();
        System.out.println(time);

        // 5. 修改日历中的某个信息
        obj.set(Calendar.MONTH, 9);  // 月份是从0开始计算，所以这里是修改为10月
        System.out.println(obj.get(Calendar.MONTH));  // 9
        obj.set(Calendar.DAY_OF_YEAR, 250);  // 修改为一年中的第250天
        System.out.println(obj.get(Calendar.DAY_OF_YEAR));  // 250

        // 6. 为某个信息增加或者减少多少
        obj.add(Calendar.DAY_OF_YEAR, 100);
        obj.add(Calendar.DAY_OF_YEAR, -100);
        System.out.println(obj.get(Calendar.DAY_OF_YEAR));  // 250
    }
}

JDK 8 开始新增的日期、时间

它们的优点

设计更合理，功能丰富，使用更方便
都是不可变对象，修改后会返回新的时间对象，不会丢失最开始的时间
线程安全
能精确到毫秒、纳秒

LocalDate、LocalTime、LocalDateTime

LocalDate：代表本地日期（年、月、日、星期）
LocalTime：代表本地时间（时、分、秒、纳秒）
LocalDateTime：代表本地日期、时间（年、月、日、星期、时、分、秒、纳秒）

// LocalDate

import java.time.LocalDate;

public class Test {
    public static void main(String[] args) {
        // 1. 获取本地日期对象（不可变对象）
        LocalDate date = LocalDate.now();
        System.out.println(date);  // 2023-11-24

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

        // 3. 修改信息（本质不是修改原来的，而是新建了一个对象）
        LocalDate newDate = date.withYear(2050);
        System.out.println(date);  // 2023-11-24
        System.out.println(newDate);  // 2050-11-24

        // 4. 把某个信息加(或者减)多少（本质不是修改原来的，而是新建了一个对象）
        LocalDate date1 = date.plusYears(10);
        LocalDate date2 = date.minusYears(10);

        // 5. 指定日期的LocalDate对象
        LocalDate date3 = LocalDate.of(2035, 10, 1);

        // 6. 判断2个日期对象，是否相等，在前还是在后
        System.out.println(date1.equals(date2));  // false
        System.out.println(date1.isAfter(date2));  // true
        System.out.println(date1.isBefore(date2));  // false
        
    }
}

// LocalTime

import java.time.LocalTime;

public class Test {
    public static void main(String[] args) {
        // 1. 获取本地时间对象（不可变对象）
        LocalTime time = LocalTime.now();
        System.out.println(time);  // 23:56:28.720309500

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

        // 3. 修改信息（本质不是修改原来的，而是新建了一个对象）
        LocalTime time1 = time.withHour(8);

        // 4. 把某个信息加(或者减)多少（本质不是修改原来的，而是新建了一个对象）
        LocalTime time2 = time.plusHours(8);
        LocalTime time3 = time.minusHours(8);

        // 5. 指定时间的LocalTime对象
        LocalTime time4 = LocalTime.of(12, 15);

        // 6. 判断2个时间对象，是否相等，在前还是在后
        System.out.println(time1.equals(time2));
        System.out.println(time1.isAfter(time2));
        System.out.println(time1.isBefore(time2));

    }
}

// LocalDateTime

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;

public class Test {
    public static void main(String[] args) {
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println(dateTime);  // 2023-11-25T10:08:23.410530300

        // 1. 可以获取日期和时间的全部信息
        int year = dateTime.getYear();
        int month = dateTime.getMonthValue();
        int day = dateTime.getDayOfMonth();
        int dayOfYear = dateTime.getDayOfYear();
        int dayOfWeek = dateTime.getDayOfWeek().getValue();
        int hour = dateTime.getHour();
        int minute = dateTime.getMinute();
        int second = dateTime.getSecond();
        int nano = dateTime.getNano();

        // 2. 修改时间
        LocalDateTime dateTime1 = dateTime.withYear(2035);

        // 3. 加减
        LocalDateTime dateTime2 = dateTime.plusYears(5);
        LocalDateTime dateTime3 = dateTime.minusYears(5);

        // 4. 获取指定日期和时间的LocalDateTime对象
        LocalDateTime dateTime4 = LocalDateTime.of(2055, 6, 1, 12, 30, 15, 3000);
        System.out.println(dateTime4);  // 2055-06-01T12:30:15.000003

        // 5. 判断日期时间对象是否相等，在前还是在后
        System.out.println(dateTime1.equals(dateTime2));
        System.out.println(dateTime1.isAfter(dateTime2));
        System.out.println(dateTime1.isBefore(dateTime2));

        // 6. 可以把LocalDateTime对象，转为LocalDate和LocalTime
        LocalDate date = dateTime.toLocalDate();
        LocalTime time = dateTime.toLocalTime();
        System.out.println(date);  // 2023-11-25
        System.out.println(time);  // 10:20:04.680774700
    }
}

时区

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

public class Test {
    public static void main(String[] args) {
        // 1. 获取系统默认的时区
        ZoneId obj = ZoneId.systemDefault();
        System.out.println(obj);  // GMT+08:00
        System.out.println(obj.getId());  // GMT+08:00

        // 2. 显示 Java 支持的全部时区 Id
        System.out.println(ZoneId.getAvailableZoneIds());  // [Asia/Aden, America/Cuiaba, Etc/GMT+9, Etc/GMT+8, Africa/Nairobi......]

        // 3. 把某个时区的id封装成ZoneId对象
        ZoneId obj1 = ZoneId.of("America/Cuiaba");

        // 4. 获取某个时区的ZonedDatetime对象
        ZonedDateTime obj2 = ZonedDateTime.now(obj1);
        System.out.println(obj2);  // 输出 America/Cuiaba 时区当前的时间，如下所示
        // 2023-11-24T22:50:05.534176500-04:00[America/Cuiaba]

        // 5. 获取世界标准时间
        ZonedDateTime obj3 =  ZonedDateTime.now(Clock.systemUTC());
        System.out.println(obj3);  // 2023-11-25T02:54:06.575812300Z

        // 6. 获取系统默认时区的ZonedDateTime对象
        ZonedDateTime obj4 = ZonedDateTime.now();
        System.out.println(obj4);  // 2023-11-25T10:55:46.410093200+08:00[GMT+08:00]
    }
}

Instant (时刻/时间戳)

传统的 Date 类只能精确到毫秒，并且是可变对象
新增的 Instant 类可以精确到纳秒，并且是不可变对象（推荐使用 Instant 替代 Date ）

import java.time.Instant;

public class Test {
    public static void main(String[] args) {
        // 1. 创建 Instant 的对象，获取此"刻"信息(该信息由两部分组成："总秒数" + "不够1秒的纳秒数")
        Instant obj = Instant.now();
        System.out.println(obj);  // 2023-11-25T03:05:00.754167800Z

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

        // 3. 获取纳秒数
        int nano = obj.getNano();
        System.out.println(nano);

        // 4. 其他基本操作，类比之前的方法，它们的方法有共通性，而且都是不可变对象
        Instant instant1 = Instant.now();
        Instant instant2 = Instant.now();

        System.out.println(instant1.equals(instant2));  // 判断是否相等
        System.out.println(instant1.isAfter(instant2));
        System.out.println(instant1.isBefore(instant2));

        Instant instant3 = instant1.plusSeconds(5);  // +5 秒
        Instant instant4 = instant1.minusSeconds(5);  // -5 秒
    }
}

DateTimeFormatter (日期时间格式化器)

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

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

        // 2. 对时间进行格式化
        // 2.0 准备一个时间
        LocalDateTime dateTime = LocalDateTime.now();  // 创建日期时间对象
        System.out.println(dateTime);  // 输出该对象 2023-11-25T11:24:22.524304100

        // 2.1 方法一
        String str1 = formatter.format(dateTime);  // 格式化这个日期时间对象
        System.out.println(str1);  // 输出格式化后的结果 2023年11月25日 11:24:22

        // 2.2 方法二
        String str2 = dateTime.format(formatter);
        System.out.println(str2);  // 2023年11月25日 11:24:22

        // 4. 解析时间：一般使用 LocalDateTime 提供的解析方法来解析
        String str = "2023年11月25日 11:25:25";
        LocalDateTime obj = LocalDateTime.parse(str, formatter);
        System.out.println(obj);  // 2023-11-25T11:25:25
    }
}

Period（一段时期）

用于计算两个 LocalDate 对象相差的年数、月数、天数

import java.time.LocalDate;
import java.time.Period;

public class Test {
    public static void main(String[] args) {
        LocalDate start = LocalDate.of(2030, 8, 6);
        LocalDate end = LocalDate.of(2030, 8, 20);

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

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

    }
}

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(2028, 5, 10, 12, 15, 30);
        LocalDateTime end = LocalDateTime.of(2028, 5, 25, 8, 0, 0);

        // 1. 得到 Duration 对象
        Duration obj = Duration.between(start, end);

        // 2. 获取两个时间对象间隔的信息
        System.out.println(obj.toDays());  // 间隔多少天
        System.out.println(obj.toHours());  // 间隔多少小时
        System.out.println(obj.toMinutes());  // 间隔多少分
        System.out.println(obj.toSeconds());  // 间隔多少秒
        System.out.println(obj.toMillis());  // 间隔多少毫秒
        System.out.println(obj.toNanos());  // 间隔多少纳秒

    }
}