您的位置:

java中的与时间相关的6个类的简单介绍

本文目录一览:

java中基类和超类的区别

本章介绍Java的实用工具类库java.util包。在这个包中,Java提供了一些实用的方法和数据结构。例如,Java提供日期(Data)类、日历(Calendar)类来产生和获取日期及时间,提供随机数(Random)类产生各种类型的随机数,还提供了堆栈(Stack)、向量(Vector) 、位集合(Bitset)以及哈希表(Hashtable)等类来表示相应的数据结构。

图1.1给出了java.util包的基本层次结构图。下面我们将具体介绍其中几个重要的类。

┌java.util.BitSet

│java.util.Calendar

│ └java.util.GregorianCalendar

│java.util.Date

│java.util.Dictionary

│ └java.util.Hashtable

│ └java.util.Properties

│java.util.EventObject

│java.util.ResourceBundle

┌普通类┤ ├java.util.ListResourceBundle

│ │ └java.util.PropertyResourceBundle

│ │java.util.Local

│ │java.util.Observable

│ │java.util.Random

│ │java.util.StringTokenizer

│ │java.util.Vector

│ │ └java.util.Stack

Java.util┤ └java.util.TimeZone

│ └java.util.SimpleTimeZone

│ ┌java.util.Enumeration

├接 口┤java.util.EventListener

│ └java.util.Observer

│ ┌java.util.EmptyStackException

└异常类┤java.util.MissingResourceException

│java.util.NoSuchElementException

└java.util.TooManyListenersException

图1.1 java.util包的基本层次结构

1.2 日期类Date

Java在日期类中封装了有关日期和时间的信息,用户可以通过调用相应的方法来获取系统时间或设置日期和时间。Date类中有很多方法在JDK1.0公布后已经过时了,在8.3中我们将介绍JDK1.0中新加的用于替代Date的功能的其它类。

在日期类中共定义了六种构造函数。

(1)public Date()

创建的日期类对象的日期时间被设置成创建时刻相对应的日期时间。

例 Date today=new Date();//today被设置成创建时刻相对应的日期时间。

(2)public Date (long date)

long 型的参数date可以通过调用Date类中的static方法parse(String s)来获得。

例 long l=Date.parse("Mon 6 Jan 1997 13:3:00");

Date day=new Date(l);

//day中时间为1997年 1月6号星期一,13:3:00。

(3)public Date(String s)

按字符串s产生一日期对象。s的格式与方法parse中字符串参数的模式相同。

例 Date day=new Date("Mon 6 Jan 1997 13:3:00");

//day 中时间为1997年1月6号星期一,13:3:00.

(4)public Date(int year,int month,int date)

(5)public Date(int year,int month,int date,int hrs,int min)

(6)public Date(int year,int month,int date,int hrs,int min,int sec)

按给定的参数创建一日期对象。

参数说明:

year的值为:需设定的年份-1900。例如需设定的年份是1997则year的值应为97,即1997-1900的结果。所以Date中可设定的年份最小为1900;

month的值域为0~11,0代表1月,11表代表12月;

date的值域在1~31之间;

hrs的值域在0~23之间。从午夜到次日凌晨1点间hrs=0,从中午到下午1点间hrs=12;

min和sec的值域在0~59之间。

例 Date day=new Date(11,3,4);

//day中的时间为:04-Apr-11 12:00:00 AM

另外,还可以给出不正确的参数。

例 设定时间为1910年2月30日,它将被解释成3月2日。

Date day=new Date(10,1,30,10,12,34);

System.out.println("Day's date is:"+day);

//打印结果为:Day's date is:Web Mar 02 10:13:34 GMT+08:00 1910

下面我们给出一些Date类中常用方法。

(1)public static long UTC(int year,int month,int date,int hrs. int min,int sec)

该方法将利用给定参数计算UTC值。UTC是一种计时体制,与GMT(格林威治时间)的计时体系略有差别。UTC计时体系是基于原子时钟的,而GTMT计时体系是基于天文学观测的。计算中使用的一般为GMT计时体系。

