首页 文章

如何在Java中获取当前日期/时间

提问于
浏览 次
570

获取Java当前日期/时间的最佳方法是什么？

java datetime

24 回答

  • 41

    如果您希望当前日期为String，请尝试以下操作：

    DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date date = new Date();
System.out.println(dateFormat.format(date));

    要么

    DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Calendar cal = Calendar.getInstance();
System.out.println(dateFormat.format(cal.getTime()));

    http://www.mkyong.com/java/java-how-to-get-current-date-time-date-and-calender/

    回复于
  • 561

    你看过java.util.Date了吗？这正是你想要的 .

    回复于
  • 9
    import java.util.*;
import java.text.*;

public class DateDemo {
   public static void main(String args[]) {
      Date dNow = new Date( );
      SimpleDateFormat ft = 
      new SimpleDateFormat ("E yyyy.MM.dd 'at' hh:mm:ss a zzz");
      System.out.println("Current Date: " + ft.format(dNow));
   }
}

    您可以将日期用于胎儿当前数据 . 所以使用SimpleDateFormat获取格式

    回复于
  • 10

    有许多不同的方法：

    回复于
  • 38

    如果你只需要输出YYYY.MM.DD-HH.MM.SS格式的时间戳（非常频繁的情况），那么这就是这样做的方法：

    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime());
    回复于
  • 9

    1st 了解java.util.Date类

    1.1如何获取当前日期

    import java.util.Date;

class Demostration{
    public static void main(String[]args){
        Date date = new Date(); // date object
        System.out.println(date); // Try to print the date object
    }
}

    1.2如何使用getTime（）方法

    import java.util.Date;
public class Main {
    public static void main(String[]args){
        Date date = new Date();
        long timeInMilliSeconds = date.getTime();
        System.out.println(timeInMilliSeconds);
    }
}

    这将返回自1970年1月1日00:00:00 GMT以来的毫秒数，以进行时间比较 .

    1.3如何使用SimpleDateFormat类格式化时间

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

class Demostration{
    public static void main(String[]args){
        Date date=new Date();
        DateFormat dateFormat=new SimpleDateFormat("yyyy-MM-dd");
        String formattedDate=dateFormat.format(date);
        System.out.println(formattedDate);
    }
}

    还可以尝试使用不同的格式模式，如"yyyy-MM-dd hh:mm:ss"，然后选择所需的模式 . http://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html

    2nd 了解java.util.Calendar类

    2.1使用Calendar Class获取当前时间戳

    import java.util.Calendar;

class Demostration{
    public static void main(String[]args){
        Calendar calendar=Calendar.getInstance();
        System.out.println(calendar.getTime());
    }
}

    2.2尝试使用setTime和其他设置方法将日历设置为不同的日期 .

    资料来源：http://javau91.blogspot.com/

    回复于
  • 95

    对于java.util.Date，只需创建一个新的Date（）

    DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date date = new Date();
System.out.println(dateFormat.format(date)); //2016/11/16 12:08:43

    对于java.util.Calendar，使用Calendar.getInstance（）

    DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Calendar cal = Calendar.getInstance();
System.out.println(dateFormat.format(cal)); //2016/11/16 12:08:43

    对于java.time.LocalDateTime，使用LocalDateTime.now（）

    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");
LocalDateTime now = LocalDateTime.now();
System.out.println(dtf.format(now)); //2016/11/16 12:08:43

    对于java.time.LocalDate，使用LocalDate.now（）

    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate localDate = LocalDate.now();
System.out.println(dtf.format(localDate)); //2016/11/16

    参考：https://www.mkyong.com/java/java-how-to-get-current-date-time-date-and-calender/

    回复于
  • 2

    创建日期对象，然后将其打印下来 .

    Date d = new Date(System.currentTimeMillis());
System.out.print(d);
    回复于
  • 1

    如上所述，基本的Date（）可以在获取当前时间方面做到所需 . 在我最近与Java日期密切合作的经历中，内置类有许多奇怪之处（以及许多Date类方法的弃用） . 对我而言，一个奇怪的是，从技术角度来看，几个月是0指数，但实际上可能非常令人困惑 .

    如果你只关心应该满足的当前日期 - 但是如果你打算用日期进行大量的操作/计算，那么使用第三方库可能是非常有益的（因为许多Java开发人员对它们不满意所以存在很多内置功能） .

    我是Stephen C的推荐，因为我发现Joda-time在简化日期工作方面非常有用，它也有很好的文档记录，你可以在整个网络中找到许多有用的例子 . 我甚至最终编写了一个静态包装类（作为DateUtils），我用它来巩固和简化所有常见的日期操作 .

    回复于
  • 0

    使用：

    SimpleDateFormat sdf = new SimpleDateFormat("yyyy:MM:dd::HH:mm:ss");
