本文目錄一覽：
- 1、java中基類和超類的區別
- 2、java中關於時間的方法
- 3、java里表示時間的類型是什麼?
- 4、java里怎麼自定義一個日期！
- 5、Java中如何設置Date對象的年月日
- 6、java中如何對時間做國際化處理啊
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
或者直接獲取毫秒，但是感覺與你問題無關
原創文章，作者：小藍，如若轉載，請註明出處：https://www.506064.com/zh-hk/n/190448.html
微信掃一掃 
支付寶掃一掃 