(2)public static long parse(String s)

该方法将字符串s转换成一个long型的日期。在介绍构造方法Date(long date)时曾使用过这个方法。

字符串s有一定的格式,一般为:

(星期 日 年 时间GMT+时区)

若不注明时区,则为本地时区。

(3)public void setMonth(int month)

(4)public int getMonth()

这两个方法分别为设定和获取月份值。

获取的月份的值域为0~11,0代表1月,11代表12月。

(5)public String toString()

(6)public String toLocalString()

(7)public String toGMTString()

将给定日期对象转换成不同格式的字符串。它们对应的具体的格式可参看例子8.1。

(8)public int getTimezoneOffset()

该方法用于获取日期对象的时区偏移量。

例8.1中对上面介绍的Date类中的基本方法进行了具体的应用,并打印了相应的结果。由于使用了一些过时的方法,所以编译时会有警告信息。另外,由于本例中的时间表示与平台有关,不同的JDK版本对此处理不完全相同,因此不同版本的JDK执行本例的结果可能有细微差异。

例1.1 DateApp.java

import java.lang.System;

import java.util.Date;

public class DateApp{

public static void main(String args[]){

Date today=new Date();

//today中的日期被设成创建时刻的日期和时间,假设创建时刻为1997年3月

//23日17时51分54秒。

System.out.println("Today's date is "+today);

//返回一般的时间表示法,本例中结果为

//Today's date is Fri May 23 17:51:54 1997

System.out.println("Today's date(Internet GMT)is:"

+today.toGMTString());

//返回结果为GMT时间表示法,本例中结果为

//Today's date(Internet GMT)is: 23 May 1997 09:51:54:GMT

System.out.println("Today's date(Locale) is:"

+today.toLocaleString());

//返回结果为本地习惯的时间表示法,结果为

//Today's date(Locale)is:05/23/97 17:51:54

System.out.println("Today's year is: "+today.getYear());

System.out.println("Today's month is: "+(today.getMonth()+1));

System.out.println("Today's date is: "+today.getDate());

//调用Date类中方法,获取年月日的值。

//下面调用了不同的构造方法来创建Date类的对象。

Date day1=new Date(100,1,23,10,12,34);

System.out.println("Day1's date is: "+day1);

Date day2=new Date("Sat 12 Aug 1996 13:3:00");

System.out.println("Day2's date is: "+day2);

long l= Date.parse("Sat 5 Aug 1996 13:3:00 GMT+0800");

Date day3= new Date(l);

System.out.println("Day3's date(GMT)is: "+day3.toGMTString());

System.out.println("Day3's date(Locale)is: "

+day3.toLocaleString());

System.out.println("Day3's time zone offset is:"

+day3.getTimezoneOffset());

}

}

运行结果(JDK1.3版,与原文不同,原文是JDK1.0版):

E:\java\tutorial\java01java DateApp

Today's date is Thu Dec 27 17:58:16 CST 2001

Today's date(Internet GMT)is:27 Dec 2001 09:58:16 GMT

Today's date(Locale) is:2001-12-27 17:58:16

Today's year is: 101

Today's month is: 12

Today's date is: 27

Day1's date is: Wed Feb 23 10:12:34 CST 2000

Day2's date is: Fri Aug 12 13:03:00 CST 1996

Day3's date(GMT)is: 5 Aug 1996 05:03:00 GMT

Day3's date(Locale)is: 1996-8-5 13:03:00

Day3's time zone offset is:-480

E:\java\tutorial\java01

1.3 日历类Calendar

在早期的JDK版本中,日期(Date)类附有两大功能:(1)允许用年、月、日、时、分、秒来解释日期:(2)允许对表示日期的字符串进行格式化和句法分析。在JDK1.1中提供了类Calendar来完成第一种功能,类DateFormat来完成第二项功能。dateFormat是java.text包中的一个类。与Date类有所不同的是,DateFormat类接受用各种语言和不同习惯表示的日期字符串。本节将介绍java.util包中的类Calendar及其它新增加的相关的类。

