Joda-Time 學習筆記

一 Jode-Time 介紹

任何企業應用程序都需要處理時間問題。應用程序需要知道當前的時間點和下一個時間點，有時它們還必須計算這兩個
時間點之間的路徑。使用 JDK 完成這項任務將非常痛苦和繁瑣。
既然無法擺脫時間，為何不設法簡化時間處理？現在來看看 Joda Time，一個面向 Java™ 平台的易於
使用的開源時間/日期庫。正如您在本文中了解的那樣，JodaTime輕松化解了處理日期和時間的痛苦和繁瑣。

Joda-Time 令時間和日期值變得易於管理、操作和理解。事實上，易於使用是 Joda 的主要設計目標。其他目標包括可擴展性、完整的特性集以及對多種日歷系統的支持。
並且 Joda 與 JDK 是百分之百可互操作的，因此您無需替換所有 Java 代碼，只需要替換執行日期/時間計算的那部分代碼。
Joda-Time提供了一組Java類包用於處理包括ISO8601標准在內的date和time。可以利用它把JDK Date和Calendar類完全替換掉，而且仍然能夠提供很好的集成。

為什么要使用 Joda？
考慮創建一個用時間表示的某個隨意的時刻 — 比如，2000 年 1 月 1 日 0 時 0 分。
我如何創建一個用時間表示這個瞬間的 JDK 對象？使用 java.util.Date？
事實上這是行不通的，因為自 JDK 1.1 之后的每個 Java 版本的 Javadoc 都聲明應當使用 java.util.Calendar。
Date 中不贊成使用的構造函數的數量嚴重限制了您創建此類對象的途徑。

那么 Calendar 又如何呢？我將使用下面的方式創建必需的實例：

Calendar calendar = Calendar.getInstance();
calendar.set(2000, Calendar.JANUARY, 1, 0, 0, 0);

使用 Joda，代碼應該類似如下所示：

DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, 0);

這一行簡單代碼沒有太大的區別。但是現在我將使問題稍微復雜化。
假設我希望在這個日期上加上 90 天並輸出結果。使用 JDK，我需要使用清單 1 中的代碼：

// 以 JDK 的方式向某一個瞬間加上 90 天並輸出結果
Calendar calendar = Calendar.getInstance();
calendar.set(2000, Calendar.JANUARY, 1, 0, 0, 0);
SimpleDateFormat sdf =
new SimpleDateFormat("E MM/dd/yyyy HH:mm:ss.SSS");
calendar.add(Calendar.DAY_OF_MONTH, 90);
System.out.println(sdf.format(calendar.getTime()));

