java 获取当前日期时间
 

  

  

 
 
Java provides two classes to get current date and time – Date and Calendar.
 
 Java提供了两个类来获取当前日期和时间-Date和Calendar 。 
 
 
 用Java获取当前日期 (Get Current Date in Java)
 
 
Here is the simple program showing how we can use these classes to get the current date and time in Java.
 
 这是一个简单的程序，显示了我们如何使用这些类来获取Java中的当前日期和时间。 
 
 

 
 
 
package com.journaldev.util;

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

public class DateAndTimeUtil {

	public static void main(String[] args) {
		//Get current date using Date
		Date date = new Date();
		System.out.println("Current date using Date = "+date.toString());

		//Get current date using Calendar
		Calendar cal = Calendar.getInstance();
		System.out.println("Current date using Calendar = "+cal.getTime());

		//Get current time in milliseconds
		System.out.println("Current time in milliseconds using Date = "+date.getTime());
		System.out.println("Current time in milliseconds using Calendar = "+cal.getTimeInMillis());
	}

}
 
Output of the above program is:
 
 上面程序的输出是： 
 
 

  

  

 
 
Current date using Date = Thu Nov 15 13:51:03 PST 2012
Current date using Calendar = Thu Nov 15 13:51:03 PST 2012
Current time in milliseconds using Date = 1353016263692
Current time in milliseconds using Calendar = 1353016263711
 
Few points to note while getting the current date in java:
 
 在Java中获取当前日期时要注意的几点： 
 
 
Calendar.getInstance() is more expensive method, so use it only when you need Calendar object. Else use Date object.
 Calendar.getInstance（）是更昂贵的方法，因此仅在需要Calendar对象时才使用它。 否则使用Date对象。 
The number of milliseconds is the number of milliseconds since January 1, 1970, 00:00:00 GMT.
 毫秒数是自格林威治标准时间1970年1月1日00:00:00以来的毫秒数。 
Notice the difference between milliseconds in Calendar and Date object, it’s because of the time taken for java program to create Date and Calendar object. Date object is created first, hence it’s milliseconds value is lower.
 请注意Calendar和Date对象中毫秒之间的差异，这是由于Java程序创建Date和Calendar对象所花费的时间。 首先创建日期对象，因此其毫秒值较低。 
You can use SimpleDateFormat class to format the date in different ways.
 您可以使用SimpleDateFormat类以不同方式设置日期格式。 
 
Update: If you are working on Java 8, then you should consider using new Date Time API. For more details, please read Java Date Time API Tutorial.
 
 更新 ：如果您正在使用Java 8，则应考虑使用新的Date Time API。 有关更多详细信息，请阅读Java Date Time API Tutorial 。 
 
 

  
翻译自: https://www.journaldev.com/703/get-current-date-time-java
 
 
java 获取当前日期时间

 
文章目录
 
一、简介
二、使用
1、获取当前时间的毫秒值
2、获取当前的时间
3、获取当前的日期(相对于月)
4、SimpleDateFormat中格式化字符的含义
5、YYYY与yyyy区别
   
   
三、JDK1.8中Date/Time API使用
1、LocalDate
2、LocalTime
3、LocalDateTime
   
   
四、Calendar的简单使用
1、得到相关日期元素
2、设置日期
3、日期计算（增加和减去日期）
4、日历对象和时间对象转化
5、String类型转为Calendar类型
   
  
 

 
 
一、简介
 
使用到的时间类有：
 
System.currentTimeMillis()：
 
System.currentTimeMillis()产生一个当前的毫秒，这个毫秒其实就是自1970年1月1日0时起的毫秒数，类型为long；
 Date：
 
类 Date 表示特定的瞬间，精确到毫秒。
 
从 JDK 1.1 开始，应该使用 Calendar 类实现日期和时间字段之间转换，使用 DateFormat 类来格式化和解析日期字符串。Date 中的相应方法已废弃。
 Calendar：
 
Calendar 类是一个抽象类，它为特定瞬间与一组诸如 YEAR、MONTH、DAY_OF_MONTH、HOUR 等 日历字段之间的转换提供了一些方法，并为操作日历字段（例如获得下星期的日期）提供了一些方法;
 