类Calendar是一个抽象类,它完成日期(Date)类和普通日期表示法(即用一组整型域如YEAR,MONTH,DAY,HOUR表示日期)之间的转换。

由于所使用的规则不同,不同的日历系统对同一个日期的解释有所不同。在JDK1.1中提供了Calendar类一个子类GregorianCalendar??它实现了世界上普遍使用的公历系统。当然用户也可以通过继承Calendar类,并增加所需规则,以实现不同的日历系统。

第GregorianCalendar继承了Calendar类。本节将在介绍类GregorianCalendar的同时顺带介绍Calendar类中的相关方法。

类GregorianCalendar提供了七种构造函数:

(1)public GregorianCalendar()

创建的对象中的相关值被设置成指定时区,缺省地点的当前时间,即程序运行时所处的时区、地点的当前时间。

(2)public GregorianCalendar(TimeZone zone)

创建的对象中的相关值被设置成指定时区zone,缺省地点的当前时间。

(3)public GregorianCalendar(Locale aLocale)

创建的对象中的相关值被设置成缺省时区,指定地点aLocale的当前时间。

(4)public GregorianCalendar(TimeZone zone,Local aLocale)

创建的对象中的相关值被设置成指定时区,指定地点的当前时间。

上面使用到的类TimeZone的性质如下:

TimeZone是java.util包中的一个类,其中封装了有关时区的信息。每一个时区对应一组ID。类TimeZone提供了一些方法完成时区与对应ID两者之间的转换。

(Ⅰ)已知某个特定的ID,可以调用方法

public static synchronized TimeZone getTimeZone(String ID)

来获取对应的时区对象。

例 太平洋时区的ID为PST,用下面的方法可获取对应于太平洋时区的时区对象:

TimeZone tz=TimeZone.getTimeZone("PST");

调用方法getDefault()可以获取主机所处时区的对象。

TimeZone tz=TimeZone.getDefault();

(Ⅱ)调用以下方法可以获取时区的ID

■public static synchronized String[] getavailableIDs(int rawOffset)

根据给定时区偏移值获取ID数组。同一时区的不同地区的ID可能不同,这是由于不同地区对是否实施夏时制意见不统一而造成的。

例String s

java中关于时间的方法

new Date();就是系统当前的时间。

建议你这样比较

DateFormat df=DateFormat.getDateTimeInstance();

boolean dayFlagbefore=df.parse("2010-12-07 12:39:58").before(new Date());

java.util.date.

java里表示时间的类型是什么?

java.util.Date,和java.util.Calendar 是 java 的主要的时间类型

Java.util.Calendar类是java.util.Date类的一个更加深入,更加全面的替代。Java.util.Calendar类支持java.util.Date的所有功能,此外,Calendar还引入了多语言,多区域的特性,可以根据需要获取不同区域,不同时区的时间,Calendar还增加了比Date更加方便和快捷的许多操作,如获取一年当中的第几个星期,各个月的天数等便捷的方法。

Java.util.Calendar区别与java.util.Date的几个地方也需要注意一下:首先,Calendar增加了毫秒的时间段,通过它可以获取时间点的毫秒值,而java.util.Date只是精确到秒。其次,Calendar过去年的时候是当前年份比如:2010,而Date获取年份的时获取到的是当前年份-1900的一个值(2010-1900=110,因此,你调用getYear后过去的值就是110)。最后Calendar是一个抽象类,之所以能够实例化,是因为此处的Calendar充当了一个类似于工厂的作用,在getInstance方法中实例化了Calendar子类GregorianCalendar,并把它返回给客户使用。

此外,还有 java.sql.Date, java.sql.Time, java.sql.Timestamp

java里怎么自定义一个日期!

在旧版本的jdk中,Java的日期/时间类的定义并不一致,在java.util和java.sql的包中都有日期类,此外用于格式化和解析的类在java.text.SimpleDateFormat包中定义。

java.util.Date是在除了SQL语句的情况下面使用的。

java.sql.Date是针对SQL语句使用的,它只包含日期而没有时间部分

