Java获取当前时间的多种方式

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《Java获取当前时间的几种方法》，以下内容主要包含等知识点，如果你正在学习或准备学习文章，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

Java中获取当前时间最直接且常用的方式是System.currentTimeMillis()，但更推荐使用Java 8引入的java.time包中的API。2. 获取时间戳的最佳实践是根据需求选择：若追求极致性能，使用System.currentTimeMillis()；若需与现代API保持一致性和后续操作便利，使用Instant.now().toEpochMilli()。3. 格式化时间应使用线程安全的DateTimeFormatter，避免使用SimpleDateFormat。4. Java 8日期时间API相较于旧API的优势包括不变性、清晰的语义、强大的计算能力和优秀的时区处理。

Java中获取当前时间，最直接且常用的方式是利用System.currentTimeMillis()获取毫秒时间戳，或者更推荐使用Java 8引入的日期时间API，如Instant.now()、LocalDateTime.now()等，它们提供了更清晰、更强大的时间处理能力。

解决方案

要在Java里抓取当前时间，其实选择不少，关键看你想要一个什么样的“时间”。是纯粹的数字时间戳，还是一个能直接看懂的日期时间字符串，亦或是需要进行复杂时区计算的完整时间对象？

最基础的，莫过于System.currentTimeMillis()。这玩意儿直接返回一个long类型的值，代表自1970年1月1日00:00:00 GMT（格林威治标准时间）以来经过的毫秒数。它非常快，如果你只是想记录一个操作的开始和结束时间，或者生成一个简单的唯一ID，这个就够用了。

long currentTimeMillis = System.currentTimeMillis();
System.out.println("当前毫秒时间戳: " + currentTimeMillis);

然后是老牌的java.util.Date类。虽然现在不怎么推荐直接用它进行时间操作了，但获取当前时间还是很直接的：

import java.util.Date;

Date now = new Date();
System.out.println("使用Date获取当前时间: " + now);

如果你需要更精细的控制，比如获取日历字段（年、月、日、时、分、秒），java.util.Calendar也是一个选择，不过它也属于旧API了，用起来相对繁琐：

import java.util.Calendar;

Calendar calendar = Calendar.getInstance();
System.out.println("使用Calendar获取当前时间: " + calendar.getTime());
// 还可以获取特定字段
System.out.println("当前年份: " + calendar.get(Calendar.YEAR));

重头戏来了，Java 8引入的全新日期时间API（java.time包）。这套API彻底解决了旧API的许多痛点，在我看来，这是目前最优雅、最强大的时间处理方式。

• Instant: 代表时间线上的一个瞬时点，通常是UTC时间，没有时区信息。它就像一个机器可读的时间戳，精度可以到纳秒。

  import java.time.Instant;
  
  Instant instant = Instant.now();
  System.out.println("使用Instant获取当前瞬时时间 (UTC): " + instant);
  // 转换为毫秒时间戳
  System.out.println("Instant转换为毫秒时间戳: " + instant.toEpochMilli());

• LocalDateTime: 代表日期和时间，但没有时区信息。它适合表示“2023年10月27日晚上8点”，不管你在哪个时区，它都表示这个字面意义上的时间。

  import java.time.LocalDateTime;
  
  LocalDateTime localDateTime = LocalDateTime.now();
  System.out.println("使用LocalDateTime获取当前本地日期时间: " + localDateTime);

• ZonedDateTime: 包含了日期、时间以及时区信息。当你需要在全球不同时区之间转换时间，或者明确指定某个特定时区的时间时，它就派上用场了。

  import java.time.ZonedDateTime;
  import java.time.ZoneId;
  
  ZonedDateTime zonedDateTime = ZonedDateTime.now(); // 默认当前系统时区
  System.out.println("使用ZonedDateTime获取当前带时区日期时间: " + zonedDateTime);
  
  // 获取特定时区的时间
  ZonedDateTime newYorkTime = ZonedDateTime.now(ZoneId.of("America/New_York"));
  System.out.println("纽约当前时间: " + newYorkTime);

• LocalDate: 只有日期部分，没有时间。

  import java.time.LocalDate;
  
  LocalDate localDate = LocalDate.now();
  System.out.println("使用LocalDate获取当前日期: " + localDate);

• LocalTime: 只有时间部分，没有日期。

  import java.time.LocalTime;
  
  LocalTime localTime = LocalTime.now();
  System.out.println("使用LocalTime获取当前时间: " + localTime);

