深入了解 Java 中的时间信息定义、转换、比较和操作

最新推荐文章于 2024-05-08 22:37:38 发布

春哥的魔法书

最新推荐文章于 2024-05-08 22:37:38 发布

阅读量438

点赞数 2

分类专栏： java API 文章标签： java API Date

本文链接：https://blog.csdn.net/yuanchun05/article/details/133800448

版权

java 同时被 2 个专栏收录

18 篇文章 4 订阅

订阅专栏

API

2 篇文章 0 订阅

订阅专栏

1. 简介

在过去的传统Java日期处理中，经常面临着一些问题。比如，java.util.Date和java.util.Calendar在表示日期和时间时存在着一些奇怪的行为，如月份从0开始计数、对日期进行格式化的方式繁琐不直观等。这些问题给开发带来了一定的困扰。

随着Java 8的发布，引入了全新的时间API —— java.time包，这个新的API提供了更加直观和易用的方式来处理日期和时间。它以更加语义化的方式来表示日期、时间和时间间隔，并提供了丰富的操作方法和函数，使得我们在处理日期和时间时更加方便和高效。

2. 常用时间信息定义方法

2.1.java.util.Date类的使用

在早期的 Java 中，使用java.util.Date类来表示日期和时间是很常见的。

import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        Date date = new Date();
        System.out.println("当前日期和时间: " + date);
    }
}

然而，这个类在设计上存在一些问题，导致了它的使用变得麻烦和容易出错。

问题之一是java.util.Date类在表示月份时从0开始计数，这与我们通常的理解不符。例如，如果我们想表示1月份，我们需要传入0作为月份的参数，这容易引起误解和错误。

另一个问题是java.util.Date类中的很多方法已经被废弃不建议使用。例如，获取年份需要使用getYear()方法，但它返回的是相对于1900年的偏移值。此外，Date类还不是线程安全的，这意味着在多线程环境下使用时需要额外的同步措施。

下面是一个示例代码，展示了如何创建和操作java.util.Date类对象：

import java.util.Date;

public class DateExample {
    public static void main(String[] args) {
        // 创建一个当前时间的 Date 对象
        Date currentDate = new Date();

        // 获取年份（需要加上1900）
        int year = currentDate.getYear() + 1900;

        // 获取月份（需要加上1）
        int month = currentDate.getMonth() + 1;

        // 获取日期
        int day = currentDate.getDate();

        // 打印日期信息
        System.out.println("Current Date: " + year + "-" + month + "-" + day);
    }
}

2.2.java.util.Calendar 类的使用

为了弥补java.util.Date类的不足，Java引入了java.util.Calendar类来处理日期和时间。Calendar类提供了一系列的方法，用于获取和修改年、月、日、时、分、秒等字段。

然而，Calendar类的使用也存在一些问题。首先，它是一个抽象类，不能直接实例化，需要通过Calendar.getInstance()方法获取其实例。其次，月份还是从0开始计数，导致与人们的理解不一致。此外，Calendar类也不是线程安全的，需要额外的同步措施。

下面是一个示例代码，展示了如何使用java.util.Calendar类来获取和修改日期信息：

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

public class CalendarExample {
    public static void main(String[] args) {
        // 获取当前日期和时间的 Calendar 对象
        Calendar calendar = Calendar.getInstance();

        // 获取年份
        int year = calendar.get(Calendar.YEAR);

        // 获取月份（需要加上1）
        int month = calendar.get(Calendar.MONTH) + 1;

        // 获取日期
        int day = calendar.get(Calendar.DAY_OF_MONTH);
   
        // 打印日期信息
        System.out.println("Current Date: " + year + "-" + month + "-" + day);
        
        // 获取小时
        int hour = calendar.get(Calendar.HOUR_OF_DAY);
                
        // 获取分钟
        int minute = calendar.get(Calendar.MINUTE);
                
        // 获取秒
        int second = calendar.get(Calendar.SECOND);
        
        // 打印时间信息
        System.out.println("Current Time: " + hour + "-" + minute + "-" + second);
        
        
        // 修改月份为下个月
        calendar.add(Calendar.MONTH, 1);

        // 获取修改后的日期信息
        int updatedMonth = calendar.get(Calendar.MONTH) + 1;
        int updatedDay = calendar.get(Calendar.DAY_OF_MONTH);

        // 打印修改后的日期信息
        System.out.println("Updated Date: " + year + "-" + updatedMonth + "-" + updatedDay);
    }
}

2.3.新的时间 API（java.time 包）的介绍