主要是用的是get方法：
 
get(int field)	返回给定日历字段的值。
 
其中传入的主要参数为：
 
HOUR_OF_DAY		一天中某个小时；

DAY_OF_WEEK		一个星期中的某天；
DAY_OF_MONTH	一个月中的某天；
DAY_OF_YEAR		当前年中的天数；

WEEK_OF_MONTH	当前月中的星期数；
WEEK_OF_YEAR	当前年中的星期数；
 
二、使用
 
1、获取当前时间的毫秒值
 
System.currentTimeMillis()
 
long timeNow = System.currentTimeMillis();
System.out.println(timeNow);
 
Date（不推荐使用）
 
Date date = new Date()getTime();
System.out.println(timeNow);
 
2、获取当前的时间
 
System.currentTimeMillis()(yyyy)
 
long time = System.currentTimeMillis();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd:HH-mm-ss");
String day = dateFormat.format(time);
System.out.println(day);
 
Date
 
Date date = new Date();
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd:HH-mm-ss");
String day = dateFormat.format(date);
System.out.println(day);
 
3、获取当前的日期(相对于月)
 
long timeMillis = System.currentTimeMillis();
SimpleDateFormat format = new SimpleDateFormat("dd");
String dayOfMonth = format.format(timeMillis);
System.out.println(dayOfMonth);
 
Calendar
 
Calendar instance = Calendar.getInstance();
int dayOfMonth = instance.get(Calendar.DAY_OF_MONTH);
System.out.println(dayOfMonth);
 
4、SimpleDateFormat中格式化字符的含义
 
 
5、YYYY与yyyy区别
 
日期格式化时，yyyy表示当天所在的年，而大写的YYYY代表是week in which year（JDK7之后引入的概念），意思是当天所在的周属于的年份，一周从周日开始，周六结束，只要本周跨年，返回的YYYY就是下一年。
 
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
若当天为2017/12/31，执行结果为2018/12/31。（本周跨越了2017年和2018年）
 
三、JDK1.8中Date/Time API使用
 
Java 8提供了一个全新的API，用以替换java.util.Date和java.util.Calendar。Date / Time API提供了多个类，包括：
 
LocalDate
LocalTime
LocalDateTime
ZonedDateTime
 
1、LocalDate
 
LocalDate只是一个日期，没有时间。 这意味着我们只能获得当前日期，但没有一天的具体时间。
 
LocalDate localDate = LocalDate.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("YYYY-MM-dd");
String date = localDate.format(dateTimeFormatter);
System.out.println(dateTime);2020-01-11
 
结果为：
 
2020-01-11
 
2、LocalTime
 
LocalTime与LocalDate相反，它只代表一个时间，没有日期。 这意味着我们只能获得当天的当前时间，而不是实际日期：
 
LocalTime localTime = LocalTime.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("HH:mm:ss");
String time = localTime.format(dateTimeFormatter);
System.out.println(time);
 
结果为：
 
14:20:43
 
获取今年的天数
 
int daysOfThisYear = LocalDate.now().lengthOfYear();
 
获取指定某年的天数
 
LocalDate.of(2011, 1, 1).lengthOfYear();
 
3、LocalDateTime
 
最后一个是LocalDateTime，也是Java中最常用的Date / Time类，代表前两个类的组合 - 即日期和时间的值：
 
LocalDateTime localDateTime = LocalDateTime.now();
DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("YYYY-MM-dd:HH:mm:ss");
String dateTime = localDateTime.format(dateTimeFormatter);
System.out.println(dateTime);
 
结果为:
 
2020-01-11:14:22:37
 
四、Calendar的简单使用
 
1、得到相关日期元素
 
Calendar c1 = new GregorianCalendar();
int year = c1.get(Calendar.YEAR);
 
Calendar中常用参数
 