选择哪种方法，很大程度上取决于你的具体需求。如果是为了兼容老代码或者追求极致的原始性能，System.currentTimeMillis()也许还有一席之地。但对于任何现代Java应用开发，我强烈建议拥抱java.time包。它提供了更清晰的语义，更强大的功能，而且是线程安全的，这在多线程环境下尤其重要。

Java中获取当前时间戳的最佳实践是什么？

谈到获取时间戳，我们通常指的是一个从某个固定点（比如Unix纪元）开始计算的数字，它不带任何格式，纯粹就是个数值。在Java里，这事儿有两种主流做法：System.currentTimeMillis() 和 Instant.now().toEpochMilli()。

System.currentTimeMillis() 就像前面提到的，直接返回一个 long 类型的毫秒数。它非常直接，底层就是调用操作系统的API，效率极高。在很多需要快速获取一个时间点，比如计算一段代码的执行耗时，或者生成一个基于时间的简单ID时，它依然是首选。它简单粗暴，但却异常有效。

long timestampFromSystem = System.currentTimeMillis();
System.out.println("通过System.currentTimeMillis()获取的时间戳: " + timestampFromSystem);

而 Instant.now().toEpochMilli() 则是Java 8日期时间API提供的现代方式。Instant 代表的是时间线上的一个精确点，它内部可以精确到纳秒。当你调用 toEpochMilli() 时，它会将其转换为自Unix纪元以来的毫秒数。虽然多了一个对象创建和方法调用的开销，但这个开销微乎其微，在绝大多数应用场景下可以忽略不计。

import java.time.Instant;

long timestampFromInstant = Instant.now().toEpochMilli();
System.out.println("通过Instant.now().toEpochMilli()获取的时间戳: " + timestampFromInstant);

那么，最佳实践是什么呢？在我看来，如果你仅仅需要一个原始的毫秒时间戳，并且对性能有极致要求（比如高频循环内部的性能测量），那么 System.currentTimeMillis() 依然是你的朋友。它没有额外的对象开销，直接就是个原始值。

但如果你的应用中已经广泛使用了Java 8的日期时间API，或者你需要将这个时间戳与Instant、LocalDateTime等对象进行后续的转换、计算或持久化，那么使用 Instant.now().toEpochMilli() 会是更一致、更易于维护的选择。它将时间戳的概念融入到更现代、更强大的时间体系中，避免了混用不同API可能带来的理解和转换成本。毕竟，未来你可能需要从这个时间戳再构建一个Instant对象来做更多操作，那么直接从Instant开始就更顺理成章了。

简单来说，对于纯粹的、无格式的数字时间戳，两者都行。但从API设计的一致性和未来扩展性考虑，Instant家族无疑更具优势。

如何将Java获取到的时间格式化为特定字符串？

拿到一个时间对象后，我们往往需要把它变成人类可读的字符串，比如“2023年10月27日 14:30:05”。这里，Java也提供了新旧两套方案。

老一套是 java.text.SimpleDateFormat。它确实能完成任务，但有个非常大的坑：它不是线程安全的！在多线程环境下，如果你共享一个 SimpleDateFormat 实例，它会引发各种奇怪的并发问题，导致格式化结果出错。这在生产环境里是个非常隐蔽且难以调试的bug。

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

// 这是一个反面教材，展示SimpleDateFormat的用法，但请注意其线程不安全性
// SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// String formattedDate = sdf.format(new Date());
// System.out.println("使用SimpleDateFormat格式化 (不推荐多线程共享): " + formattedDate);

所以，现在我们强烈推荐使用Java 8日期时间API中的 java.time.format.DateTimeFormatter。它不仅功能强大，而且是线程安全的，这才是现代应用开发的正确姿势。

DateTimeFormatter 可以通过预定义的常量来获取，也可以通过模式字符串自定义。

• 使用预定义格式：

  import java.time.LocalDateTime;
  import java.time.format.DateTimeFormatter;
  
  LocalDateTime now = LocalDateTime.now();
  String formattedIsoDateTime = now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
  System.out.println("ISO_LOCAL_DATE_TIME格式: " + formattedIsoDateTime); // 2023-10-27T14:30:05.123