为了解决java.util.Date和java.util.Calendar的问题，Java 8引入了新的时间 API java.time包。这个新的API为处理日期和时间提供了更直观和易用的方式。

java.time包中的核心类包括：

LocalDate：用于表示日期，不包含具体时间和时区信息；
LocalTime：用于表示时间，不包含日期和时区信息；
LocalDateTime：用于表示日期和时间，不包含时区信息；
ZonedDateTime：用于表示带有时区的日期和时间。

下面是一个示例代码，展示了如何使用新的时间 API 来创建和操作日期和时间：

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
import java.time.ZonedDateTime;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;

public class DateTimeExamples {
    public static void main(String[] args) {
        // 使用新的时间 API 创建日期对象
        LocalDate date = LocalDate.now();
        System.out.println("当前日期: " + date); 

        // 使用新的时间 API 创建时间对象
        LocalTime time = LocalTime.now();
        System.out.println("当前时间: " + time); 

        // 使用新的时间 API 创建日期和时间对象
        LocalDateTime dateTime = LocalDateTime.now();
        System.out.println("当前日期和时间: " + dateTime); 

        // 使用新的时间 API 创建带时区的日期和时间对象
        ZonedDateTime zonedDateTime = ZonedDateTime.now();
        System.out.println("当前带时区的日期和时间: " + zonedDateTime);

        // 使用 java.sql.Date 表示日期
        Date sqlDate = Date.valueOf(date);
        System.out.println("java.sql.Date: " + sqlDate);

        // 使用 java.sql.Time 表示时间
        Time sqlTime = Time.valueOf(time);
        System.out.println("java.sql.Time: " + sqlTime); 

        // 使用 java.sql.Timestamp 表示时间戳（包含日期和时间）
        Timestamp timestamp = Timestamp.valueOf(dateTime);
        System.out.println("java.sql.Timestamp: " + timestamp); 
        
        // 自定义时间
        LocalDateTime dateTime1 = LocalDateTime.of(2023, 10, 12, 8, 0, 0);
        System.out.println(" 自定义LocalDateTime时间: " + dateTime1); 
        
        
    }
}

通过新的时间 API，我们可以直接创建表示日期、时间、日期和时间以及时区的对象，并进行各种操作，如日期比较、日期加减等。这使得我们在处理日期和时间时更加直观和便利。

2.3.1.取时间

import java.time.LocalDateTime;
import java.time.Month;

public class InfoExamples {

    public static void main(String[] args)  {

        // 当前时间
        LocalDateTime now = LocalDateTime.now();
        // 取年份
        int year = now.getYear();
        System.out.println("年份year = " + year);
        // 取月份名
        Month month = now.getMonth();
        System.out.println("月份名month = " + month);
        // 取月份
        int monthValue = now.getMonthValue();
        System.out.println("月份monthValue = " + monthValue);
        // 取日期
        int dayOfMonth = now.getDayOfMonth();
        System.out.println("dayOfMonth = " + dayOfMonth);
        // 取 24小时制小时
        int hour = now.getHour();
        System.out.println("hour = " + hour);
        // 取分钟
        int minute = now.getMinute();
        System.out.println("minute = " + minute);
        // 取秒
        int second = now.getSecond();
        System.out.println("second = " + second);
    }
}

3. 时间戳的概念与使用

3.1.时间戳

时间戳是一种表示从某个特定时间起至今所经过的时间的方式。它通常以整数或浮点数的形式表示，并在不同的编程语言和数据库中具有不同的实现方式。时间戳被广泛用于记录事件的先后顺序、进行时间的比较和排序、计算时间间隔等操作。

在Java中，时间戳通常使用 java.util.Date 或 java.time.Instant 类型来表示。以下是关于时间戳概念和使用的一些重点说明：

3.1.1.`java.util.Date` 的时间戳

java.util.Date 类中的 getTime() 方法可以获取自1970年1月1日00:00:00 UTC（协调世界时）以来的毫秒数形式的时间戳。这个时间戳可以作为一个长整型数值进行存储或传递。下面是一个示例代码：

import java.util.Date;

public class TimestampExample {
    public static void main(String[] args) {
        Date now = new Date();
        long timestamp = now.getTime();
        System.out.println("时间戳: " + timestamp);
    }
}

3.1.2.`java.time.Instant` 的时间戳

在新的时间 API（java.time 包）中，java.time.Instant 类提供了更加简洁和易用的方式来表示时间戳。我们可以使用 Instant.now() 方法获取当前时间的时间戳，并使用 toEpochMilli() 方法将其转换为毫秒数形式的时间戳。以下是一个示例代码：