Calendar.YEAR
Calendar.MONTH
Calendar.WEEK_OF_YEAR
Calendar.WEEK_OF_MONTH
Calendar.DATE
Calendar.DAY_OF_MONTH
Calendar.DAY_OF_YEAR
Calendar.DAY_OF_WEEK
Calendar.DAY_OF_WEEK_IN_MONTH
Calendar.AM_PM
Calendar.HOUR
Calendar.HOUR_OF_DAY
Calendar.MINUTE
Calendar.SECOND
Calendar.MILLISECOND
Calendar.ZONE_OFFSET
Calendar.DST_OFFSET
Calendar.FIELD_COUNT
 
2、设置日期
 
Calendar c = new GregorianCalendar();
c.set(Calendar.YEAR,8000);
 
3、日期计算（增加和减去日期）
 
Calendar c = new GregorianCalendar();
c.add(Calendar.YEAR,-30);
 
4、日历对象和时间对象转化
 
Calendar c = new GregorianCalendar();
c.setTime(new Date());
 
5、String类型转为Calendar类型
 
String str="2020-10-10";
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
Date date = df.parse(str);
Calendar c = new GregorianCalendar();
c.setTime(date);

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

#1楼
 
 采用： 
 
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime());
System.out.println(timeStamp );
 
 （正在工作。） 
 

#2楼
 
 创建日期对象并简单地将其打印下来。 
 
Date d = new Date(System.currentTimeMillis());
System.out.print(d);
 

#3楼
 
 如果您希望当前日期为字符串，请尝试以下操作： 
 
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/ 
 

#4楼
 
 与上述解决方案相似。 但是我总是发现自己在寻找这段代码： 
 
Date date=Calendar.getInstance().getTime();
System.out.println(date);
 

#5楼
 
 在Java 8中为： 
 
LocalDateTime.now()
 
 并且如果您需要时区信息： 
 
ZonedDateTime.now()
 
 并且如果您想打印花式格式化的字符串： 
 
System.out.println(ZonedDateTime.now().format(DateTimeFormatter.RFC_1123_DATE_TIME))
 

#6楼
 
 我发现这是最好的方法： 
 
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
 

#7楼
 
    // 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() );
 

#8楼
 
 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起的毫秒数，以进行时间比较。 
 
 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 
 
 2理解java.util.Calendar类 
 
 2.1使用日历类获取当前时间戳 
 
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/ 
 

#9楼
 
 采用： 
 
SimpleDateFormat sdf = new SimpleDateFormat("yyyy:MM:dd::HH:mm:ss");
System.out.println(sdf.format(System.currentTimeMillis()));
 
 print语句将在调用时而不是在创建SimpleDateFormat时打印时间。 因此，可以重复调用它而无需创建任何新对象。 
 

#10楼
 
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获取格式 
 
 

#11楼
 
 tl; dr 
 
Instant.now()                         // Capture the current moment in UTC, with a resolution of nanoseconds. Returns a `Instant` object.
 
 … 要么 … 
 
ZonedDateTime.now(                    // Capture the current moment as seen in…
    ZoneId.of( "America/Montreal" )   // … the wall-clock time used by the people of a particular region (a time zone).
)                                     // Returns a `ZonedDateTime` object.
 
 java.time 
 
 一些答案中提到java.time类是现代的替代品， 该类是与最早的Java版本捆绑在一起的麻烦的旧旧日期时间类的替代品。 以下是更多信息。 
 
  
 
 时区 
 
 其他答案无法解释时区在确定当前日期和时间方面如何至关重要。 对于任何给定的时刻，日期和时间在全球范围内都会因区域而异。 例如，午夜过后几分钟是法国巴黎的新一天，而在蒙特利尔魁北克仍然是“昨天”。 
 
 Instant 
 
 作为最佳实践，您的许多业务逻辑和数据存储/交换都应在UTC中完成。 
 
 要获得当前时刻的UTC在分辨率纳秒 ，使用Instant类。 常规计算机硬件时钟的准确性受到限制，因此当前时刻可能以毫秒或微秒而不是纳秒的速度捕获。 
 
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 ZonedDateTime 。 
 
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.
 
 弦乐 
 
 要生成表示日期时间值的字符串，只需对java.time类的标准ISO 8601格式调用toString 。 
 
String output = myLocalDate.toString();  // 2016-09-23
 
 … 要么 … 
 