它们都有getTime方法返回毫秒数,自然就可以直接构建。 java.util.Date 是 java.sql.Date 的父类,前者是常用的表示时间的类,我们通常格式化或者得到当前时间都是用他,后者之后在读写数据库的时候用他,因为PreparedStament的setDate()的第2参数和ResultSet的getDate()方法的第2个参数都是java.sql.Date。

java.sql.Date转为java.util.Date

java.sql.Date date=new java.sql.Date();

java.util.Date d=new java.util.Date (date.getTime());

java.util.Date转为java.sql.Date

java.util.Date utilDate=new Date();

java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime());

java.util.Date utilDate=new Date();

java.sql.Date sqlDate=new java.sql.Date(utilDate.getTime());

java.sql.Time sTime=new java.sql.Time(utilDate.getTime());

java.sql.Timestamp stp=new java.sql.Timestamp(utilDate.getTime());

这里所有时间日期都可以被SimpleDateFormat格式化format()

SimpleDateFormat f=new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");

f.format(stp);

f.format(sTime);

f.format(sqlDate);

f.format(utilDate)

java.sql.Date sqlDate=java.sql.Date.valueOf(" 2005-12-12");

utilDate=new java.util.Date(sqlDate.getTime());

另类取得年月日的方法:

import java.text.SimpleDateFormat;

import java.util.*;

java.util.Date date = new java.util.Date();

//如果希望得到YYYYMMDD的格式SimpleDateFormat

sy1=new SimpleDateFormat("yyyyMMDD");

String dateFormat=sy1.format(date);

//如果希望分开得到年,月,日SimpleDateFormat

sy=new SimpleDateFormat("yyyy");

SimpleDateFormat sm=new SimpleDateFormat("MM");

SimpleDateFormat sd=new SimpleDateFormat("dd");

String syear=sy.format(date);

String smon=sm.format(date);

String sday=sd.format(date);

注意啦!!!在JAVA 8中有了日期的新的表示方式。在java.time包中。

   Java 8日期/时间( Date/Time)API是开发人员最受追捧的变化之一,Java从一开始就没有对日期时间处理的一致性方法,因此日期/时间API也是除Java核心API以外另一项倍受欢迎的内容。

为什么我们需要新的Java日期/时间API?

    在开始研究Java 8日期/时间API之前,让我们先来看一下为什么我们需要这样一个新的API。在Java中,现有的与日期和时间相关的类存在诸多问题,其中有:

1. Java的日期/时间类的定义并不一致,在java.util和java.sql的包中都有日期类,此外用于格式化和解析的类在java.text包中定义。

2. java.util.Date同时包含日期和时间,而java.sql.Date仅包含日期,将其纳入java.sql包并不合理。另外这两个类都有相同的名字,这本身就是一个非常糟糕的设计。

3. 对于时间、时间戳、格式化以及解析,并没有一些明确定义的类。对于格式化和解析的需求,我们有java.text.DateFormat抽象类,但通常情况下,SimpleDateFormat类被用于此类需求。

4. 所有的日期类都是可变的,因此他们都不是线程安全的,这是Java日期类最大的问题之一。

5. 日期类并不提供国际化,没有时区支持,因此Java引入了java.util.Calendar java.util.TimeZone类,但他们同样存在上述所有的问题。

     在现有的日期和日历类中定义的方法还存在一些其他的问题,但以上问题已经很清晰地表明:Java需要一个健壮的日期/时间类。这也是为什么Joda Time在Java日期/时间需求中扮演了高质量替换的重要角色。

Java 8日期/时间API是JSR-310的实现,它的实现目标是克服旧的日期时间实现中所有的缺陷,新的日期/时间API的一些设计原则是:

1. 不变性:新的日期/时间API中,所有的类都是不可变的,这对多线程环境有好处。

2. 关注点分离:新的API将人可读的日期时间和机器时间(unix timestamp)明确分离,它为日期(Date)、时间(Time)、日期时间(DateTime)、时间戳(unix timestamp)以及时区定义了不同的类。