import java.time.Instant;

public class InstantExample {
    public static void main(String[] args) {
        Instant now = Instant.now();
        long timestamp = now.toEpochMilli();
        System.out.println("时间戳: " + timestamp);
    }
}

3.1.3.当前时间戳转时间类型

时间戳的使用方式：
时间戳可以用于各种操作，如时间的比较、排序、存储或传输。在进行时间比较时，可以简单地通过比较两个时间戳的数值来确定它们的先后顺序。时间戳的另一个重要用途是计算时间间隔，可以通过相减两个时间戳的数值来获取它们之间的毫秒数差值。

需要注意的是，时间戳通常是以格林尼治标准时间（GMT）或协调世界时（UTC）为基准的，因此在使用时间戳时应注意时区的转换和处理。

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class TimestampExample {

    public static void main(String[] args)  {

        // 获取当前时间的时间戳
        long timestamp = System.currentTimeMillis();
        System.out.println("当前时间戳：" + timestamp);

        // 将时间戳转换为日期对象
        Date date = new Date(timestamp);
        System.out.println("时间戳转换为日期对象：" + date);

        // 将时间戳转换为本地日期时间对象
        Instant instant = Instant.ofEpochMilli(timestamp);
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        System.out.println("时间戳转换为本地日期时间对象：" + localDateTime);

        // 将Java 8时间类型转换为时间戳
        LocalDateTime localDateTime3 = LocalDateTime.now();
        long timestamp2 = localDateTime3.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli();
        System.out.println("Java 8时间类型转换为时间戳：" + timestamp2);
    }
}

3.2.`java.sql.Timestamp`

java.sql.Timestamp是Java中用于表示SQL数据库中的日期和时间信息的类。它是java.util.Date的子类，并扩展了它的功能以支持更高精度的时间信息，尤其是对于代表纳秒级别精度的时间戳。

以下是一些关于java.sql.Timestamp的重要说明：

3.2.1.创建`java.sql.Timestamp`对象

您可以使用多种方式创建java.sql.Timestamp对象。其中最常用的方式是通过使用java.sql.Timestamp(long time)构造函数，该构造函数接受一个代表自1970年1月1日00:00:00 UTC以来的毫秒数的参数。

以下是一个示例代码，展示了如何创建一个java.sql.Timestamp对象：

import java.sql.Timestamp;

public class TimestampExample {
    public static void main(String[] args) {
        long timestampInMillis = System.currentTimeMillis();
        Timestamp timestamp = new Timestamp(timestampInMillis);
        System.out.println("时间戳: " + timestamp);
    }
}

3.2.2.与数据库的交互

java.sql.Timestamp常被用于与数据库进行日期和时间类型的交互。当从数据库中查询到一个日期或时间字段时，可以使用java.sql.ResultSet对象的getTimestamp(int columnIndex)或getTimestamp(String columnLabel)方法获取一个java.sql.Timestamp对象。

以下是一个示例代码，展示了如何从数据库中获取一个日期时间字段的时间戳：

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;