String output = zdt.toString();  // 2016-09-23T12:34:56.789+03:00[America/Montreal]
 
 ZonedDateTime类通过在方括号中明智地附加时区名称来扩展标准格式。 
 
 对于其他格式，请在“堆栈溢出”中搜索有关DateTimeFormatter类的许多问题和答案。 
 
 避免LocalDateTime 
 
 相反，由RamanSB问题的评论，你不应该使用LocalDateTime类为当前日期与时间。 
 
 LocalDateTime故意缺少任何时区或UTC偏移信息。 所以，当您在跟踪时间轴上的特定时刻，这是不恰当的。 当然不适合捕获当前时刻。 
 
 LocalDateTime只有一个日期和时间，例如“ 2020年1月23日中午”，但是我们不知道这是日本东京中午还是美国俄亥俄州托莱多中午，相隔两个小时。 
 
 “本地”用语是违反直觉的。 它意味着任何地点，而不是任何一个特定地点。 例如，今年的圣诞节从12月25日的午夜开始： 2017-12-25T00:00:00 ，以LocalDateTime表示。 但这意味着全球各地在不同时间的午夜。 午夜首先发生在基里巴斯 ，之后是新西兰，再之后是印度，等等，依此类推，圣诞节开始之前，法国在加拿大的孩子们仍在等待这一天之前，已经过了几个小时。 这些圣诞节开始点中的每一个都将表示为单独的ZonedDateTime 。 
 

 从系统外部 
 
 如果您不能信任系统时钟，请参阅Java：从服务器而不是系统时钟获取当前日期和时间，以及我的答案 。 
 
  
 
 java.time.Clock 
 
 要利用当前时刻的备用供应商，请编写抽象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及更高版本中。 这些类取代了麻烦的旧的旧式日期时间类，例如java.util.Date ， Calendar和SimpleDateFormat 。 
 
 要了解更多信息，请参见Oracle教程 。 并在Stack Overflow中搜索许多示例和说明。 规格为JSR 310 。 
 
 现在处于维护模式的Joda-Time项目建议迁移到java.time类。 
 
 您可以直接与数据库交换java.time对象。 使用与JDBC 4.2或更高版本兼容的JDBC驱动程序 。 不需要字符串，不需要java.sql.*类。 
 
 在哪里获取java.time类？ 
 
 Java SE 8 ， Java SE 9 ， Java SE 10 ， Java SE 11和更高版本-标准Java API的一部分，具有捆绑的实现。 
  
 Java 9添加了一些次要功能和修复。 
 Java SE 6和Java SE 7 
  
 大多数java.time功能都在ThreeTen- Backport中反向移植到Java 6和7。 
 安卓系统 
  
 更高版本的Android捆绑了java.time类的实现。 
 对于早期的Android（<26）， ThreeTenABP项目改编了ThreeTen-Backport （如上所述）。 请参阅如何使用ThreeTenABP… 。 
  
 
 ThreeTen-Extra项目使用其他类扩展了java.time。 该项目为将来可能在java.time中添加内容提供了一个试验场。 您可以在这里找到一些有用的类，比如Interval ， YearWeek ， YearQuarter ，和更多 。 
 

#12楼
 
 您可以自己使用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文档已不建议使用 。 
 
 Oracle文档： 
 
 
 
 Date类表示特定的时间瞬间，精度为毫秒。 
 
 
 在JDK 1.1之前，Date类具有两个附加功能。 它允许将日期解释为年，月，日，小时，分钟和秒值。 它还允许格式化和解析日期字符串。 不幸的是，这些功能的API不适合国际化。 从JDK 1.1开始，应使用Calendar类在日期和时间字段之间进行转换，而DateFormat类应用于格式化和解析日期字符串。 不建议使用Date中的相应方法。 
 
 
 因此，您也可以使用Calendar类， 
 
Calendar.YEAR;
//and lot more
 
 要获取当前时间，可以使用： 
 