3. 清晰:在所有的类中,方法都被明确定义用以完成相同的行为。举个例子,要拿到当前实例我们可以使用now()方法,在所有的类中都定义了format()和parse()方法,而不是像以前那样专门有一个独立的类。为了更好的处理问题,所有的类都使用了工厂模式和策略模式,一旦你使用了其中某个类的方法,与其他类协同工作并不困难。

4. 实用操作:所有新的日期/时间API类都实现了一系列方法用以完成通用的任务,如:加、减、格式化、解析、从日期/时间中提取单独部分,等等。

5. 可扩展性:新的日期/时间API是工作在ISO-8601日历系统上的,但我们也可以将其应用在非IOS的日历上。

Java日期/时间API包含以下相应的包。

1. java.time包:这是新的Java日期/时间API的基础包,所有的主要基础类都是这个包的一部分,如:LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有这些类都是不可变的和线程安全的,在绝大多数情况下,这些类能够有效地处理一些公共的需求。

2. java.time.chrono包:这个包为非ISO的日历系统定义了一些泛化的API,我们可以扩展AbstractChronology类来创建自己的日历系统。

3. java.time.format包:这个包包含能够格式化和解析日期时间对象的类,在绝大多数情况下,我们不应该直接使用它们,因为java.time包中相应的类已经提供了格式化和解析的方法。

4. java.time.temporal包:这个包包含一些时态对象,我们可以用其找出关于日期/时间对象的某个特定日期或时间,比如说,可以找到某月的第一天或最后一天。你可以非常容易地认出这些方法,因为它们都具有“withXXX”的格式。

5. java.time.zone包:这个包包含支持不同时区以及相关规则的类。

新旧API的对比图:

新API的示例代码:

public class TimeIntroduction {

    public static void testClock() throws InterruptedException {

        //时钟提供给我们用于访问某个特定 时区的 瞬时时间、日期 和 时间的。  

        Clock c1 = Clock.systemUTC(); //系统默认UTC时钟(当前瞬时时间 System.currentTimeMillis())  

        System.out.println(c1.millis()); //每次调用将返回当前瞬时时间(UTC)  

        Clock c2 = Clock.systemDefaultZone(); //系统默认时区时钟(当前瞬时时间)  

        Clock c31 = Clock.system(ZoneId.of("Europe/Paris")); //巴黎时区  

        System.out.println(c31.millis()); //每次调用将返回当前瞬时时间(UTC)  

        Clock c32 = Clock.system(ZoneId.of("Asia/Shanghai"));//上海时区  

        System.out.println(c32.millis());//每次调用将返回当前瞬时时间(UTC)  

        Clock c4 = Clock.fixed(Instant.now(), ZoneId.of("Asia/Shanghai"));//固定上海时区时钟  

        System.out.println(c4.millis());

        Thread.sleep(1000);

        System.out.println(c4.millis()); //不变 即时钟时钟在那一个点不动  

        Clock c5 = Clock.offset(c1, Duration.ofSeconds(2)); //相对于系统默认时钟两秒的时钟  

        System.out.println(c1.millis());

        System.out.println(c5.millis());

    }

    public static void testInstant() {

        //瞬时时间 相当于以前的System.currentTimeMillis()  

        Instant instant1 = Instant.now();

        System.out.println(instant1.getEpochSecond());//精确到秒 得到相对于1970-01-01 00:00:00 UTC的一个时间  

        System.out.println(instant1.toEpochMilli()); //精确到毫秒  

        Clock clock1 = Clock.systemUTC(); //获取系统UTC默认时钟  

        Instant instant2 = Instant.now(clock1);//得到时钟的瞬时时间  

        System.out.println(instant2.toEpochMilli());

        Clock clock2 = Clock.fixed(instant1, ZoneId.systemDefault()); //固定瞬时时间时钟  

        Instant instant3 = Instant.now(clock2);//得到时钟的瞬时时间  

        System.out.println(instant3.toEpochMilli());//equals instant1  

    }