// 以 Joda 的方式向某一個瞬間加上 90 天並輸出結果
DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, 0);
System.out.println(dateTime.plusDays(90).toString("E MM/dd/yyyy HH:mm:ss.SSS");

兩者之間的差距拉大了（Joda 用了兩行代碼，JDK 則是 5 行代碼）。
現在假設我希望輸出這樣一個日期：距離 2000.1.1日 45 天之后的某天在下一個月的當前周的最后一天的日期。
坦白地說，我甚至不想使用 Calendar 處理這個問題。
使用 JDK 實在太痛苦了，即使是簡單的日期計算，比如上面這個計算。
正是多年前的這樣一個時刻，我第一次領略到 JodaTime的強大。使用 Joda，用於計算的代碼所示：

DateTime dateTime = new DateTime(2000, 1, 1, 0, 0, 0, 0);
System.out.println(dateTime.plusDays(45).plusMonths(1).dayOfWeek()
.withMaximumValue().toString("E MM/dd/yyyy HH:mm:ss.SSS");

輸出為：
Sun 03/19/2000 00:00:00.000

如果您正在尋找一種易於使用的方式替代 JDK 日期處理，那么您真的應該考慮 Joda。

 

二 創建Joda-Time對象

 現在，我將展示在采用該庫時會經常遇到的一些 Joda 類，並展示如何創建這些類的實例。

ReadableInstant
Joda 通過 ReadableInstant 類實現了瞬間性這一概念。表示時間上的不可變瞬間的 Joda 類都屬於這個類的子類。
（將這個類命名為ReadOnlyInstant 可能更好，我認為這才是設計者需要傳達的意思）。
換句話說，ReadableInstant 表示時間上的某一個不可修改的瞬間。
其中的兩個子類分別為 DateTime 和 DateMidnight：

DateTime：這是最常用的一個類。它以毫秒級的精度封裝時間上的某個瞬間時刻。
DateTime 始終與 DateTimeZone 相關，如果您不指定它的話，它將被默認設置為運行代碼的機器所在的時區。
可以使用多種方式構建 DateTime 對象。這個構造函數使用系統時間：

DateTime dateTime = new DateTime();

如果您創建了一個 DateTime 的實例，並且沒有提供 Chronology 或 DateTimeZone，Joda將使用 ISOChronology（默認）和DateTimeZone（來自系統設置）

Joda 可以使您精確地控制創建 DateTime 對象的方式，該對象表示時間上的某個特定的瞬間。

DateTime dateTime = new DateTime(
2000, //year
1, // month
1, // day
0, // hour (midnight is zero)
0, // minute
0, // second
0 // milliseconds
);

下一個構造函數將指定從 epoch（1970年1月1日 子時 格林威治標准時間） 到某個時刻所經過的毫秒數。
它根據 JDK Date 對象的毫秒值創建一個DateTime 對象，其時間精度用毫秒表示，因為 epoch 與 Joda 是相同的：

java.util.Date jdkDate = new Date();
long timeInMillis = jdkDate.getTime();
DateTime dateTime = new DateTime(timeInMillis);

或者Date 對象直接傳遞給構造函數:

dateTime = new DateTime(new Date());

Joda 支持使用許多其他對象作為構造函數的參數，用於創建 DateTime:

// Use a Calendar
  dateTime = new DateTime(calendar);

  // Use another Joda DateTime
  dateTime = new DateTime(anotherDateTime);

  // Use a String (must be formatted properly)
  String timeString = "2006-01-26T13:30:00-06:00";
  dateTime = new DateTime(timeString);
  timeString = "2006-01-26";
  dateTime = new DateTime(timeString);

注意，如果您准備使用 String（必須經過解析），您必須對其進行精確地格式化。

DateMidnight：這個類封裝某個時區（通常為默認時區）在特定年/月/日的午夜時分的時刻。
它基本上類似於 DateTime，不同之處在於時間部分總是為與該對象關聯的特定 DateTimeZone 時區的午夜時分。

 

ReadablePartial
應用程序所需處理的日期問題並不全部都與時間上的某個完整時刻有關，因此您可以處理一個局部時刻。
例如，有時您比較關心年/月/日，或者一天中的時間，甚至是一周中的某天。Joda 設計者使用ReadablePartial 接口捕捉這種表示局部時間的概念，
這是一個不可變的局部時間片段。用於處理這種時間片段的兩個有用類分別為 LocalDate 和 LocalTime：

LocalDate：該類封裝了一個年/月/日的組合。當地理位置（即時區）變得不重要時，使用它存儲日期將非常方便。
例如，某個特定對象的出生日期 可能為 1999 年 4 月 16 日，但是從技術角度來看，
在保存所有業務值的同時不會了解有關此日期的任何其他信息（比如這是一周中的星期幾，或者這個人出生地所在的時區）。
在這種情況下，應當使用 LocalDate。

LocalTime：這個類封裝一天中的某個時間，當地理位置不重要的情況下，可以使用這個類來只存儲一天當中的某個時間。
例如，晚上 11:52 可能是一天當中的一個重要時刻（比如，一個 cron 任務將啟動，它將備份文件系統的某個部分），
但是這個時間並沒有特定於某一天，因此我不需要了解有關這一時刻的其他信息。

 

創建對象代碼：

package com.jt.joda;

import java.util.Date;

import org.joda.time.DateTime;
import org.joda.time.LocalDate;
import org.joda.time.LocalTime;
import org.junit.Test;

public class Demo {

    @Test
    public void test1(){
        
        //方法一：取系統點間  
        DateTime dt1 = new DateTime();  
        System.out.println(dt1);
          
        //方法二：通過java.util.Date對象生成  
        DateTime dt2 = new DateTime(new Date());  
        System.out.println(dt2);
        
        //方法三：指定年月日點分秒生成(參數依次是：年,月,日,時,分,秒,毫秒)  
        DateTime dt3 = new DateTime(2012, 5, 20, 13, 14, 0, 0);  
        System.out.println(dt3); 
        //方法四：ISO8601形式生成  
        DateTime dt4 = new DateTime("2012-05-20"); 
        System.out.println(dt4);
        DateTime dt5 = new DateTime("2012-05-20T13:14:00");  
        System.out.println(dt5);
          
        //只需要年月日的時候  
        LocalDate localDate = new LocalDate(2009, 9, 6);// September 6, 2009  
        System.out.println(localDate);
        
        //只需要時分秒毫秒的時候  
        LocalTime localTime = new LocalTime(13, 30, 26, 0);// 1:30:26PM  
        System.out.println(localTime);

    }
/*    
    2015-09-25T17:51:12.900+08:00
    2015-09-25T17:51:12.977+08:00
    2012-05-20T13:14:00.000+08:00
    2012-05-20T00:00:00.000+08:00
    2012-05-20T13:14:00.000+08:00
    2009-09-06
    13:30:26.000
*/
    
}

 

三 與JDK日期對象轉換

許多代碼都使用了 JDK Date 和 Calendar 類。但是幸虧有 Joda，可以執行任何必要的日期算法，然后再轉換回 JDK 類。
這將兩者的優點集中到一起。您在本文中看到的所有 Joda 類都可以從 JDK Calendar 或 Date 創建，正如您在 創建 JodaTime對象 中看到的那樣。
出於同樣的原因，可以從您所見過的任何 Joda 類創建 JDK Calendar 或 Date。

1.    DateTime dt = new DateTime();  
2.      
3.    //轉換成java.util.Date對象  
4.    Date d1 = new Date(dt.getMillis());  
5.    Date d2 = dt.toDate();  
6.      
7.    //轉換成java.util.Calendar對象  
8.    Calendar c1 = Calendar.getInstance();  
9.    c1.setTimeInMillis(dt.getMillis());  
10.   Calendar c2 = dt.toCalendar(Locale.getDefault()); 

對於 ReadablePartial 子類，您還需要經過額外一步，如所示：

1 Date date = localDate.toDateMidnight().toDate();

要創建 Date 對象，您必須首先將它轉換為一個 DateMidnight 對象，然后只需要將 DateMidnight 對象作為 Date。
（當然，產生的 Date 對象將把它自己的時間部分設置為午夜時刻）。
JDK 互操作性被內置到 Joda API 中，因此您無需全部替換自己的接口，如果它們被綁定到 JDK 的話。比
如，您可以使用 Joda 完成復雜的部分，然后使用 JDK 處理接口。

 

四 日期計算

現在，您已經了解了如何創建一些非常有用的 Joda 類，我將向您展示如何使用它們執行日期計算。

假設在當前的系統日期下，我希望計算上一個月的最后一天。對於這個例子，我並不關心一天中的時間，因為我只需要獲得年/月/日，如所示：

LocalDate now = SystemFactory.getClock().getLocalDate();
LocalDate lastDayOfPreviousMonth = now.minusMonths(1).dayOfMonth().withMaximumValue();

首先，我從當前月份減去一個月，得到 “上一個月”。
接着，我要求獲得 dayOfMonth 的最大值，它使我得到這個月的最后一天。
注意，這些調用被連接到一起（注意 Joda ReadableInstant 子類是不可變的），這樣您只需要捕捉調用鏈中最后一個方法的結果，從而獲得整個計算的結果。

您可能對dayOfMonth() 調用感興趣。這在 Joda 中被稱為屬性（property）。它相當於 Java對象的屬性。
屬性是根據所表示的常見結構命名的，並且它被用於訪問這個結構，用於完成計算目的。
屬性是實現 Joda 計算威力的關鍵。您目前所見到的所有 4 個 Joda 類都具有這樣的屬性。一些例子包括：
yearOfCentury
dayOfYear
monthOfYear
dayOfMonth
dayOfWeek

假設您希望獲得任何一年中的第 11 月的第一個星期二的日期，而這天必須是在這個月的第一個星期一之后。

LocalDate now = SystemFactory.getClock().getLocalDate();
LocalDate electionDate = now.monthOfYear()
.setCopy(11) // November
.dayOfMonth() // Access Day Of Month Property
.withMinimumValue() // Get its minimum value
.plusDays(6) // Add 6 days
.dayOfWeek() // Access Day Of Week Property
.setCopy("Monday") // Set to Monday (it will round down)
.plusDays(1); // Gives us Tuesday

.setCopy("Monday") 是整個計算的關鍵。不管中間LocalDate 值是多少，將其 dayOfWeek 屬性設置為 Monday 總是能夠四舍五入，
這樣的話，在每月的開始再加上 6 天就能夠讓您得到第一個星期一。再加上一天就得到第一個星期二。Joda 使得執行此類計算變得非常容易。

 

下面是其他一些因為使用 Joda 而變得超級簡單的計算：

1.	DateTime dt = new DateTime();  
2.	  
3.	//昨天  
4.	DateTime yesterday = dt.minusDays(1);         
5.	//明天  
6.	DateTime tomorrow = dt.plusDays(1);       
7.	//1個月前  
8.	DateTime before1month = dt.minusMonths(1);        
9.	//3個月后  
10.	DateTime after3month = dt.plusMonths(3);          
11.	//2年前  
12.	DateTime before2year = dt.minusYears(2);          
13.	//5年后  
14.	DateTime after5year = dt.plusYears(5); 

　　

五 格式化時間

使用 JDK 格式化日期以實現打印是完全可以的，但是我始終認為它應該更簡單一些。
這是 Joda 設計者進行了改進的另一個特性。要格式化一個 Joda 對象，調用它的 toString() 方法，
並且如果您願意的話，傳遞一個標准的 ISO8601或一個 JDK 兼容的控制字符串，以告訴 JDK 如何執行格式化。
不需要創建單獨的 SimpleDateFormat 對象
（但是 Joda 的確為那些喜歡自找麻煩的人提供了一個DateTimeFormatter 類）。
調用 Joda 對象的 toString() 方法，僅此而已。

dateTime.toString(ISODateTimeFormat.basicDateTime());
dateTime.toString(ISODateTimeFormat.basicDateTimeNoMillis());
dateTime.toString(ISODateTimeFormat.basicOrdinalDateTime());
dateTime.toString(ISODateTimeFormat.basicWeekDateTime());

20090906T080000.000-0500
20090906T080000-0500
2009249T080000.000-0500
2009W367T080000.000-0500

 

DateTime dateTime = DateTime.now();
dateTime.toString("MM/dd/yyyy hh:mm:ss.SSSa");
dateTime.toString("dd-MM-yyyy HH:mm:ss");
dateTime.toString("EEEE dd MMMM, yyyy HH:mm:ssa");
dateTime.toString("MM/dd/yyyy HH:mm ZZZZ");
dateTime.toString("MM/dd/yyyy HH:mm Z");

09/06/2009 02:30:00.000PM
06-Sep-2009 14:30:00
Sunday 06 September, 2009 14:30:00PM
09/06/2009 14:30 America/Chicago
09/06/2009 14:30 -0500

結束語

談到日期處理，Joda 是一種令人驚奇的高效工具。無論您是計算日期、打印日期，或是解析日期，Joda都將是工具箱中的便捷工具。
在本文中，我首先介紹了 Joda，它可以作為 JDK 日期/時間庫的替代選擇。然后介紹了一些 Joda 概念，以及如何使用 Joda 執行日期計算和格式化。

六 使用代碼案例

2、獲取年月日點分秒 
1.	DateTime dt = new DateTime();  
2.	//年  
3.	int year = dt.getYear();  
4.	//月  
5.	int month = dt.getMonthOfYear();  
6.	//日  
7.	int day = dt.getDayOfMonth();  
8.	//星期  
9.	int week = dt.getDayOfWeek();  
10.	//點  
11.	int hour = dt.getHourOfDay();  
12.	//分  
13.	int min = dt.getMinuteOfHour();  
14.	//秒  
15.	int sec = dt.getSecondOfMinute();  
16.	//毫秒  
17.	int msec = dt.getMillisOfSecond();  


3 星期的特殊處理 

dt.getDayOfWeek()

1.	DateTime dt = new DateTime();  
2.	  
3.	//星期  
4.	switch(dt.getDayOfWeek()) {  
5.	case DateTimeConstants.SUNDAY:  
6.	    System.out.println("星期日");  
7.	    break;  
8.	case DateTimeConstants.MONDAY:  
9.	    System.out.println("星期一");  
10.	    break;  
11.	case DateTimeConstants.TUESDAY:  
12.	    System.out.println("星期二");  
13.	    break;  
14.	case DateTimeConstants.WEDNESDAY:  
15.	    System.out.println("星期三");  
16.	    break;  
17.	case DateTimeConstants.THURSDAY:  
18.	    System.out.println("星期四");  
19.	    break;  
20.	case DateTimeConstants.FRIDAY:  
21.	    System.out.println("星期五");  
22.	    break;  
23.	case DateTimeConstants.SATURDAY:  
24.	    System.out.println("星期六");  
25.	    break;  
26.	}  


4、與JDK日期對象的轉換 
1.	DateTime dt = new DateTime();  
2.	  
3.	//轉換成java.util.Date對象  
4.	Date d1 = new Date(dt.getMillis());  
5.	Date d2 = dt.toDate();  
6.	  
7.	//轉換成java.util.Calendar對象  
8.	Calendar c1 = Calendar.getInstance();  
9.	c1.setTimeInMillis(dt.getMillis());  
10.	Calendar c2 = dt.toCalendar(Locale.getDefault()); 

5、日期前后推算 

1.	DateTime dt = new DateTime();  
2.	  
3.	//昨天  
4.	DateTime yesterday = dt.minusDays(1);         
5.	//明天  
6.	DateTime tomorrow = dt.plusDays(1);       
7.	//1個月前  
8.	DateTime before1month = dt.minusMonths(1);        
9.	//3個月后  
10.	DateTime after3month = dt.plusMonths(3);          
11.	//2年前  
12.	DateTime before2year = dt.minusYears(2);          
13.	//5年后  
14.	DateTime after5year = dt.plusYears(5);  


6、取特殊日期 

1.	DateTime dt = new DateTime();     
2.	  
3.	//月末日期    
4.	DateTime lastday = dt.dayOfMonth().withMaximumValue();  
5.	  
6.	//90天后那周的周一  
7.	DateTime firstday = dt.plusDays(90).dayOfWeek().withMinimumValue();  


7、時區 

1.	//默認設置為日本時間  
2.	DateTimeZone.setDefault(DateTimeZone.forID("Asia/Tokyo"));  
3.	DateTime dt1 = new DateTime();  
4.	  
5.	//倫敦時間  
6.	DateTime dt2 = new DateTime(DateTimeZone.forID("Europe/London"));  

8、計算區間 

1.	DateTime begin = new DateTime("2012-02-01");  
2.	DateTime end = new DateTime("2012-05-01");  
3.	  
4.	//計算區間毫秒數  
5.	Duration d = new Duration(begin, end);  
6.	long time = d.getMillis();  
7.	  
8.	//計算區間天數  
9.	Period p = new Period(begin, end, PeriodType.days());  
10.	int days = p.getDays();  
11.	  
12.	//計算特定日期是否在該區間內  
13.	Interval i = new Interval(begin, end);  
14.	boolean contained = i.contains(new DateTime("2012-03-01"));  


9、日期比較 

1.	DateTime d1 = new DateTime("2012-02-01");  
2.	DateTime d2 = new DateTime("2012-05-01");  
3.	  
4.	//和系統時間比  
5.	boolean b1 = d1.isAfterNow();  
6.	boolean b2 = d1.isBeforeNow();  
7.	boolean b3 = d1.isEqualNow();  
8.	  
9.	//和其他日期比  
10.	boolean f1 = d1.isAfter(d2);  
11.	boolean f2 = d1.isBefore(d2);  
12.	boolean f3 = d1.isEqual(d2);  


10、格式化輸出 

1.	DateTime dateTime = new DateTime();  
2.	  
3.	String s1 = dateTime.toString("yyyy/MM/dd hh:mm:ss.SSSa");  
4.	String s2 = dateTime.toString("yyyy-MM-dd HH:mm:ss");  
5.	String s3 = dateTime.toString("EEEE dd MMMM, yyyy HH:mm:ssa");  
6.	String s4 = dateTime.toString("yyyy/MM/dd HH:mm ZZZZ");  
7.	String s5 = dateTime.toString("yyyy/MM/dd HH:mm Z");  

　

案例：

    public static DateTime getNowWeekMonday() {
        DateTime date = DateTime.now();
        int dayOfWeek = date.getDayOfWeek();
        return DateTime.parse(date.minusDays(dayOfWeek - 1).toString("yyyy-MM-dd"));
    }

 private static final String DATE_FORMAT = "yyyy-MM-dd";

    //每周一0點0分0秒觸發，處理上上周
    @Scheduled(cron = "0 0 0 ? * MON ")
    public void weeklyRemind() {
        logger.info("CyclePendingReminderTask.weeklyRemind");
        logger.info("周期性待處理提醒任務開始");
        String now = DateTime.now().toString(DATE_FORMAT);
        //往前推2周，上上周周一
        String from = DateTime.parse(now, ISODateTimeFormat.dateElementParser())
                .minusWeeks(2).toString(DATE_FORMAT);
        //上上周周日
        String to = DateTime.parse(from, ISODateTimeFormat.dateElementParser())
                .plusWeeks(1).minusDays(1).toString(DATE_FORMAT);
        //上上周周一0點時間戳
        long fromTime = DateTime.parse(from, ISODateTimeFormat.dateElementParser()).getMillis();
        //上周周一0點時間戳
        long toTime = DateTime.parse(to, ISODateTimeFormat.dateElementParser()).plus(1).getMillis();
        List<String> userIdList = ideaService.getUserIdList();
        for (String userId : userIdList) {
            List<Idea> ideaList = ideaService.findIdeasByCreateAt(userId, fromTime, toTime);
            //有創建想法才會有提醒
            if (ideaList.size() > 0) {
                CyclePendingIdeaReminder reminder = new CyclePendingIdeaReminder();
                reminder.setUserId(userId);
                reminder.setFrom(from);
                reminder.setTo(to);
                reminder.setFinished(false);
                cpiReminderService.save(reminder);
            }
        }
        logger.info("周期性待處理提醒任務完成");
    }

    //每月一號0點0分0秒觸發
    //當中再判斷當前月份進行季度和年度的處理操作
    @Scheduled(cron = "0 0 0 1 * ? ")
    public void monthlySelectionRemind() {
        logger.info("IdeaSelectionReminderTask monthlySelectionRemind start.");
        DateTime nowTime = DateTime.now();
        int month = nowTime.getMonthOfYear();
        String now = nowTime.toString(DATE_FORMAT);
        //年度處理:  1
        if (month == 1) {
            logger.info("年度精選任務開始");
            String from = DateTime.parse(now, ISODateTimeFormat.dateElementParser())
                .minusYears(1).toString(DATE_FORMAT);
            String to = DateTime.parse(now, ISODateTimeFormat.dateElementParser())
                .minusDays(1).toString(DATE_FORMAT);
            doMonthly(from, to, OriginalityType.year);
            logger.info("年度精選任務完成");
        }
        //季度處理： 3(4)  6(7)  9(10)  12(1)
        if (month == 4 || month == 7 || month == 10 || month == 1) {
            logger.info("季度精選任務開始");
            String from = DateTime.parse(now, ISODateTimeFormat.dateElementParser())
                    .minusMonths(3).toString(DATE_FORMAT);
            String to = DateTime.parse(now, ISODateTimeFormat.dateElementParser())
                    .minusDays(1).toString(DATE_FORMAT);
            doMonthly(from, to, OriginalityType.quarter);
            logger.info("季度精選任務完成");
        }
        //月份處理
        logger.info("月精選任務開始");
        String from = DateTime.parse(now, ISODateTimeFormat.dateElementParser())
                .minusMonths(1).toString(DATE_FORMAT);
        String to = DateTime.parse(now, ISODateTimeFormat.dateElementParser())
                .minusDays(1).toString(DATE_FORMAT);
        doMonthly(from, to, OriginalityType.month);
        logger.info("月精選任務完成");
        logger.info("IdeaSelectionReminderTask monthlySelectionRemind finish.");
    }

 

// 今日凌晨
Date date = DateTime.parse(DateTime.now().toString("yyyy-MM-dd")).toDate()

// 今天9點對應的日期
Date date = DateTime.parse(DateTime.now().toString("yyyy-MM-dd")).hourOfDay().addToCopy(9).toDate();  

// 當前時間加1分鍾
Date date = DateTime.now().minuteOfHour().addToCopy(1)).toDate()