Calendar rightNow = Calendar.getInstance();
 
 
 
 文件： 
 
 
 与其他对语言环境敏感的类一样， 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教程：Java SimpleDateFormat 。 
 
 正如其他人提到的那样，当我们需要从日期开始进行操作时，我们没有简单，最佳的方法，或者我们不满意内置于类，API中的内容。 
 
 例如，当我们需要在两个日期之间取得差异时，当我们需要比较两个日期（对此也有内置方法）时 ，等等。 我们不得不使用第三方库。 Joda Time是其中一种最受欢迎​​的产品。 
 
 另请阅读： 
 
 如何正确获取Joda-Time中的当前日期和时间？ 
 JodaTime-如何获取UTC的当前时间 
 JodaTime示例。 
 下载Joda 
 。 现在最快乐的事情是（在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);
 
 阅读有关Java 8 date的优秀博客文章之一 。 
 
 并保持谨慎，以查找有关Java日期和时间的更多信息，因为您可以获取/使用更多的方法和/或有用的方法。 
 
 日期和时间的Oracle教程 。 
 Oracle格式化程序教程 。 
 课程：标准日历。 
 编辑： 
 
 根据@BasilBourque的评论，麻烦的旧日期时间类（例如java.util.Date ， java.util.Calendar和java.text.SimpleTextFormat现在已被遗留 ，由java.time类取代。 
 

#13楼
 
 对于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/ 
 

#14楼
 
 我将继续回答这个问题，因为当我遇到相同的问题时，这就是我所需要的： 
 
Date currentDate = new Date(System.currentTimeMillis());
 
 现在， currentDate是Java Date对象中的当前日期。 
 

#15楼
 
 System.out.println( new SimpleDateFormat("yyyy:MM:dd - hh:mm:ss a").format(Calendar.getInstance().getTime()) );
    //2018:02:10 - 05:04:20 PM
 
 AM / PM的日期/时间 
 

#16楼
 
 
 
 新的数据时间API是在Java 8诞生时引入的。这是由于在旧的数据时间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
 

#17楼
 
 您看过java.util.Date吗？ 这正是您想要的。 
 

#18楼
 
只需创建一个Date对象... 
 
Date date = new Date();
 

#19楼
 
 有许多不同的方法： 
 
 System.currentTimeMillis（） 
 日期 
 日历 

#20楼
 
 看一下Date类。 还有一个更新的Calendar类，它是执行许多日期/时间操作的首选方法（不赞成使用Date上的许多方法。） 
 
 如果只需要当前日期，则可以创建一个新的Date对象或调用Calendar.getInstance(); 。 
 

#21楼
 
 这取决于您想要的日期/时间形式： 
 
 如果您希望日期/时间为单个数值，那么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的LocalDateTime速度很慢 。） 
 在Java 8中，调用LocalDateTime.now()和ZonedDateTime.now()将为您提供当前日期/时间的表示形式1 。 
 在Java 8之前，大多数了解这些事情的人都建议Joda-time拥有（到目前为止）最好的Java API来完成涉及时间点和持续时间计算的事情。 对于Java 8，这不再是事实。 但是，如果您已经在代码库中使用Joda time，则没有2个强烈的理由进行迁移。 
 

 1-请注意，LocalDateTime不包含时区。正如javadoc所说： “如果没有其他信息（例如偏移量或时区），它就无法在时间轴上表示时刻。”
 
 2-如果不这样做，您的代码不会中断，也不会收到弃用警告。当然，Joda代码库可能会停止获取更新，但是不太可能需要它们。没有更新意味着稳定性，这是一件好事 。还要注意，很有可能有人会修复Java平台中由回归引起的问题。
 

#22楼
 
java.util.Date date = new java.util.Date();
 
它使用实例化的时间自动填充。 
 

#23楼
 
 如前所述，基本的Date（）可以完成获取当前时间所需的工作。 在我最近的大量使用Java日期的经验中，内置类有很多奇怪的地方（以及许多Date类方法的弃用）。 在我看来，一个奇怪的是，月份是基于0指数的，从技术角度来看这是有道理的，但实际上可能会非常令人困惑。 
 
 如果您只关心应该满足的当前日期-但是，如果您打算对日期进行大量操作/计算，那么使用第三方库可能会非常有益（存在许多第三方库，因为许多Java开发人员对这些日期不满意内置功能）。 
 
 我第二次引用Stephen C的建议，因为我发现Joda-time在简化日期工作方面非常有用，它的文档也非常丰富，您可以在网上找到许多有用的示例。 我什至最终编写了一个静态包装器类（如DateUtils），用于合并和简化所有常见的日期操作。 
 