    public static void testLocalDateTime() {

        //使用默认时区时钟瞬时时间创建 Clock.systemDefaultZone() --即相对于 ZoneId.systemDefault()默认时区  

        LocalDateTime now = LocalDateTime.now();

        System.out.println(now);

//自定义时区  

        LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Europe/Paris"));

        System.out.println(now2);//会以相应的时区显示日期  

//自定义时钟  

        Clock clock = Clock.system(ZoneId.of("Asia/Dhaka"));

        LocalDateTime now3 = LocalDateTime.now(clock);

        System.out.println(now3);//会以相应的时区显示日期  

//不需要写什么相对时间 如java.util.Date 年是相对于1900 月是从0开始  

//2013-12-31 23:59  

        LocalDateTime d1 = LocalDateTime.of(2013, 12, 31, 23, 59);

//年月日 时分秒 纳秒  

        LocalDateTime d2 = LocalDateTime.of(2013, 12, 31, 23, 59, 59, 11);

//使用瞬时时间 + 时区  

        Instant instant = Instant.now();

        LocalDateTime d3 = LocalDateTime.ofInstant(Instant.now(), ZoneId.systemDefault());

        System.out.println(d3);

//解析String---LocalDateTime  

        LocalDateTime d4 = LocalDateTime.parse("2013-12-31T23:59");

        System.out.println(d4);

        LocalDateTime d5 = LocalDateTime.parse("2013-12-31T23:59:59.999");//999毫秒 等价于999000000纳秒  

        System.out.println(d5);

//使用DateTimeFormatter API 解析 和 格式化  

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss");

        LocalDateTime d6 = LocalDateTime.parse("2013/12/31 23:59:59", formatter);

        System.out.println(formatter.format(d6));

//时间获取  

        System.out.println(d6.getYear());

        System.out.println(d6.getMonth());

        System.out.println(d6.getDayOfYear());

        System.out.println(d6.getDayOfMonth());

        System.out.println(d6.getDayOfWeek());

        System.out.println(d6.getHour());

        System.out.println(d6.getMinute());

        System.out.println(d6.getSecond());

        System.out.println(d6.getNano());

//时间增减  

        LocalDateTime d7 = d6.minusDays(1);

        LocalDateTime d8 = d7.plus(1, IsoFields.QUARTER_YEARS);

//LocalDate 即年月日 无时分秒  

//LocalTime即时分秒 无年月日  

//API和LocalDateTime类似就不演示了  

    }

    public static void testZonedDateTime() {

        //即带有时区的date-time 存储纳秒、时区和时差(避免与本地date-time歧义)。  

//API和LocalDateTime类似,只是多了时差(如2013-12-20T10:35:50.711+08:00[Asia/Shanghai])  

        ZonedDateTime now = ZonedDateTime.now();

        System.out.println(now);

        ZonedDateTime now2 = ZonedDateTime.now(ZoneId.of("Europe/Paris"));

        System.out.println(now2);

//其他的用法也是类似的 就不介绍了  

        ZonedDateTime z1 = ZonedDateTime.parse("2013-12-31T23:59:59Z[Europe/Paris]");

        System.out.println(z1);

    }

    public static void testDuration() {

        //表示两个瞬时时间的时间段  

        Duration d1 = Duration.between(Instant.ofEpochMilli(System.currentTimeMillis() - 12323123), Instant.now());

//得到相应的时差  

        System.out.println(d1.toDays());

        System.out.println(d1.toHours());

        System.out.println(d1.toMinutes());

        System.out.println(d1.toMillis());

        System.out.println(d1.toNanos());

//1天时差 类似的还有如ofHours()  

        Duration d2 = Duration.ofDays(1);

        System.out.println(d2.toDays());

    }

    public static void testChronology() {

        //提供对java.util.Calendar的替换,提供对年历系统的支持  

        Chronology c = HijrahChronology.INSTANCE;

        ChronoLocalDateTime d = c.localDateTime(LocalDateTime.now());

        System.out.println(d);

    }

    /**

     * 新旧日期转换

     */

