JDK7 以前的時間相關類
全世界的時間, 有一個統一的計算標準.
格林尼治時間/格林威治時間 (Greenwich Mean Time) 簡稱 GMT. 計算核心: 地球自轉一天是 24 小時, 太陽直射時為正午 12 點. 後來發現計算誤差較大, 現在格林威治時間已經不再作為標準時間來使用了.
到了 2012 年 1 月, 取消了用了將近 130 年的迴歸制標準時間. 現在, 標準時間是由原子鐘來提供的.
原子鐘: 利用銫原子的震動的頻率計算出來的時間, 作為世界標準時間 (UTC)
銫原子每振動 9,192,631,770 次等於 1 秒鐘. 這種計算方式是非常精準的, 2000 萬年的誤差為 1 秒鐘.
中國位於東八區, 要在世界標準時間的基礎上加 8 小時.
Date 類
Date 類是一個 JDK 寫好的 Javabean 類, 用來描述時間, 精確到毫秒.
利用空參構造建立的物件, 預設表示作業系統當前時間.
利用有參構造建立的物件, 表示指定的時間.
程式示例:
import java.util.Date;
public class demo1 {
public static void main(String[] args) {
/*
public Date() 建立 Date 物件, 表示當前時間
public Date(long date) 建立 Date 物件, 表示指定時間
public void settime(long time) 設定/修改毫秒值
public long gettime() 獲取時間物件的毫秒值
*/
// 1. 建立物件表示一個時間
Date d1 = new Date();
System.out.println(d1);
// 2. 建立物件表示一個指定的時間
Date d2 = new Date(0L); // 從時間原點開始, 過了 0 毫秒的那個時間
System.out.println(d2);
// 3. settime 修改時間
// 1000 毫秒 = 1 秒
d2.setTime(1000L);
System.out.println(d2);
// 4. getTime 獲取當前時間的毫秒值
long time = d2.getTime();
System.out.println(time);
}
}
程式示例:
import java.util.Date;
import java.util.Random;
public class demo2 {
public static void main(String[] args) {
/*
需求 1: 列印時間原點開始一年之後的時間
需求 2: 定義任意兩個 Date 物件, 比較一下哪個時間在前, 哪個時間在後
*/
// 需求 2: 定義任意兩個 Date 物件, 比較一下哪個時間在前, 哪個時間在後
Random r = new Random();
// 建立兩個時間物件
Date d1 = new Date(Math.abs(r.nextInt()));
Date d2 = new Date(Math.abs(r.nextInt()));
long time1 = d1.getTime();
long time2 = d2.getTime();
if (time1 > time2) {
System.out.println("第一個時間在後面, 第二個時間在前面");
} else if (time1 < time2) {
System.out.println("第二個時間在後面, 第一個時間在前面");
} else {
System.out.println("表示兩個時間一樣");
}
}
private static void method() {
// 需求 1: 列印時間原點開始一年之後的時間
// 1. 建立一個物件, 表示時間原點
Date d1 = new Date(0L);
// 2. 獲取 d1 時間的毫秒值
long time = d1.getTime();
// 3. 在這個基礎上我們要加一年的毫秒值即可
time = time + 1000L * 60 * 60 * 24 * 365;
// 4. 把計算之後的時間毫秒值, 再設定回 d1 當中
d1.setTime(time);
// 5. 列印 d1
System.out.println(d1);
}
}
SimpleDateFormat 類
Date 類只能按照固定的格式列印時間, 而這個格式不符合一般的閱讀習慣.
SimpleDateFormat 類的作用:
-
格式化: 把時間變成我們喜歡的格式.
-
解析: 把字串表示的時間變成 Date 物件.
程式示例:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class demo3 {
public static void main(String[] args) throws ParseException {
/*
public simpleDateFormat() 預設格式
public simpleDateFormat(String pattern) 指定格式
public final string format(Date date) 格式化(日期物件 ->字串)
public Date parse(string source) 解析(字串 ->日期物件)
*/
// 1. 定義一個字串表示時間
String str = "2023-11-11 11:11:11";
// 2. 利用空參構造建立simpleDateFormat物件
// 細節:
// 建立物件的格式要跟字串的格式完全一致
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = sdf.parse(str);
// 3. 列印結果
System.out.println(date); // Sat Nov 11 11:11:11 CST 2023
System.out.println(date.getTime()); // 1699672271000
System.out.println("--------------------------------------------------------");
method1();
System.out.println("--------------------------------------------------------");
}
private static void method1() {
// 1. 利用空參構造建立 simpleDateFormat 物件, 預設格式
SimpleDateFormat sdf1 = new SimpleDateFormat();
Date d1 = new Date(0L);
String str1 = sdf1.format(d1);
System.out.println(str1); // 1970/1/1 上午8:00
// 2. 利用帶參構造建立simpleDateFormat物件, 指定格式
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
String str2 = sdf2.format(d1);
System.out.println(str2); // 1970年01月01日 08:00:00
// 課堂練習: yyyy年MM月dd日 時:分:秒 星期
SimpleDateFormat sdf3 = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss EE");
String str3 = sdf3.format(d1);
System.out.println(str3); // 1970年01月01日 08:00:00 週四
}
}
程式示例:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class demo4 {
public static void main(String[] args) throws ParseException {
/*
* 假設, 你初戀的出生年月日為: 2000-11-11
* 請用字串表示這個資料, 並將其轉換為: 2000年11月11日
*
* 建立一個 Date 物件表示 2000年11月11日
* 建立一個 SimpleDateFormat 物件, 並定義格式為年月日把時間變成: 2000年11月11日
*/
// 1. 可以透過 2000-11-11 進行解析, 解析成一個 Date 物件
String str = "2000-11-11";
// 2. 解析
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf1.parse(str);
// 3. 格式化
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy年MM月dd日");
String result = sdf2.format(date);
System.out.println(result); // 2000年11月11日
}
}
程式示例:
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
public class demo5 {
public static void main(String[] args) throws ParseException {
/*
* 需求:
* 秒殺活動開始時間: 2023年11月11日 0:0:0(毫秒值)
* 秒殺活動結束時間: 2023年11月11日 0:10:0(毫秒值)
*
* 小賈下單並付款的時間為: 2023年11月11日 0:01:0
* 小皮下單並付款的時間為: 2023年11月11日 0:11:0
* 用程式碼說明這兩位同學有沒有參加上秒殺活動?
*/
// 1. 定義字串表示三個時間
String startstr = "2023年11月11日 0:0:0";
String endstr = "2023年11月11日 0:10:0";
String orderstr = "2023年11月11日 0:01:00";
// 2. 解析上面的三個時間, 得到 Date 物件
SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日HH:mm:ss");
Date startDate = sdf.parse(startstr);
Date endDate = sdf.parse(endstr);
Date orderDate = sdf.parse(orderstr);
// 3. 得到三個時間的毫秒值
long startTime = startDate.getTime();
long endTime = endDate.getTime();
long orderTime = orderDate.getTime();
// 4. 判斷
if (orderTime >= startTime && orderTime <= endTime) {
System.out.println("參加秒殺活動成功"); // 參加秒殺活動成功
} else {
System.out.println("參加秒殺活動失敗");
}
}
}
Calendar 類
可以做, 但是比較麻煩.
Calendar 代表了系統當前時間的日曆物件, 可以單獨修改, 獲取時間中的年, 月, 日.
細節: Calendar 是一個抽象類, 不能直接建立物件.
獲取 Calendar 日曆類物件的方法:
BuddhistCalendar 是佛曆.
JapaneseImperialCalendar 是日本帝國曆.
GregorianCalendar 是格林威治日曆, 即公曆.
程式示例:
import java.util.Calendar;
public class CalendarDemo2 {
public static void main(String[] args) {
/*
* public static Calendar lgetInstance() 獲取當前時間的日曆物件
* public final Date getTime() 獲取日期物件
* public final setTime(Date date) 給日曆設定日期物件
* public long getTimeInMillis() 拿到時間毫秒值
* public void setTimeInMillis(long millis) 給日曆設定時間毫秒值
* public int get(int field) 獲取日期中的某個欄位資訊
* public void set(int field,int value) 修改日曆的某個欄位資訊
* public void add(int field,int amount) 為某個欄位增加/減少指定的值
*/
// 1.獲取日曆物件
// 細節1:Calendar是一個抽象類,不能直接new,而是透過一個靜態方法獲取到子類物件
// 底層原理:
// 會根據系統的不同時區來獲取不同的日曆物件,預設表示當前時間.
// 把會把時間中的紀元,年,月,日,時,分,秒,星期,等等的都放到一個陣列當中
// 日 : 紀元
// 1 : 年
// 2 : 月
// 3 : 一年中的第幾周
// 4 : 一個月中的第幾周
// 5 : 一個月中的第幾天(日期)
// ....
// 細節2:
// 月份:範圍0~11 如果獲取出來的是.那麼實際上是1月.
// 星期:在老外的眼裡,星期日是一週中的第一天
// 1(星期日) 2(星期一) 3(星期二) 4(星期三) 5(星期四) 6(星期五) 7(星期六)
Calendar c = Calendar.getInstance();
System.out.println(c);
}
}
getInstance() 原始碼:
進入 createCalendar() 方法:
Calendar 可以看作是一個抽象類. 它的實現, 採用了設計模式中的工廠方法.
當我們透過 Calendar.getInstance() 獲取日曆時, 預設的是返回的一個 GregorianCalendar 物件.
程式示例:
import java.util.Calendar;
import java.util.Date;
public class CalendarDemo2 {
public static void main(String[] args) {
/*
* public static Calendar lgetInstance() 獲取當前時間的日曆物件
* public final Date getTime() 獲取日期物件
* public final setTime(Date date) 給日曆設定日期物件
* public long getTimeInMillis() 拿到時間毫秒值
* public void setTimeInMillis(long millis) 給日曆設定時間毫秒值
* public int get(int field) 獲取日期中的某個欄位資訊
* public void set(int field,int value) 修改日曆的某個欄位資訊
* public void add(int field,int amount) 為某個欄位增加/減少指定的值
*/
// 1.獲取日曆物件
// 細節1:Calendar是一個抽象類,不能直接new,而是透過一個靜態方法獲取到子類物件
// 底層原理:
// 會根據系統的不同時區來獲取不同的日曆物件,預設表示當前時間.
// 把會把時間中的紀元,年,月,日,時,分,秒,星期,等等的都放到一個陣列當中
// 日 : 紀元
// 1 : 年
// 2 : 月
// 3 : 一年中的第幾周
// 4 : 一個月中的第幾周
// 5 : 一個月中的第幾天(日期)
// .... 一共 17 個屬性, 所以索引最大為 16
// 細節2:
// 月份:範圍0~11 如果獲取出來的是.那麼實際上是1月.
// 星期:在老外的眼裡,星期日是一週中的第一天
// 1(星期日) 2(星期一) 3(星期二) 4(星期三) 5(星期四) 6(星期五) 7(星期六)
Calendar c = Calendar.getInstance();
// 2.修改一下日曆代表的時間
Date d = new Date(0L);
c.setTime(d);
System.out.println(c);
}
}
程式示例:
import java.util.Calendar;
import java.util.Date;
public class CalendarDemo2 {
public static void main(String[] args) {
/*
* public static Calendar lgetInstance() 獲取當前時間的日曆物件
* public final Date getTime() 獲取日期物件
* public final setTime(Date date) 給日曆設定日期物件
* public long getTimeInMillis() 拿到時間毫秒值
* public void setTimeInMillis(long millis) 給日曆設定時間毫秒值
* public int get(int field) 獲取日期中的某個欄位資訊
* public void set(int field,int value) 修改日曆的某個欄位資訊
* public void add(int field,int amount) 為某個欄位增加/減少指定的值
*/
// 1.獲取日曆物件
// 細節1:Calendar是一個抽象類,不能直接new,而是透過一個靜態方法獲取到子類物件
// 底層原理:
// 會根據系統的不同時區來獲取不同的日曆物件,預設表示當前時間.
// 把會把時間中的紀元,年,月,日,時,分,秒,星期,等等的都放到一個陣列當中
// 日 : 紀元
// 1 : 年
// 2 : 月
// 3 : 一年中的第幾周
// 4 : 一個月中的第幾周
// 5 : 一個月中的第幾天(日期)
// ....
// 細節2:
// 月份:範圍0~11 如果獲取出來的是.那麼實際上是1月.
// 星期:在老外的眼裡,星期日是一週中的第一天
// 1(星期日) 2(星期一) 3(星期二) 4(星期三) 5(星期四) 6(星期五) 7(星期六)
Calendar c = Calendar.getInstance();
// puslic int get(int field) 取日期中的某個欄位資訊
// public void set(int field,int value) 修改日曆的某個欄位資訊
// public void add(int fieldint amount) 為某個欄位增加/減少指定的值
int year = c.get(1);
int month = c.get(2);
int date = c.get(5);
System.out.println(year + ", " + month + ", " + date); // 2024, 8, 19
Date d = new Date(0L);
c.setTime(d);
int year1 = c.get(1);
int month1 = c.get(2) + 1;
int date1 = c.get(5);
System.out.println(year1 + ", " + month1 + ", " + date1); // 1970, 1, 1
// java在Calendar類中,把索引對應的數字都定義成常量,
// 用數字當然也可以,但是容易忘記,閱讀性也很低,以後建議用常量,
// 常量值可以進入 Calendar 類的原始碼中檢視
int year2 = c.get(Calendar.YEAR);
int month2 = c.get(Calendar.MONTH) + 1;
int date2 = c.get(Calendar.DAY_OF_MONTH);
int week2 = c.get(Calendar.DAY_OF_WEEK);
System.out.println(year2 + "," + month2 + "," + date2 + "," + week2); // 1970,1,1,5
// 最後的數字 5 表示星期四, 但是閱讀性不強, 可以將其顯示為星期四, 將該操作放在 getWeek() 中
System.out.println(year2 + "," + month2 + "," + date2 + "," + getWeek(week2)); // 1970,1,1,星期四
}
// 查表法://表:容器
// 讓資料跟索引產生對應的關係
// 傳入對應的數字: 1 ~7//返回對應的星期
public static String getWeek(int index) {
// 定義一個陣列,讓漢字星期幾 跟1~7產生對應關係
String[] arr = {"", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
// 根據索引返回對應的星期
return arr[index];
}
}
程式示例:
import java.util.Calendar;
public class CalendarDemo2 {
public static void main(String[] args) {
/*
* public static Calendar lgetInstance() 獲取當前時間的日曆物件
* public final Date getTime() 獲取日期物件
* public final setTime(Date date) 給日曆設定日期物件
* public long getTimeInMillis() 拿到時間毫秒值
* public void setTimeInMillis(long millis) 給日曆設定時間毫秒值
* public int get(int field) 獲取日期中的某個欄位資訊
* public void set(int field,int value) 修改日曆的某個欄位資訊
* public void add(int field,int amount) 為某個欄位增加/減少指定的值
*/
// 1.獲取日曆物件
// 細節1:Calendar是一個抽象類,不能直接new,而是透過一個靜態方法獲取到子類物件
// 底層原理:
// 會根據系統的不同時區來獲取不同的日曆物件,預設表示當前時間.
// 把會把時間中的紀元,年,月,日,時,分,秒,星期,等等的都放到一個陣列當中
// 日 : 紀元
// 1 : 年
// 2 : 月
// 3 : 一年中的第幾周
// 4 : 一個月中的第幾周
// 5 : 一個月中的第幾天(日期)
// ....
// 細節2:
// 月份:範圍0~11 如果獲取出來的是.那麼實際上是1月.
// 星期:在老外的眼裡,星期日是一週中的第一天
// 1(星期日) 2(星期一) 3(星期二) 4(星期三) 5(星期四) 6(星期五) 7(星期六)
Calendar c = Calendar.getInstance();
// puslic int get(int field) 取日期中的某個欄位資訊
// public void set(int field,int value) 修改日曆的某個欄位資訊
// public void add(int fieldint amount) 為某個欄位增加/減少指定的值
c.set(Calendar.YEAR, 2023);
c.set(Calendar.MONTH, 8);
c.set(Calendar.MONTH, 12); // 月份大於11時,自動改變年份,自動向後排,此時相當於下一年的一月份
c.set(Calendar.DAY_OF_MONTH, 10);
// 呼叫方法在這個基礎上增加一個月
c.add(Calendar.MONTH, -1);
int year2 = c.get(Calendar.YEAR);
int month2 = c.get(Calendar.MONTH) + 1;
int date2 = c.get(Calendar.DAY_OF_MONTH);
int week2 = c.get(Calendar.DAY_OF_WEEK);
System.out.println(year2 + "," + month2 + "," + date2 + "," + getWeek(week2)); // 2023,12,10,星期日
}
// 查表法://表:容器
// 讓資料跟索引產生對應的關係
// 傳入對應的數字: 1 ~7//返回對應的星期
public static String getWeek(int index) {
// 定義一個陣列,讓漢字星期幾 跟1~7產生對應關係
String[] arr = {"", "星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
// 根據索引返回對應的星期
return arr[index];
}
}
JDK8 新增的時間相關類
全世界一共分為 24 個時區. 每一個時區內, 時間都是一樣的.
但是 Java 定義時區時不是按照東一區, 東二區這種方式去定義的.
在中國, Java 定義了不止一個時區: Asia/Shanghai, Asia/Taipei, Asia/Chongqing. 一般都用上海.
全世界範圍內, Java 一共定義了 600 個時區.
點選控制檯, 點選 Ctrl + F, 可以在控制檯輸出的內容中進行搜尋.
程式示例:
import java.time.ZoneId;
import java.util.Set;
public class demo1 {
public static void main(String[] args) {
/*
static Set<string> getAvailableZoneIds() 獲取Java中支援的所有時區
static ZoneId systemDefault() 獲取系統預設時區
static Zoneld of(string zoneld) 獲取一個指定時區
*/
// 1.獲取所有的時區名稱
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds.size()); // 600
System.out.println(zoneIds); // Asia/Shanghai
// 2.獲取當前系統的預設時區
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId); // Asia/Shanghai
// 3.獲取指定的時區
ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
System.out.println(zoneId1); // Asia/Pontianak
}
}
程式示例:
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class demo2 {
public static void main(String[] args) {
/*
* static Instant now() 獲取當前時間的Instant物件(標準時間)
* static Instant ofXxxx(long epochMilli) 根據(秒/毫秒/納秒)獲取Instant物件
* ZonedDateTime atZone(ZoneIdzone) 指定時區
* boolean isxxx(Instant otherInstant) 判斷系列的方法
* Instant minusXxx(long millisToSubtract) 減少時間系列的方法
* Instant plusXxx(long millisToSubtract) 增加時間系列的方法
*/
// 1.獲取當前時間的Instant物件(標準時間)
Instant now = Instant.now();
System.out.println(now);
// 2.根據(秒/毫秒/納秒)獲取Instant物件
Instant instant1 = Instant.ofEpochMilli(0L);
System.out.println(instant1);// 1970-01-01T00:00:00z
Instant instant2 = Instant.ofEpochSecond(1L);
System.out.println(instant2);// 1970-01-01T00:00:01Z
Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
System.out.println(instant3);// 1970-01-01T00:00:027
// 3. 指定時區
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);
// 4.isXxx 判斷
Instant instant4 = Instant.ofEpochMilli(0L);
Instant instant5 = Instant.ofEpochMilli(1000L);
// 5.用於時間的判斷
// isBefore:判斷呼叫者代表的時間是否在參數列示時間的前面
boolean result1 = instant4.isBefore(instant5);
System.out.println(result1);// true
// isAfter:判斷呼叫者代表的時間是否在參數列示時間的後面
boolean result2 = instant4.isAfter(instant5);
System.out.println(result2);// false
// 6.Instant minusXxx(long millisToSubtract) 減少時間系列的方法
Instant instant6 = Instant.ofEpochMilli(3000L);
System.out.println(instant6);// 1970-01-01T00:00:03Z
Instant instant7 = instant6.minusSeconds(1);
System.out.println(instant7);// 1970-01-01T00:00:02Z
}
}
程式示例:
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
public class demo3 {
public static void main(String[] args) {
/*
* static ZonedDateTime now() 獲取當前時間的ZonedDateTime物件
* static ZonedDateTime ofXxxx(. . . ) 獲取指定時間的ZonedDateTime物件
* ZonedDateTime withXxx(時間) 修改時間系列的方法
* ZonedDateTime minusXxx(時間) 減少時間系列的方法
* ZonedDateTime plusXxx(時間) 增加時間系列的方法
*/
// 1.獲取當前時間物件(帶時區)
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);
// 2.獲取指定的時間物件(帶時區)1/年月日時分秒納秒方式指定
ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));
System.out.println(time1);
// 透過Instant + 時區的方式指定獲取時間物件
Instant instant = Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);
// 3.withXxx 修改時間系列的方法
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);
// 4. 減少時間
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);
// 5.增加時間
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);
}
}
程式示例:
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
public class demo4 {
public static void main(String[] args) {
/*
* static DateTimeFormatter ofPattern(格式) 獲取格式物件
* String format(時間物件) 按照指定方式格式化
*/
// 獲取時間物件
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
// 解析/格式化器
DateTimeFormatter dtf1 = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm;ss EE a");
// 格式化
System.out.println(dtf1.format(time));
}
}
Calendar 類
程式示例:
import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.Month;
import java.time.MonthDay;
public class LocalDateDemo {
public static void main(String[] args) {
// 1.獲取當前時間的日曆物件(包含 年月日)
LocalDate nowDate = LocalDate.now();
// System.out.println("今天的日期:" + nowDate);
// 2.獲取指定的時間的日曆物件
LocalDate ldDate = LocalDate.of(2023, 1, 1);
System.out.println("指定日期:" + ldDate);
System.out.println("=============================");
// 3.get系列方法獲取日曆中的每一個屬性值//獲取年
int year = ldDate.getYear();
System.out.println("year: " + year);
// 獲取月//方式一:
Month m = ldDate.getMonth();
System.out.println(m);
System.out.println(m.getValue());
// 方式二:
int month = ldDate.getMonthValue();
System.out.println("month: " + month);
// 獲取日
int day = ldDate.getDayOfMonth();
System.out.println("day:" + day);
// 獲取一年的第幾天
int dayofYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayofYear);
// 獲取星期
DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
System.out.println(dayOfWeek);
System.out.println(dayOfWeek.getValue());
// is開頭的方法表示判斷
System.out.println(ldDate.isBefore(ldDate));
System.out.println(ldDate.isAfter(ldDate));
// with開頭的方法表示修改, 只能修改年月日
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);
// minus開頭的方法表示減少, 只能減少年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);
// plus開頭的方法表示增加, 只能增加年月日
LocalDate plusLocalDate = ldDate.plusDays(1);
System.out.println(plusLocalDate);
// -------------
// 判斷今天是否是你的生日
LocalDate birDate = LocalDate.of(2000, 1, 1);
LocalDate nowDate1 = LocalDate.now();
MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
MonthDay nowMd = MonthDay.from(nowDate1);
System.out.println("今天是你的生日嗎? " + birMd.equals(nowMd));// 今天是你的生日嗎?
}
}
程式示例:
import java.time.LocalTime;
public class LocalTimeDemo {
public static void main(String[] args) {
// 獲取本地時間的日曆物件. (包含 時分秒)
LocalTime nowTime = LocalTime.now();
System.out.println("今天的時間:" + nowTime);
int hour = nowTime.getHour();// 時
System.out.println("hour: " + hour);
int minute = nowTime.getMinute();// 分
System.out.println("minute: " + minute);
int second = nowTime.getSecond();// 秒
System.out.println("second:" + second);
int nano = nowTime.getNano();// 納秒
System.out.println("nano:" + nano);
System.out.println("------------------------------------");
System.out.println(LocalTime.of(8, 20));// 時分
System.out.println(LocalTime.of(8, 20, 30));// 時分秒
System.out.println(LocalTime.of(8, 20, 30, 150));// 時分秒納秒
LocalTime mTime = LocalTime.of(8, 20, 30, 150);
// is系列的方法
System.out.println(nowTime.isBefore(mTime));
System.out.println(nowTime.isAfter(mTime));
// with系列的方法, 只能修改時, 分, 秒
System.out.println(nowTime.withHour(10));
// plus系列的方法, 只能修改時, 分, 秒
System.out.println(nowTime.plusHours(10));
}
}
程式示例:
public class LocalDateTimeDemo {
public static void main(String[] args) {
// 當前時間的的日曆物件(包含年月日時分秒)
LocalDateTime nowDateTime = LocalDateTime.now();
System.out.println("今天是:" + nowDateTime);// 今天是:
System.out.println(nowDateTime.getYear());// 年
System.out.println(nowDateTime.getMonthValue());// 月
System.out.println(nowDateTime.getDayOfMonth());// 日
System.out.println(nowDateTime.getHour());// 時
System.out.println(nowDateTime.getMinute());// 分
System.out.println(nowDateTime.getSecond());// 秒
System.out.println(nowDateTime.getNano());// 納秒
// 日:當年的第幾天
System.out.println("dayofYear:" + nowDateTime.getDayOfYear());
// 星期
System.out.println(nowDateTime.getDayOfWeek());
System.out.println(nowDateTime.getDayOfWeek().getValue());
// 月份
System.out.println(nowDateTime.getMonth());
System.out.println(nowDateTime.getMonth().getValue());
LocalDate ld = nowDateTime.toLocalDate();
System.out.println(ld);
LocalTime lt = nowDateTime.toLocalTime();
System.out.println(lt.getHour());
System.out.println(lt.getMinute());
System.out.println(lt.getSecond());
}
}
程式示例:
import java.time.LocalDate;
import java.time.Period;
public class PeriodDemo {
public static void main(String[] args) {
// 當前本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);
// 生日的 年月日
LocalDate birthDate = LocalDate.of(2000, 1, 1);
System.out.println(birthDate);
Period period = Period.between(birthDate, today);// 第二個引數減第一個引數
System.out.println("相差的時間間隔物件:" + period);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());
System.out.println(period.toTotalMonths());
}
}
程式示例:
import java.time.Duration;
import java.time.LocalDateTime;
public class DurationDemo {
public static void main(String[] args) {
// 本地日期時間物件.
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 出生的日期時間物件
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);
Duration duration = Duration.between(birthDate, today);// 第二個引數減第一個引數
System.out.println("相差的時間間隔物件:" + duration);
System.out.println("============================================");
System.out.println(duration.toDays());// 兩個時間差的天數
System.out.println(duration.toHours());// 兩個時間差的小時數
System.out.println(duration.toMinutes());// 兩個時間差的分鐘數
System.out.println(duration.toMillis());// 兩個時間差的毫秒數
System.out.println(duration.toNanos());// 兩個時間差的納秒數
}
}
程式示例:
import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;
public class A10_ChronoUnitDemo {
public static void main(String[] args) {
// 當前時間
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 生日時間
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);
System.out.println("相差的年數:" + ChronoUnit.YEARS.between(birthDate, today));
System.out.println("相差的月數:" + ChronoUnit.MONTHS.between(birthDate, today));
System.out.println("相差的週數:" + ChronoUnit.WEEKS.between(birthDate, today));
System.out.println("相差的天數:" + ChronoUnit.DAYS.between(birthDate, today));
System.out.println("相差的時數:" + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分數:" + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒數:" + ChronoUnit.SECONDS.between(birthDate, today));
System.out.println("相差的毫秒數:" + ChronoUnit.MILLIS.between(birthDate, today));
System.out.println("相差的微秒數:" + ChronoUnit.MICROS.between(birthDate, today));
System.out.println("相差的納秒數:" + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天數:" + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年數:" + ChronoUnit.DECADES.between(birthDate, today));
System.out.println("相差的世紀(百年)數:" + ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println("相差的千年數:" + ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println("相差的紀元數:" + ChronoUnit.ERAS.between(birthDate, today));
}
}