1.JAVA时间相关类汇总
java.util
-
java.util.Date： 是 Java 最早的日期时间类，但它已被弃用。它表示自 1970 年 1 月 1 日 00:00:00 GMT（格林尼治标准时间）以来的毫秒数。
-
java.util.Calendar： 是用于处理日期时间的抽象基类。它提供了对日期时间字段（如年、月、日、小时等）进行操作的方法。
-
java.util.GregorianCalendar： 是 Calendar 的具体子类，用于实现格里高利历。它提供了对日期时间的操作，同时支持国际化和本地化。
java.time
java.time 包下的类： Java 8 引入了新的日期时间 API，包括以下几个主要类：
- java.time.LocalDate： 表示日期（年、月、日）。
- java.time.LocalTime： 表示时间（小时、分钟、秒）。
- java.time.LocalDateTime： 表示日期时间（年、月、日、小时、分钟、秒）。
- java.time.ZonedDateTime： 表示带时区的日期时间。
- java.time.Instant： 表示时间戳（从1970-01-01T00:00:00Z开始的秒数）。
- java.time.Duration： 表示持续时间。
- java.time.Period： 表示日期间隔。
java.sql
java.sql 包下的类： 用于处理数据库中的日期时间数据，主要包括以下几个类：
- java.sql.Date： 表示 SQL DATE 类型，仅包含日期（年、月、日），没有时间部分。
- java.sql.Time： 表示 SQL TIME 类型，仅包含时间（小时、分钟、秒），没有日期部分。
- java.sql.Timestamp： 表示 SQL TIMESTAMP 类型，包含日期和时间（年、月、日、小时、分钟、秒）。
Other
除了上述提到的常用的时间类之外，还有一些其他的时间类，虽然不太常用，但也值得了解：
-
java.util.DateUtils： DateUtils 类是 Apache Commons Lang 库中的一个实用类，提供了一些有用的静态方法来处理日期时间，例如日期加减、格式化、比较等。
-
java.text.SimpleDateFormat： SimpleDateFormat 类是用于格式化和解析日期时间字符串的类。它允许你通过模式字符串来定义日期时间的格式，例如 “yyyy-MM-dd HH:mm:ss”。
-
java.util.Timer 和 java.util.TimerTask： Timer 类用于调度后台线程以在指定时间执行任务，而 TimerTask 则是要执行的任务。它们可以用于定时执行一些操作，如定时任务、定时器等。
-
java.time.format.DateTimeFormatter： DateTimeFormatter 类是 Java 8 中用于日期时间格式化和解析的类。它可以将日期时间对象格式化为字符串，也可以将字符串解析为日期时间对象，提供了丰富的日期时间格式化选项。
这些类可以根据具体的需求来选择使用。在进行日期时间处理时，建议优先选择 Java 8 中引入的新的日期时间 API（java.time 包下的类），因为它们提供了更好的性能和功能，同时支持不可变性和线程安全性。
2.常用时间类详细介绍使用
java.util.Date概念介绍
java.util.Date 是 Java 最早引入的日期时间类之一，用于表示特定的日期和时间点。以下是关于 java.util.Date 类的一些详细介绍：
-
日期时间表示：
java.util.Date表示自 1970 年 1 月 1 日 00:00:00 GMT（格林尼治标准时间）以来的毫秒数。它实际上是一个包装了一个长整型值的对象，该长整型值表示的是自纪元以来的毫秒数。 -
不可变性：
java.util.Date类是不可变的，一旦创建了一个Date对象，其值就不能被修改。这意味着你不能直接更改Date对象的日期或时间，而是需要创建一个新的Date对象来表示新的日期或时间。 -
过时方法： 尽管
java.util.Date是 Java 中最早的日期时间类之一，但它已经被标记为过时（deprecated）。这是因为它存在一些问题，比如它不支持时区信息，也不是线程安全的。因此，Java 8 引入了新的日期时间 API（java.time 包下的类），推荐使用新的 API 来替代java.util.Date。 -
与时间戳的关系：
java.util.Date类本质上是一个时间戳，表示从1970年1月1日00:00:00以来的毫秒数。它类似于 Unix 时间戳（Unix Epoch），但是精确度更高，可以精确到毫秒级别。 -
格式化和解析：
java.util.Date类本身不负责格式化和解析日期时间字符串，但可以通过SimpleDateFormat类来进行格式化和解析。 -
使用注意事项： 尽管
java.util.Date类已被标记为过时，但在某些情况下仍然会使用到它。在使用时需要注意避免直接使用它的构造函数和部分方法，尽量使用 Calendar 类或新的日期时间 API 来处理日期和时间。
java.util.Date基本使用
java.util.Date 类是 Java 中最早的日期时间类之一，用于表示特定的日期和时间点。虽然它已经被标记为过时（deprecated），但在某些情况下仍然会被使用。以下是关于如何使用 java.util.Date 类的一些示例：
1. 创建 Date 对象
要创建一个表示当前日期时间的 Date 对象，可以直接调用无参构造函数：
Date currentDate = new Date();
2. 获取日期时间
可以使用 getTime() 方法获取日期时间的毫秒数表示：
long milliseconds = currentDate.getTime();
3. 格式化输出
可以使用 SimpleDateFormat 类来将 Date 对象格式化为指定格式的字符串：
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = sdf.format(currentDate);
System.out.println("Formatted Date: " + formattedDate);
4. 日期时间比较
可以使用 compareTo() 方法比较两个 Date 对象的先后顺序：
Date anotherDate = new Date();
if (currentDate.compareTo(anotherDate) > 0) {
// currentDate 晚于 anotherDate
} else if (currentDate.compareTo(anotherDate) < 0) {
// currentDate 早于 anotherDate
} else {
// 两个日期相等
}
5. 时间戳转换
可以使用 java.sql.Timestamp 类将 Date 对象转换为 SQL TIMESTAMP 类型：
Timestamp timestamp = new Timestamp(currentDate.getTime());
6. 其他操作
- 使用
setTime()方法设置日期时间的毫秒数。 - 使用
before()和after()方法比较日期时间的先后顺序。 - 注意
java.util.Date对象是可变的，可以通过setTime()方法直接改变其值，因此在多线程环境下需要谨慎使用。
java.util.Calendar概念
java.util.Calendar 是 Java 提供的日期时间操作的一个类，它提供了一组方法来处理日期和时间，并支持国际化和时区。以下是关于 java.util.Calendar 类的详细介绍：
-
抽象基类：
java.util.Calendar是一个抽象基类，用于表示日期时间对象。它提供了一个通用的日历系统，可以处理日期、时间、星期几等日历字段，并支持对这些字段进行操作。 -
单例获取：
Calendar类通过getInstance()静态方法来获取一个Calendar对象的实例。默认情况下，该方法返回一个表示当前日期时间的Calendar对象。 -
操作日期时间：
Calendar类提供了一系列方法来操作日期时间，包括设置、获取日期时间字段（年、月、日、时、分、秒等）、日期时间加减、日期比较等操作。 -
时区和地区：
Calendar类支持时区和地区的设置，可以根据需要设置不同的时区和地区，以处理不同地区的日期时间。 -
国际化支持：
Calendar类支持国际化，可以根据不同的地区和语言来格式化日期时间，以及获取星期几、月份等信息。 -
线程安全性：
Calendar类的实例不是线程安全的，如果多个线程需要访问和操作同一个Calendar实例，则需要使用同步机制来确保线程安全。 -
与时间戳的关系： 与
java.util.Date类不同，Calendar类不直接表示日期时间的毫秒数，而是根据日历系统的规则来表示日期时间字段，因此在处理日期时间时更加灵活。 -
使用注意事项：
Calendar类是一个老旧的日期时间类，在 Java 8 引入了新的日期时间 API（java.time 包下的类）后，推荐使用新的 API 来处理日期和时间，因为新的 API 更加简洁、清晰，并且解决了Calendar类存在的一些问题。
总的来说，java.util.Calendar 类是 Java 中用于处理日期时间的一个基础类，但由于其复杂的操作和不够直观的接口，已经被新的日期时间 API 所取代。因此，在新的开发中，推荐使用新的日期时间 API 来代替 Calendar 类。
java.util.Calendar使用
java.util.Calendar 是 Java 中用于操作日期和时间的一个类，它提供了丰富的方法来处理日期时间字段，并支持国际化和时区。以下是关于 java.util.Calendar 的详细介绍和使用方法：
1. 获取 Calendar 实例
要获取 Calendar 实例，可以使用 getInstance() 方法：
Calendar calendar = Calendar.getInstance();
2. 设置日期时间字段值
可以使用 set() 方法来设置日期时间字段的值，例如设置年份：
calendar.set(Calendar.YEAR, 2023);
3. 获取日期时间字段值
可以使用 get() 方法来获取日期时间字段的值，例如获取月份：
int month = calendar.get(Calendar.MONTH);
4. 日期时间加减
可以使用 add() 方法来对日期时间进行加减操作，例如加一天：
calendar.add(Calendar.DAY_OF_MONTH, 1);
5. 日期比较
可以使用 compareTo() 方法来比较两个日期的先后顺序：
Calendar anotherCalendar = Calendar.getInstance();
if (calendar.compareTo(anotherCalendar) > 0) {
// calendar 晚于 anotherCalendar
} else if (calendar.compareTo(anotherCalendar) < 0) {
// calendar 早于 anotherCalendar
} else {
// 两个日期相等
}
6. 格式化输出
Calendar 类本身不负责格式化日期时间，但可以通过 SimpleDateFormat 类来进行格式化输出：
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String formattedDate = sdf.format(calendar.getTime());
System.out.println("Formatted Date: " + formattedDate);
7. 其他常用操作
getActualMaximum()和getActualMinimum()方法用于获取指定字段的最大值和最小值。getTime()方法用于获取Date对象，从而方便与其他日期时间库进行交互。
需要注意的是，Calendar 类的月份从 0 开始，即 0 表示一月，1 表示二月，以此类推。此外，Calendar 类的月份、星期等字段都是基于 0 开始计数的。
综上所述，java.util.Calendar 是 Java 中用于操作日期和时间的一个类，它提供了丰富的方法来处理日期时间字段，但在使用时需要注意月份的计数方式以及与其他日期时间库的兼容性。随着 Java 8 引入了新的日期时间 API，推荐使用新的 API（java.time 包下的类）来替代 Calendar 类。
java.time
java.time 是 Java 8 引入的新的日期时间 API，用于处理日期、时间、时区等相关的操作。这个 API 提供了一系列类来代表日期、时间、时间间隔、时区等，并且设计上更加清晰、易用、线程安全。以下是关于 java.time 包的介绍：
1. 核心类
java.time 包中的核心类包括：
- LocalDate： 用于表示日期，例如 2024-02-10。
- LocalTime： 用于表示时间，例如 12:30:45。
- LocalDateTime： 用于表示日期时间，例如 2024-02-10T12:30:45。
- Instant： 用于表示时间戳，从 1970-01-01T00:00:00Z 开始的秒数。
- ZonedDateTime： 用于表示带时区的日期时间。
2. 时区支持
java.time API 提供了对时区的良好支持，包括：
- ZoneId： 用于表示时区。
- ZoneOffset： 用于表示时区偏移量。
- OffsetDateTime： 用于表示带偏移量的日期时间。
3. 时间间隔
java.time API 还提供了处理时间间隔的类，包括：
- Duration： 用于表示持续时间，例如 2 小时 30 分钟。
- Period： 用于表示日期间隔，例如 3 天。
4. 格式化和解析
java.time.format.DateTimeFormatter 类用于格式化和解析日期时间字符串，提供了丰富的日期时间格式化选项，使得格式化和解析操作更加灵活。
5. 不可变性和线程安全性
java.time 中的类都是不可变的（immutable），这意味着一旦创建了对象，其值就不能被修改，保证了线程安全性。
java.time常用类使用
下面是 java.time 包下一些常用类的使用方法：
1. LocalDate
import java.time.LocalDate;
// 获取当前日期
LocalDate currentDate = LocalDate.now();
System.out.println("Current Date: " + currentDate);
// 创建指定日期
LocalDate customDate = LocalDate.of(2024, 2, 10);
System.out.println("Custom Date: " + customDate);
// 获取年、月、日
int year = currentDate.getYear();
int month = currentDate.getMonthValue();
int day = currentDate.getDayOfMonth();
System.out.println("Year: " + year + ", Month: " + month + ", Day: " + day);
2. LocalTime
import java.time.LocalTime;
// 获取当前时间
LocalTime currentTime = LocalTime.now();
System.out.println("Current Time: " + currentTime);
// 创建指定时间
LocalTime customTime = LocalTime.of(12, 30, 45);
System.out.println("Custom Time: " + customTime);
// 获取时、分、秒
int hour = currentTime.getHour();
int minute = currentTime.getMinute();
int second = currentTime.getSecond();
System.out.println("Hour: " + hour + ", Minute: " + minute + ", Second: " + second);
3. LocalDateTime
import java.time.LocalDateTime;
// 获取当前日期时间
LocalDateTime currentDateTime = LocalDateTime.now();
System.out.println("Current DateTime: " + currentDateTime);
// 创建指定日期时间
LocalDateTime customDateTime = LocalDateTime.of(2024, 2, 10, 12, 30, 45);
System.out.println("Custom DateTime: " + customDateTime);
// 获取年、月、日、时、分、秒
int year = currentDateTime.getYear();
int month = currentDateTime.getMonthValue();
int day = currentDateTime.getDayOfMonth();
int hour = currentDateTime.getHour();
int minute = currentDateTime.getMinute();
int second = currentDateTime.getSecond();
System.out.println("Year: " + year + ", Month: " + month + ", Day: " + day);
System.out.println("Hour: " + hour + ", Minute: " + minute + ", Second: " + second);
4. DateTimeFormatter（日期时间格式化）
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
// 创建 DateTimeFormatter
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
// 格式化日期时间
LocalDateTime dateTime = LocalDateTime.now();
String formattedDateTime = dateTime.format(formatter);
System.out.println("Formatted DateTime: " + formattedDateTime);
// 解析日期时间字符串
String dateString = "2024-02-10 12:30:45";
LocalDateTime parsedDateTime = LocalDateTime.parse(dateString, formatter);
System.out.println("Parsed DateTime: " + parsedDateTime);
java.sql时间类介绍
在 java.sql 包中，主要有三个与时间相关的类：java.sql.Date、java.sql.Time 和 java.sql.Timestamp。以下是对这些类的详细介绍：
1. java.sql.Date
java.sql.Date类用于表示 SQL DATE 类型的日期值。- 与
java.util.Date不同，java.sql.Date中只包含年、月、日，没有时、分、秒，精确到日期。 - 内部实际上是一个包装了一个长整型值的对象，表示自纪元（1970 年 1 月 1 日）以来的毫秒数，但仅包含日期部分。
- 可以通过
getTime()方法获取毫秒数，也可以通过toString()方法以默认格式（“yyyy-MM-dd”）将日期转换为字符串。
2. java.sql.Time
java.sql.Time类用于表示 SQL TIME 类型的时间值。- 与
java.util.Date不同，java.sql.Time中只包含时、分、秒，没有年、月、日，精确到时间。 - 内部实际上也是一个包装了一个长整型值的对象，表示自纪元（1970 年 1 月 1 日）以来的毫秒数，但仅包含时间部分。
- 可以通过
getTime()方法获取毫秒数，也可以通过toString()方法以默认格式（“HH:mm:ss”）将时间转换为字符串。
3. java.sql.Timestamp
java.sql.Timestamp类用于表示 SQL TIMESTAMP 类型的日期时间值。- 包含年、月、日、时、分、秒，精确到毫秒。
- 内部实际上也是一个包装了一个长整型值的对象，表示自纪元（1970 年 1 月 1 日）以来的毫秒数，包含日期和时间部分。
- 可以通过
getTime()方法获取毫秒数，也可以通过toString()方法以默认格式（“yyyy-MM-dd HH:mm:ss.SSS”）将日期时间转换为字符串。
这些类通常用于与数据库交互时处理日期和时间类型的值。在使用时需要注意它们的精度和区别，以及与 java.util.Date 的差异。
java.sql时间类使用
java.sql 包中的时间相关类主要用于在 Java 代码中与数据库中的日期和时间类型进行交互，包括 java.sql.Date、java.sql.Time 和 java.sql.Timestamp。以下是这些类的基本使用方法：
1. java.sql.Date
import java.sql.Date;
// 创建 java.sql.Date 对象
Date currentDate = new Date(System.currentTimeMillis());
// 使用 PreparedStatement 设置日期参数
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO my_table (date_column) VALUES (?)");
preparedStatement.setDate(1, currentDate);
preparedStatement.executeUpdate();
// 从 ResultSet 中获取日期值
ResultSet resultSet = statement.executeQuery("SELECT date_column FROM my_table");
if (resultSet.next()) {
Date dateFromResultSet = resultSet.getDate("date_column");
System.out.println("Date from ResultSet: " + dateFromResultSet);
}
2. java.sql.Time
import java.sql.Time;
// 创建 java.sql.Time 对象
Time currentTime = new Time(System.currentTimeMillis());
// 使用 PreparedStatement 设置时间参数
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO my_table (time_column) VALUES (?)");
preparedStatement.setTime(1, currentTime);
preparedStatement.executeUpdate();
// 从 ResultSet 中获取时间值
ResultSet resultSet = statement.executeQuery("SELECT time_column FROM my_table");
if (resultSet.next()) {
Time timeFromResultSet = resultSet.getTime("time_column");
System.out.println("Time from ResultSet: " + timeFromResultSet);
}
3. java.sql.Timestamp
import java.sql.Timestamp;
// 创建 java.sql.Timestamp 对象
Timestamp currentTimestamp = new Timestamp(System.currentTimeMillis());
// 使用 PreparedStatement 设置时间戳参数
PreparedStatement preparedStatement = connection.prepareStatement("INSERT INTO my_table (timestamp_column) VALUES (?)");
preparedStatement.setTimestamp(1, currentTimestamp);
preparedStatement.executeUpdate();
// 从 ResultSet 中获取时间戳值
ResultSet resultSet = statement.executeQuery("SELECT timestamp_column FROM my_table");
if (resultSet.next()) {
Timestamp timestampFromResultSet = resultSet.getTimestamp("timestamp_column");
System.out.println("Timestamp from ResultSet: " + timestampFromResultSet);
}
这些示例展示了如何在 Java 代码中使用 java.sql.Date、java.sql.Time 和 java.sql.Timestamp 类来处理数据库中的日期和时间类型。
3.JAVA时间类相互转化
在 Java 中，常用的时间类包括 java.util.Date、java.sql.Date、java.sql.Time、java.sql.Timestamp、java.time.LocalDate、java.time.LocalTime 和 java.time.LocalDateTime 等。下面是它们之间相互转化的方法：
1. java.util.Date 转 java.sql.Date、java.sql.Time、java.sql.Timestamp
import java.util.Date;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
// 创建 java.util.Date 对象
Date utilDate = new Date();
// 转换为 java.sql.Date
java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
// 转换为 java.sql.Time
java.sql.Time sqlTime = new java.sql.Time(utilDate.getTime());
// 转换为 java.sql.Timestamp
java.sql.Timestamp timestamp = new java.sql.Timestamp(utilDate.getTime());
2. java.sql.Date、java.sql.Time、java.sql.Timestamp 转 java.util.Date
import java.util.Date;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
// 创建 java.sql.Date、java.sql.Time、java.sql.Timestamp 对象
Date sqlDate = new Date(System.currentTimeMillis());
Time sqlTime = new Time(System.currentTimeMillis());
Timestamp timestamp = new Timestamp(System.currentTimeMillis());
// 转换为 java.util.Date
Date utilDateFromDate = new Date(sqlDate.getTime());
Date utilDateFromTime = new Date(sqlTime.getTime());
Date utilDateFromTimestamp = new Date(timestamp.getTime());
3. java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime 转 java.sql.Date、java.sql.Time、java.sql.Timestamp
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
// 创建 java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime 对象
LocalDate localDate = LocalDate.now();
LocalTime localTime = LocalTime.now();
LocalDateTime localDateTime = LocalDateTime.now();
// 转换为 java.sql.Date、java.sql.Time、java.sql.Timestamp
java.sql.Date sqlDate = java.sql.Date.valueOf(localDate);
java.sql.Time sqlTime = java.sql.Time.valueOf(localTime);
java.sql.Timestamp timestamp = java.sql.Timestamp.valueOf(localDateTime);
4. java.sql.Date、java.sql.Time、java.sql.Timestamp 转 java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.LocalDateTime;
// 创建 java.sql.Date、java.sql.Time、java.sql.Timestamp 对象
Date sqlDate = Date.valueOf("2024-02-10");
Time sqlTime = Time.valueOf("12:30:45");
Timestamp timestamp = Timestamp.valueOf("2024-02-10 12:30:45");
// 转换为 java.time.LocalDate、java.time.LocalTime、java.time.LocalDateTime
LocalDate localDate = sqlDate.toLocalDate();
LocalTime localTime = sqlTime.toLocalTime();
LocalDateTime localDateTime = timestamp.toLocalDateTime();
这些示例演示了各种常用的时间类之间相互转换的方法。在实际使用中，根据需要选择合适的转换方法。
扫一扫
15万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