    public static void testNewOldDateConversion(){

        Instant instant=new Date().toInstant();

        Date date=Date.from(instant);

        System.out.println(instant);

        System.out.println(date);

    }

    public static void main(String[] args) throws InterruptedException {

        testClock();

        testInstant();

        testLocalDateTime();

        testZonedDateTime();

        testDuration();

        testChronology();

        testNewOldDateConversion();

    }

}

Java中如何设置Date对象的年月日

Date

public Date(int year,

int month,

int day)

参数:

year - year 减去 1900,它必须是 0 到 8099 之间的数。(注意,8099 是由 9999 减去 1900 得到的。)

month - 0 到 11 之间的数

day - 1 到 31 之间的数

测试代码如下:

import java.util.Date;

public class Test {

public static void main(String args[]){

Date date = new Date(2010-1900,1,10);

System.out.println(date);

}

}

运行结果:

Wed Feb 10 00:00:00 CST 2010

希望对你有帮助。。。。。。仍有问题可以HI我。。。。

java中如何对时间做国际化处理啊

import java.util.*;

import java.text.*;

public class timeText {

/**

* @param args

*/

public static void main(String[] args) {

// TODO Auto-generated method stub

Date now = new Date();

Calendar cal = Calendar.getInstance();

DateFormat d1 = DateFormat.getDateInstance(); //默认语言(汉语)下的默认风格(MEDIUM风格,比如:2008-6-16 20:54:53)

String str1 = d1.format(now);

DateFormat d2 = DateFormat.getDateTimeInstance();//获取系统时间格式

String str2 = d2.format(now); //将时间格式转换成字符串

DateFormat d3 = DateFormat.getTimeInstance();

String str3 = d3.format(now);

DateFormat d4 = DateFormat.getInstance(); //使用SHORT风格显示日期和时间

String str4 = d4.format(now);

DateFormat d5 = DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL); //显示日期,周,时间(精确到秒)

String str5 = d5.format(now);

DateFormat d6 = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG); //显示日期。时间(精确到秒)

String str6 = d6.format(now);

DateFormat d7 = DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT); //显示日期,时间(精确到分)

String str7 = d7.format(now);

DateFormat d8 = DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM); //显示日期,时间(精确到分)

String str8 = d8.format(now);//与SHORT风格相比,这种方式最好用

System.out.println("用Date方式显示时间: " + now);//此方法显示的结果和Calendar.getInstance().getTime()一样

System.out.println("用DateFormat.getDateInstance()格式化时间后为:" + str1);

System.out.println("用DateFormat.getDateTimeInstance()格式化时间后为:" + str2);

System.out.println("用DateFormat.getTimeInstance()格式化时间后为:" + str3);

System.out.println("用DateFormat.getInstance()格式化时间后为:" + str4);

System.out.println("用DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL)格式化时间后为:" + str5);

System.out.println("用DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG)格式化时间后为:" + str6);

System.out.println("用DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT)格式化时间后为:" + str7);

System.out.println("用DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM)格式化时间后为:" + str8);

}

}

运行结果:

用Date方式显示时间: Mon Jun 16 20:54:53 CST 2008

用DateFormat.getDateInstance()格式化时间后为:2008-6-16

用DateFormat.getDateTimeInstance()格式化时间后为:2008-6-16 20:54:53

用DateFormat.getTimeInstance()格式化时间后为:20:54:53

用DateFormat.getInstance()格式化时间后为:08-6-16 下午8:54

用DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.FULL)格式化时间后为

:2008年6月16日 星期一 下午08时54分53秒 CST

用DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG)格式化时间后为

:2008年6月16日 下午08时54分53秒

用DateFormat.getDateTimeInstance(DateFormat.SHORT,DateFormat.SHORT)格式化时间后

为:08-6-16 下午8:54

用DateFormat.getDateTimeInstance(DateFormat.MEDIUM,DateFormat.MEDIUM)格式化时间

后为:2008-6-16 20:54:53

或者直接获取毫秒,但是感觉与你问题无关