System.out.println(sdf.format(System.currentTimeMillis()));

    print语句将打印调用它的时间，而不是在创建 SimpleDateFormat 时 . 因此可以在不创建任何新对象的情况下重复调用它 .

    回复于
  • 7

    我会继续把这个答案放进去，因为当我遇到同样的问题时，我只需要它：

    Date currentDate = new Date(System.currentTimeMillis());

    currentDate 现在是Java Date 对象中的当前日期 .

    回复于
  • -1

    与上述解决方案类似 . 但我总是发现自己正在寻找这段代码：

    Date date=Calendar.getInstance().getTime();
System.out.println(date);
    回复于
  • 3

    随着Java 8的出现，引入了新的Data-Time API . 这是由于旧的数据时间API引起的以下问题 . 难以处理时区：需要编写大量代码来处理时区 . 不是线程安全：java.util.Date不是线程安全的 .

    所以看看Java 8

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


public class DataTimeChecker {

    public static void main(String args[]) {
        DataTimeChecker dateTimeChecker = new DataTimeChecker();
        dateTimeChecker.DateTime();
    }

    public void DateTime() {
        // Get the current date and time
        LocalDateTime currentTime = LocalDateTime.now();
        System.out.println("Current DateTime: " + currentTime);

        LocalDate date1 = currentTime.toLocalDate();
        System.out.println("Date : " + date1);

        Month month = currentTime.getMonth();
        int day = currentTime.getDayOfMonth();
        int seconds = currentTime.getSecond();

        System.out.println("Month : " + month);
        System.out.println("Day : " + day);
        System.out.println("Seconds : " + seconds);

        LocalDateTime date2 = currentTime.withDayOfMonth(17).withYear(2018);
        System.out.println("Date : " + date2);

        //Prints 17 May 2018
        LocalDate date3 = LocalDate.of(2018, Month.MAY, 17);
        System.out.println("Date : " + date3);

        //Prints 04 hour 45 minutes
        LocalTime date4 = LocalTime.of(4, 45);
        System.out.println("Date : " + date4);

        // Convert to a String 
        LocalTime date5 = LocalTime.parse("20:15:30");
        System.out.println("Date : " + date5);
    }
}

    以上编码的输出：

    Current DateTime: 2018-05-17T04:40:34.603
Date : 2018-05-17
Month : MAY
Day : 17
Seconds : 34
Date : 2018-05-17T04:40:34.603
Date : 2018-05-17
Date : 04:45
Date : 20:15:30
    回复于
  • 58

    使用：

    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime());
System.out.println(timeStamp );

    （它正在工作 . ）

    回复于
  • 4
    System.out.println( new SimpleDateFormat("yyyy:MM:dd - hh:mm:ss a").format(Calendar.getInstance().getTime()) );
    //2018:02:10 - 05:04:20 PM

    上午/下午的日期/时间

    回复于
  • 3

    只需创建一个Date对象......

    Date date = new Date();
    回复于
  • 352

    我觉得这是最好的方法：

    DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Calendar cal = Calendar.getInstance();