public class DatabaseExample {
    public static void main(String[] args) {
        String url = "jdbc:mysql://localhost:3306/mydatabase";
        String username = "root";
        String password = "password";

        try (Connection conn = DriverManager.getConnection(url, username, password);
             PreparedStatement stmt = conn.prepareStatement("SELECT datetime_column FROM mytable");
             ResultSet rs = stmt.executeQuery()) {
            
            if (rs.next()) {
                Timestamp timestamp = rs.getTimestamp("datetime_column");
                System.out.println("时间戳: " + timestamp);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

注意，上述代码仅是一个简化示例，实际情况下需要根据具体的数据库和表结构进行相应的操作。

java.sql.Timestamp类还提供了许多其他方法，以便灵活地处理日期和时间信息，如获取特定部分的日期或时间（年、月、日、小时等），格式化输出等。您可以参考Java官方文档以获取更详细的信息。

4.相互转换

4.1. `String` 类型与时间类型的相互转换

这一部分我们详细说明了如何将String类型与不同时间类型进行相互转换

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Date;

public class StringConvertExample {
    public static void main(String[] args) {
        
        // 将字符串日期转换为java.util.Date
        String dateString = "2023-10-12";
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        Date date = dateFormat.parse(dateString);
        System.out.println("字符串转换为java.util.Date：" + date);

        // 将字符串日期转换为Java 8 时间类型
        String dateFormattedString = "2023-10-12";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
        LocalDate localDate = LocalDate.parse(dateFormattedString, formatter);
        System.out.println("字符串转换为Java 8 时间类型：" + localDate);
    }
}

4.2.时间格式化

使用java.time.format.DateTimeFormatter进行格式化，使用java.time.format.FormatStyle进行简化格式化，以及使用java.time.format.DateTimeFormatterBuilder进行自定义格式化。

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeFormatterBuilder;
import java.time.format.FormatStyle;
import java.util.Date;

public class FormatExample {

    public static void main(String[] args)  {

        // 将java.util.Date转换为字符串日期
        Date date = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
        String format = dateFormat.format(date);
        System.out.println("java.util.Date转换为字符串：" + format);

        // 使用java.time.format.DateTimeFormatter进行格式化
        LocalDateTime dateTime = LocalDateTime.now();
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = dateTime.format(formatter);
        System.out.println("格式化后的时间：" + formattedDateTime);

        // 使用java.time.format.FormatStyle进行格式化
        LocalDateTime dateTime2 = LocalDateTime.now();
        DateTimeFormatter formatter2 = DateTimeFormatter.ofLocalizedDateTime(FormatStyle.MEDIUM);
        String formattedDateTime2 = dateTime.format(formatter);
        System.out.println("格式化后的时间：" + formattedDateTime2);

        // 使用java.time.format.DateTimeFormatterBuilder进行自定义格式化
        LocalDateTime dateTime3 = LocalDateTime.now();
        DateTimeFormatter formatter3 = new DateTimeFormatterBuilder()
            .appendPattern("yyyy年MM月dd日 HH时mm分ss秒")
            .toFormatter();
        String formattedDateTime3 = dateTime3.format(formatter3);
        System.out.println("格式化后的时间：" + formattedDateTime3);
    }
}

4.3. 不同时间类型的相互转换

java.util.Date, Java 8时间类型相互转换

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class DateConvertExample {
    public static void main(String[] args)  {

        // 将java.util.Date转换为Java 8时间类型
        Date date = new Date();
        Instant instant = date.toInstant();
        LocalDateTime localDateTime = LocalDateTime.ofInstant(instant, ZoneId.systemDefault());
        System.out.println("java.util.Date转换为Java 8时间类型：" + localDateTime);

        // 将Java 8时间类型转换为java.util.Date
        LocalDateTime localDateTime2 = LocalDateTime.now();
        Instant instant2 = localDateTime.atZone(ZoneId.systemDefault()).toInstant();
        Date date2 = Date.from(instant);
        System.out.println("Java 8时间类型转换为java.util.Date：" + date2);

    }
}

5.Java8操作方法

5.1.时间比较和操作

时间的比较和操作，包括比较两个时间的先后顺序、计算时间差以及对时间进行增减操作。

import java.time.Duration;
import java.time.LocalDateTime;

public class DateActionExample {

    public static void main(String[] args)  {

        // 比较两个时间的先后顺序
        LocalDateTime dateTime1 = LocalDateTime.of(2023, 10, 12, 8, 0, 0);
        LocalDateTime dateTime2 = LocalDateTime.of(2023, 10, 12, 10, 0, 0);
        boolean isAfter = dateTime1.isAfter(dateTime2);
        System.out.println("dateTime1是否在dateTime2之后：" + isAfter);
        boolean isBefore = dateTime1.isBefore(dateTime2);
        System.out.println("dateTime1是否在dateTime2之前：" + isBefore);
        boolean isEqual = dateTime1.isEqual(dateTime2);
        System.out.println("dateTime1是否与dateTime2相等：" + isEqual);

        // 计算时间差
        LocalDateTime oldDateTime = LocalDateTime.of(2023, 10, 12, 8, 0, 0);
        LocalDateTime newDateTime = LocalDateTime.of(2023, 10, 12, 10, 0, 0);
        Duration duration = Duration.between(oldDateTime, newDateTime);
        long hours = duration.toHours();
        System.out.println("时间差（小时）：" + hours);

        // 对时间进行增减操作
        LocalDateTime dateTime = LocalDateTime.of(2023, 10, 12, 8, 0, 0);
        LocalDateTime addedDateTime = dateTime.plusHours(2);
        System.out.println("增加2小时后的时间：" + addedDateTime);
        LocalDateTime subtractedDateTime = dateTime.minusHours(2);
        System.out.println("减少2小时后的时间：" + subtractedDateTime);
        LocalDateTime withDateTime = dateTime.withHour(2);
        System.out.println("设置成2点 = " + withDateTime);
    }
}