• 使用自定义模式： 这是最常用的方式，你可以根据自己的需求来定义日期时间的显示格式。

  import java.time.LocalDateTime;
  import java.time.format.DateTimeFormatter;
  
  LocalDateTime now = LocalDateTime.now();
  // 定义一个常见的日期时间格式
  DateTimeFormatter customFormatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
  String formattedCustom = now.format(customFormatter);
  System.out.println("自定义格式化: " + formattedCustom); // 2023年10月27日 14:30:05
  
  // 还可以只格式化日期或时间
  DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
  String formattedDateOnly = now.format(dateFormatter);
  System.out.println("只格式化日期: " + formattedDateOnly); // 2023/10/27

DateTimeFormatter 的模式字母和 SimpleDateFormat 类似，但它提供了更多细粒度的控制，而且最重要的是，它天生就是为线程安全设计的。每次调用 ofPattern 或者获取预定义实例，它都是一个不可变的对象，可以放心地在多线程间共享。这才是我们应该追求的“香饽饽”。

Java 8日期时间API相较于旧API有哪些显著优势？

Java 8引入的java.time包，通常被称为JSR 310日期时间API，它对旧有的java.util.Date和java.util.Calendar体系进行了彻底的革新。这不仅仅是换了个名字那么简单，它解决了一大堆旧API固有的、让人头疼的问题，带来了诸多显著优势，让时间处理变得前所未有的清晰和强大。

首先，也是最核心的一点：不变性（Immutability）。旧的Date和Calendar对象都是可变的。这意味着一旦你创建了一个Date或Calendar实例，它的内部状态是可以被修改的。这在多线程环境下是个巨大的隐患，一个线程可能不经意间修改了另一个线程正在使用的日期对象，导致难以追踪的并发问题。而java.time包中的所有核心类，如Instant、LocalDateTime、ZonedDateTime、Duration、Period等，都是不可变的。这意味着一旦创建，它们的值就不能再改变，每次“修改”操作（比如plusDays()）都会返回一个新的实例。这极大地简化了并发编程，提升了代码的健壮性。

其次，是清晰的语义和类型安全。旧API中，Date对象既可以表示日期也可以表示时间，甚至还包含了时区信息，这种“大杂烩”的设计导致语义模糊。Calendar更是把日期和时间分解成了各种字段，操作起来非常繁琐，而且月份是从0开始的，这常常是新手犯错的源头。Java 8 API则对时间概念进行了清晰的划分：

• LocalDate：只有日期，没有时间。
• LocalTime：只有时间，没有日期。
• LocalDateTime：日期和时间，但没有时区信息。
• Instant：时间线上的一个瞬时点，通常是UTC时间，没有时区概念。
• ZonedDateTime：带有时区信息的日期和时间。
• OffsetDateTime：带有时区偏移量的日期和时间。 这种分离使得代码意图更加明确，也减少了类型混用的可能性。

再者，强大的日期时间计算能力。旧API进行日期时间计算简直是噩梦，你需要不断地通过Calendar的add()方法来增减字段，而且还要小心溢出问题。新API则提供了直观且链式调用的方法，比如plusDays()、minusHours()、withYear()等等，以及Duration和Period类来表示时间量，让时间计算变得非常自然和优雅。

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

LocalDateTime now = LocalDateTime.now();
// 增加10天
LocalDateTime after10Days = now.plusDays(10);
System.out.println("10天后: " + after10Days);

// 计算两个日期之间的周期（年、月、日）
LocalDate startDate = LocalDate.of(2023, 1, 1);
LocalDate endDate = LocalDate.of(2024, 3, 15);
Period period = Period.between(startDate, endDate);
System.out.println("从" + startDate + "到" + endDate + "相差: " + period.getYears() + "年" + period.getMonths() + "月" + period.getDays() + "天");

// 计算两个时间点之间的持续时间（秒、纳秒）
Instant startInstant = Instant.now();
// 模拟一些操作
try { Thread.sleep(100); } catch (InterruptedException e) {}
Instant endInstant = Instant.now();
Duration duration = Duration.between(startInstant, endInstant);
System.out.println("操作耗时: " + duration.toMillis() + "毫秒");

最后，优秀的时区处理。旧API处理时区是个老大难问题，很容易出错。新API通过ZoneId和ZonedDateTime提供了完善且易于理解的时区转换和处理机制，大大降低了跨时区应用开发的复杂性。

总结来说，Java 8日期时间API的优势体现在：不变性带来的线程安全和易用性，清晰的类型语义减少了混淆和错误，直观强大的计算能力提升了开发效率，以及对时区处理的全面支持。在我看来，任何新的Java项目都应该毫不犹豫地采用这套API，它是Java在时间处理领域的一次里程碑式的进步。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。