System.out.println(dateFormat.format(cal.getTime())); // 2014/08/06 16:00:22
    回复于
  • 18

    在Java 8中它是：

    LocalDateTime.now()

    如果您需要时区信息：

    ZonedDateTime.now()

    如果你想打印花哨的格式化字符串：

    System.out.println(ZonedDateTime.now().format(DateTimeFormatter.RFC_1123_DATE_TIME))
    回复于
  • 6
    // 2015/09/27 15:07:53
    System.out.println( new SimpleDateFormat("yyyy/MM/dd HH:mm:ss").format(Calendar.getInstance().getTime()) );

    // 15:07:53
    System.out.println( new SimpleDateFormat("HH:mm:ss").format(Calendar.getInstance().getTime()) );

    // 09/28/2015
    System.out.println(new SimpleDateFormat("MM/dd/yyyy").format(Calendar.getInstance().getTime()));

    // 20150928_161823
    System.out.println( new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime()) );

    // Mon Sep 28 16:24:28 CEST 2015
    System.out.println( Calendar.getInstance().getTime() );

    // Mon Sep 28 16:24:51 CEST 2015
    System.out.println( new Date(System.currentTimeMillis()) );

    // Mon Sep 28
    System.out.println( new Date().toString().substring(0, 10) );

    // 2015-09-28
    System.out.println( new java.sql.Date(System.currentTimeMillis()) );

    // 14:32:26
    Date d = new Date();
    System.out.println( (d.getTime() / 1000 / 60 / 60) % 24 + ":" + (d.getTime() / 1000 / 60) % 60 + ":" + (d.getTime() / 1000) % 60 );

    // 2015-09-28 17:12:35.584
    System.out.println( new Timestamp(System.currentTimeMillis()) );

    // Java 8

    // 2015-09-28T16:16:23.308+02:00[Europe/Belgrade]
    System.out.println( ZonedDateTime.now() );

    // Mon, 28 Sep 2015 16:16:23 +0200
    System.out.println( ZonedDateTime.now().format(DateTimeFormatter.RFC_1123_DATE_TIME) );

    // 2015-09-28
    System.out.println( LocalDate.now(ZoneId.of("Europe/Paris")) ); // rest zones id in ZoneId class

    // 16
    System.out.println( LocalTime.now().getHour() );

    // 2015-09-28T16:16:23.315
    System.out.println( LocalDateTime.now() );
    回复于
  • 6

    tl;博士

    Instant.now()                                         // Capture the current moment in UTC, with a resolution of nanoseconds.

    … 要么 …

    ZonedDateTime.now( ZoneId.of( "America/Montreal" ) )  // Capture the current moment as seen in the wall-clock time used by the people of a particular region (a time zone).

    java.time

    一些答案提到java.time类是与最早版本的Java捆绑在一起的麻烦的旧遗留日期时间类的现代替代品 . 以下是更多信息 .

    时区

    其他答案无法解释时区在确定当前日期和时间方面的重要性 . 对于任何给定的时刻，日期和时间在全球范围内因地区而异 . 例如，午夜后几分钟是Paris France中的新一天，而在Montréal Québec中仍然是“昨天” .

    瞬发

    作为最佳实践，您的大部分业务逻辑和数据存储/交换应该在UTC中完成 . 要使用nanoseconds中的分辨率获取UTC中的当前时刻，请使用Instant class .

    Instant instant = Instant.now();

    ZonedDateTime

    您可以将 Instant 调整为其他时区 . 应用ZoneId对象获取ZonedDateTime .

    ZoneId z = ZoneId.of( "America/Montreal" );
ZonedDateTime zdt = instant.atZone( z );

    我们可以跳过 Instant 并直接获取当前的 ZonedDateTime .

    ZonedDateTime zdt = ZonedDateTime.now( z );

    始终传递可选的时区参数 . 如果省略，则表示您的JVM当前应用默认时区 . 默认情况下可以随时更改，即使在运行时也是如此 . 不要让您的应用受到外部因素的影响 . 始终指定所需/预期的时区 .

    ZonedDateTime do_Not_Do_This = ZonedDateTime.now(); // BAD - Never rely implicitly on the current default time zone.

    您可以稍后从 ZonedDateTime 中提取 Instant .

    Instant instant = zdt.toInstant();

    当您想要时间轴上的实际时刻时，请始终使用 Instant 或 ZonedDateTime 而不是LocalDateTime . Local… 类型故意不具有时区概念，因此它们仅代表对可能时刻的粗略概念 . 要获得实际时刻，您必须指定一个时区来将 Local… 类型转换为 ZonedDateTime ，从而使其有意义 .

    LocalDate

    LocalDate类表示没有时间且没有时区的仅日期值 .

    ZoneId z = ZoneId.of( "America/Montreal" );