#24楼
 
 我创建了这种方法，对我有用。 
 
public String GetDay() {
    return String.valueOf(LocalDateTime.now().format(DateTimeFormatter.ofPattern("dd")));
}

public String GetNameOfTheDay() {
    return String.valueOf(LocalDateTime.now().getDayOfWeek());
}

public String GetMonth() {
    return String.valueOf(LocalDateTime.now().format(DateTimeFormatter.ofPattern("MM")));
}

public String GetNameOfTheMonth() {
    return String.valueOf(LocalDateTime.now().getMonth());
}

public String GetYear() {
    return String.valueOf(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy")));
}

public boolean isLeapYear(long year) {
    return Year.isLeap(year);
}

public String GetDate() {
    return GetDay() + "/" + GetMonth() + "/" + GetYear();
}

public String Get12HHour() {
    return String.valueOf(LocalDateTime.now().format(DateTimeFormatter.ofPattern("hh")));
}

public String Get24HHour() {
    return String.valueOf(LocalDateTime.now().getHour());
}

public String GetMinutes() {
    return String.valueOf(LocalDateTime.now().format(DateTimeFormatter.ofPattern("mm")));
}

public String GetSeconds() {
    return String.valueOf(LocalDateTime.now().format(DateTimeFormatter.ofPattern("ss")));
}

public String Get24HTime() {
    return Get24HHour() + ":" + GetMinutes();
}

public String Get24HFullTime() {
    return Get24HHour() + ":" + GetMinutes() + ":" + GetSeconds();
}

public String Get12HTime() {
    return Get12HHour() + ":" + GetMinutes();
}

public String Get12HFullTime() {
    return Get12HHour() + ":" + GetMinutes() + ":" + GetSeconds();
}
 

#25楼
 
 只需尝试以下代码： 
 
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
public class CurrentTimeDateCalendar {
    public static void getCurrentTimeUsingDate() {
        Date date = new Date();
        String strDateFormat = "hh:mm:ss a";
        DateFormat dateFormat = new SimpleDateFormat(strDateFormat);
        String formattedDate= dateFormat.format(date);
        System.out.println("Current time of the day using Date - 12 hour format: " + formattedDate);
    }
    public static void getCurrentTimeUsingCalendar() {
        Calendar cal = Calendar.getInstance();
        Date date=cal.getTime();
        DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        String formattedDate=dateFormat.format(date);
        System.out.println("Current time of the day using Calendar - 24 hour format: "+ formattedDate);
    }
}
 
 样本输出是： 
 
 
 
 使用日期的一天中的当前时间-12小时格式：晚上11:13:01 
 
 
 使用日历的一天中的当前时间-24小时格式：23：13：01 
 
 
 有关更多信息： 
 
 用Java获取当前日期时间 
 

#26楼
 
 Java 8或以上
 
LocalDateTime.now() and ZonedDateTime.now()
 

#27楼
 
如果您只需要以YYYY.MM.DD-HH.MM.SS格式（非常常见）输出时间戳，则可以采用以下方法： 
 
String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(Calendar.getInstance().getTime());

Date date = new Date(System.currentTimeMillis());
 SimpleDateFormat dateFormat = new SimpleDateFormat(“yyyy-MM-dd HH:mm:ss”);
 dateFormat.setTimeZone(TimeZone.getTimeZone(“GMT+8”));
 String time = dateFormat.format(date);
 Calendar c = Calendar.getInstance();
 Date nowDate = new SimpleDateFormat(“yy-MM-dd”).parse(time);;
 c.setTime(nowDate);
 c.set(Calendar.DATE, c.get(Calendar.DATE) + 1);
 String time2 = new SimpleDateFormat(“yyyy-MM-dd”).format(c.getTime());
 System.err.println(time + " —" + time2);