LocalDate today = LocalDate.now( z );  // Always pass a time zone.

    字符串

    要生成表示日期时间值的String，只需在标准ISO 8601格式的java.time类上调用 toString .

    String output = myLocalDate.toString();  // 2016-09-23

    … 要么 …

    String output = zdt.toString();  // 2016-09-23T12:34:56.789+03:00[America/Montreal]

    ZonedDateTime 类通过在方括号中明智地附加时区名称来扩展标准格式 .

    对于其他格式，请在DateTimeFormatter类上搜索许多问题和答案的Stack Overflow .

    避免使用LocalDateTime

    与RamanSB对问题的评论相反，您不应将LocalDateTime类用于当前日期时间 .

    LocalDateTime 故意缺少任何时区或从UTC信息偏移 . 因此，当您跟踪时间线上的特定时刻时，这是不合适的 . 当然不适合捕捉当前时刻 .

    “本地”措辞是违反直觉的 . 它意味着任何地方而不是任何一个特定的地方 . 例如，圣诞节今年12月25日午夜开始： 2017-12-25T00:00:00 ，表示为 LocalDateTime . 但这意味着在不同时间在全球不同地点的午夜 . 午夜发生在Kiribati，后来在新西兰，几个小时后在印度发生，依此类推，在法国圣诞节开始之前还有几个小时过去，当时加拿大的孩子们还在等待那一天 . 这些圣诞节起点中的每一个都将被表示为单独的 ZonedDateTime .

    来自系统外部

    如果您不能信任您的系统时钟，请参阅Java: Get current Date and Time from Server not System clock和my Answer .

    photo of a couple of external radio clock devices

    java.time.Clock

    要利用当前时刻的备用供应商，请编写abstract java.time.Clock类的子类 .

    您可以将 Clock 实现作为参数传递给各种java.time方法 . 例如，Instant.now( clock ) .

    Instant instant = Instant.now( yourClockGoesHere ) ;

    出于测试目的，请注意从 Clock 本身静态可用的 Clock 的备用实现：fixed， offset ， tick 等 .

    关于java.time

    java.time框架内置于Java 8及更高版本中 . 这些类取代了麻烦的旧legacy日期时间类，例如java.util.Date，Calendar和SimpleDateFormat .

    现在位于maintenance mode的Joda-Time项目建议迁移到java.time类 .

    要了解更多信息，请参阅Oracle Tutorial . 并搜索Stack Overflow以获取许多示例和解释 . 规格是JSR 310 .

    您可以直接与数据库交换java.time对象 . 使用JDBC driver与JDBC 4.2或更高版本兼容 . 不需要字符串，不需要 java.sql.* 类 .

    从哪里获取java.time类？

    ThreeTen-Extra项目使用其他类扩展java.time . 该项目是未来可能添加到java.time的试验场 . 您可以在这里找到一些有用的类，例如Interval，YearWeek，_ YearQuarter和more .

    回复于
  • 4

    看看Date课程 . 还有更新的Calendar类，它是执行许多日期/时间操作的首选方法（许多日期方法已被弃用 . ）

    如果您只想要当前日期，则可以创建新的Date对象或调用 Calendar.getInstance(); .

    回复于
  • 25

    您可以自己使用 Date 对象和格式 . 作为一个例子，很难格式化并需要更多代码

    Date dateInstance = new Date();
int year = dateInstance.getYear()+1900;//Returns:the year represented by this date, minus 1900.
int date = dateInstance.getDate();
int month = dateInstance.getMonth();
int day = dateInstance.getDay();
int hours = dateInstance.getHours();
int min = dateInstance.getMinutes();
int sec = dateInstance.getSeconds();

String dayOfWeek = "";
switch(day){
    case 0:
        dayOfWeek = "Sunday";
        break;
    case 1:
        dayOfWeek = "Monday";
        break;
    case 2:
        dayOfWeek = "Tuesday";
        break;
    case 3:
        dayOfWeek = "Wednesday";
        break;
    case 4:
        dayOfWeek = "Thursday";
        break;
    case 5:
        dayOfWeek = "Friday";
        break;
    case 6:
        dayOfWeek = "Saturday";
        break;
}
System.out.println("Date: " + year +"-"+ month + "-" + date + " "+ dayOfWeek);
System.out.println("Time: " + hours +":"+ min + ":" + sec);

    输出：

    Date: 2017-6-23 Sunday
Time: 14:6:20

    正如您所看到的，这是您可以做到的最糟糕的方式，根据oracle文档，它是deprecated .

    Oracle doc：

    类Date表示特定的时刻，精度为毫秒 . 在JDK 1.1之前，Date类有两个附加功能 . 它允许将日期解释为年，月，日，小时，分钟和秒值 . 它还允许格式化和解析日期字符串 . 不幸的是，这些功能的API不适应国际化 . 从JDK 1.1开始，Calendar类应该用于在日期和时间字段之间进行转换，而DateFormat类应该用于格式化和解析日期字符串 . 不推荐使用Date中的相应方法 .

    所以，你也可以使用Calendar类，

    Calendar.YEAR;
//and lot more

    要获得当前时间，您可以使用：

    Calendar rightNow = Calendar.getInstance();

    Doc：与其他区域设置敏感的类一样，Calendar提供了一个类方法getInstance，用于获取此类型的通用对象 . Calendar的getInstance方法返回一个Calendar对象，其日历字段已使用当前日期和时间进行初始化

    以下代码仅获取日期

    Date rightNow = Calendar.getInstance().getTime();
System.out.println(rightNow);

    此外， Calendar 类具有子类 . GregorianCalendar是 Calendar 中的一个和具体子类，并提供世界上大多数人使用的标准日历系统 .

    使用 GregorianCalendar 的示例：

    Calendar cal = new GregorianCalendar();
int hours = cal.get(Calendar.HOUR);
int minute = cal.get(Calendar.MINUTE);
int second = cal.get(Calendar.SECOND);
int ap = cal.get(Calendar.AM_PM);

String amVSpm;
if(ap == 0){
    amVSpm = "AM";
}else{
    amVSpm = "PM";
}

String timer = hours + "-" + minute + "-" + second + " " +amVSpm;
System.out.println(timer);

    您可以使用SimpleDateFormat，简单快捷的格式化日期：

    String pattern = "yyyy-MM-dd";
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);

String date = simpleDateFormat.format(new Date());
System.out.println(date);

    阅读本Jakob Jenkov tutorial: Java SimpleDateFormat .

    正如其他人所提到的，当我们需要从日期进行操作时，我们没有简单和最好的方法，或者我们不能满足内置的类API .

    作为一个例子，当我们需要get different between two dates时，我们需要compare two dates(there is in-built method also for this)等等 . 我们不得不使用第三方库 . 其中一个好的和受欢迎的是Joda Time.

    另请阅读：

    . 最幸福的事情是现在（在Java 8中），没有人因任何原因需要下载和使用库 . 在Java 8中获取当前日期和时间的简单示例，

    LocalTime localTime = LocalTime.now();
System.out.println(localTime);

//with time zone
LocalTime localTimeWtZone = LocalTime.now(ZoneId.of("GMT+02:30"));
System.out.println(localTimeWtZone);

    其中一个good blog post to read about Java 8 date .

    并记住要了解有关Java日期和时间的更多信息，因为您可以获得/使用更多方法和/或有用的方法 .

    EDIT:

    根据@BasilBourque评论，麻烦的旧日期时间类如 java.util.Date ， java.util.Calendar 和 java.text.SimpleTextFormat 现在是legacy，取而代之的是java.time classes .

    回复于
  • 1

    这取决于您想要的日期/时间形式：

    • 如果您希望将日期/时间作为单个数值，那么 System.currentTimeMillis() 将为您提供，表示为UNIX纪元后的毫秒数（作为Java long ） . 此值是UTC时间点的增量，并且与本地时区无关...假设系统时钟已正确设置 .

    • 如果您希望表单中的日期/时间允许您以数字方式访问组件（年，月等），则可以使用以下方法之一：

    • new Date() 为您提供了一个用当前日期/时间初始化的 Date 对象 . 问题是 Date API方法大多存在缺陷......并且已弃用 .

    • Calendar.getInstance() 使用默认的 Locale 和 TimeZone 为您提供使用当前日期/时间初始化的 Calendar 对象 . 其他重载允许您使用特定的 Locale 和/或 TimeZone . 日历工作......但API仍然很麻烦 .

    • new org.joda.time.DateTime() 使用默认时区和年表为您提供使用当前日期/时间初始化的Joda-time对象 . 还有很多其他的Joda替代品......这里描述的太多了 . （但请注意，有些人报告说Joda时间有性能问题 . 例如Jodatime's LocalDateTime is slow when used the first time . ）

    在Java 8中

    • ，调用 LocalDateTime.now() 和 ZonedDateTime.now() 将为您提供当前日期/时间的表示1 .

    在Java 8之前，大多数了解这些事情的人都建议Joda-time具有（迄今为止）用于执行涉及时间点和持续时间计算的最佳Java API . 使用Java 8，这已不再适用 . 但是，如果您已经在代码库中使用Joda时间，则没有强烈的迁移理由 .

    1 - 请注意，LocalDateTime不包含时区 . 正如javadoc所说：“如果没有附加信息，例如偏移或时区，它就不能代表时间线上的瞬间 . ”

    2 - 如果不这样做，您的代码将不会中断，并且您不会收到弃用警告 . 当然，Joda代码库可能会停止获取更新，但它不太可能需要它们 . 没有更新意味着稳定，这是一件好事 . 另请注意，如果有人能够修复Java平台中的回归导致的问题，那很有可能 .

    回复于
  • 14
    java.util.Date date = new java.util.Date();

    它会自动填充实例化的时间 .

    回复于

相关问题