Süre Temsili

Giriş
İki Tarih Arasındaki Fark yazısı verilen iki zaman aralığının kaç yıl, ay, hafta, gün, dakika vs. gibi birimler olarak ölçülebileceğini gösteriyor. Ölçümde kullanılan birimler kavramsal olarak "süre" kelimesiyle anlatılıyor.

Dolayısıyla programlama dilleri ve kütüphaneler süre kavramını ve çeşitli birimler cinsiden temsil edebilmek için çeşitli sınıflar sunuyorlar.

C#
TimeSpan sınıfı
TimeSpan yazısına taşıdım.

Boost
Saniye
Saniyeyi temsil etmek için boost::posixtime::seconds  sınıfı kullanılıyor. Örnek:

boost::posix_time::seconds(1)

Joda
Ay
Ayı temsil etmek için Months sınıfı kullanılıyor.

Gün
Günü temsil etmek için Days sınıfı kullanılıyor.
  
Saat
Saati temsil etmek için Hours sınıfı kullanılıyor. Hour sınıfı yaratmak için

Hours.hours(6);

yazılabilir veya Hours sınıfı içindeki static olarak önceden yaratılmış hazır Hours.ONE gibi nesneler kullanılabilir.


Dakika
Dakikayı temsil etmek için Minutes sınıfı kullanılıyor.

Milisaniye
Milisaniyeyi temsil etmek için Duration sınıfı kullanılıyor. Sınıfın açıklamasında "specifying a length of time in milliseconds." deniliyor. Duration sınıfını yaratmak için bir çok seçenek mevcut. Örnek:

Duration.millis (1000);//1000 milisaniyelik süre
Duration.standardDays (1);//1 günün milisaniye olarak süresi
Duration.standardHours (1);//1 saatin milisaniye olarak süresi

Sürenin Bir Üst Süre Cinsi ile Yazılması
Saniyenin Dakika + Saniye Olarak Gösterilmesi
Basit bir örnek:

private String secondsToString(int pTime) {
    return String.format("%02d:%02d", ptime / 60, pTime % 60);
}

İki Tarih Arasındaki Fark - Zaman Aralığı

Not : DateTime İşlemleri Yazısı çok uzun olduğu için içeriğin bir kısmını buraya taşımayı uygun buldum.
Giriş

İki tarih arasındaki fark ile zaman eksenindeki iki noktanın arasındaki mesafeyi ölçüyoruz. Bu mesafe bir çok birim cinsinden ifade edilebilir. Yıl, ay, hafta, gün, dakika vs. gibi.

İki tarih arasındaki farkı bulma amacımız bazen sadece mesafeyi ölçmek iken bazen de iki tarih aralığı arasına düşen kayıtları bulmak olabiliyor.

Bu yazının amacı verilen iki tarih arasındaki farkı yıl/ay/hafta vs gibi birimler cinsinden nasıl bulunacağını göstermek.

Ölçüm sonunda çıkan mesafeyi gösteren süre kavramı ile ilgili sınıfları Süre Temsili başlıklı yazıda bulabilirsiniz.

Aynı Saat Dilimindeki İki Tarih Arasındaki Farkı Ölçmek
C++
Yeni C++ ile chrono namespace'i içinde duration isimli bir sınıf var. Bu sınıf zaman aralığını temsil ediyor. Kullanım kolaylığı için diğer typedef'ler de aşağıdaki gibi tanımlanmış.

namespace std {
namespace chrono {
typedef duration<signed int-type >= 64 bits,nano>        nanoseconds;
typedef duration<signed int-type >= 55 bits,micro>       microseconds;
typedef duration<signed int-type >= 45 bits,milli>       milliseconds;
typedef duration<signed int-type >= 35 bits>             seconds;
typedef duration<signed int-type >= 29 bits,ratio<60>>   minutes;
typedef duration<signed int-type >= 23 bits,ratio<3600>> hours;
}
}

Typedef'e verilen ilk tip - örneğin signed int - birimin tutulacağı primitif tipi belirtir, ikinci parametre olan ratio ise küsüratlı durumlarda saniyeye göre oranı belirtir. Örnekte yarım dakika double tutulacağı için ilk parametre double, ikinci parametre toplam değerin 30 saniye olması için ( 60 * 0.5) 60 tanımlanmış.

std::chrono::duration<double,std::ratio<60>>halfAMinute(0.5);

Bir diğer örnekte ise aşağıda

std::chrono::duration<long,std::ratio<1,1000>> oneMillisecond(1);

Java
TimeUnit sınıfı kullanılabilir.

Calendar cal = Calendar.getInstance ();
cal.clear ();
cal.set (2013,Calendar.MARCH,1);
Date start = cal.getTime ();
cal.set (2013,Calendar.APRIL,1);
Date end = cal.getTime ();
long days = TimeUnit.MILLISECONDS.toDays (end.getTime () - start.getTime ());

C#
C# ile verilen iki tarih arasındaki farkı bulmak için TimeSpan sınıfı var. Bu sınıfta aralığın başlangıç ve bitiş değerleri yok sadece mesafe bilgisi var.  Yani bu sınıf sadece tick'ler ile ilgileniyor.

    DateTime pastTime = //değer ata
    TimeSpan timeSinceContact = DateTime.Now - pastTime;

    // 14 gün geçmişse
    if (timeSinceContact.Days > 14){    }

TimeSpan sınıfının en işe yarayan özelliklerinden birisi ise TotalSeconds.

Örnek:
 
boost
date sınıfı
Aşağıdaki örnekte iki tarih arasındaki gün farkı bulunuyor. boost'un date sınıfı kullanıldığı için sadece gün farkı bulunur. Saat hesabı yapılmaz.

time_duration sınıfı
Bu sınıf ile iki tarih arasında fark saat ve dakika olarak bulunabilir.
is_negative() , hours() ve minutes() metodları
Örnek:
using boost::posix_time::ptime;
const boost::posix_time::ptime utcNow = boost::posix_time::second_clock::universal_time();
const ptime localTime = boost::date_time::c_local_adjustor<ptime>::utc_to_local(utcNow);
const boost::posix_time::time_duration td = localTime - utcNow;
td.is_negative(){...}
td.hours();
td.minutes()

ticks metodu
Bir başka örnekte iki tarih arasındaki fark saniye olarak hesaplanmış. Niçin total_seconds() metodu kullanılmamış bilmiyorum.

Joda

Özet

Joda'da aynı saat dilimindeki iki tarih arasındaki farkı ölçmek için bir çok sınıf kullanılabilir. Bu sınıflar temel olarak ikiye ayrılırlar. 

1. İlk sınıf Period ismiyle anılır. Period'un bir çok alt türevi de mevcuttur. 
2. İkinci sınıf ise Duration sınıfıdır.

Duration Sınıfı Nedir?
Duration sınıfı tanım olarak süre anlamına geliyor. Başlangıç ve bitişi tanımlı olmak zorunda değil. Period'dan farklı olarak milisaniye cinsinden çalıştığı için genellikle daha kısa aralıklar - 10 dakika vs. - gibi kullanılıyor. Zaten sınıfın açıklamasında "specifying a length of time in milliseconds." deniliyor.

Joda Period Sınıfı Nedir ?
Periyod tanım olarak başlangıç ve bitişi belli olan zaman aralığı anlamına geliyor. Duration'dan farklı olarak daha uzun aralıklar için kullanılıyor. 3 gün 2 saat gibi.

Joda Period ve  Alt Türevleri

Eğer amacımız 2 gün 3 saat 10 dakika gibi bir sonuç elde etmekse Period sınıfını kullanmak gerekir. Yok amacımız sadece 2 gün bilgisini elde etmek saat,dakika bilgilerini dikkate almamak ise BaseSingleFieldPeriod sınıfından türeyen Months, Days,Hours, Minutes gibi sınıfları kullanabiliriz. Aşağıdaki sınıf hiyerarşisi bu durumu gösteriyor.



Joda Duration sınıfını Oluşturmak
Duration sınıfını oluşturmak için iki tane tarih kullanılabilir. Örnek:

DateTime startTime,endTime;
Duration d = new Duration (startTime,endTime);

Joda Period Sınıfını Oluşturmak
Period sınıfını oluşturmak için iki tane tarih kullanılabilir. Örnek :

Joda PeriodType Sınıfı

Bazen farkı bulurken belli birimleri görmek istemeyiz. Bu durumda PeriodType sınıfını aşağıdaki örnekteki  gibi kullanabiliriz.

Period p = new Period(startDate, endDate,PeriodType.standard().withSecondsRemoved().withMillisRemoved());

Bu durumda aradaki farkı saniye ve milisaniye olmadan buluruz. Period sınıfı string'e dönüşürken de bu birimler yazılmaz.
 
Joda Period Sınıfı ve hours() toStandardHours() metodları arasındaki fark
Period sınfı iki tane saate çeviren metod içeriyor. Aralarındaki fark ise bu soruda açıklanmış. Eğer iki tarih arasındaki fark bir günden büyükse hours() ile sadece saat farkını alırız, geri kalan gün ise getDays() ile alınıyor. toStandardHours() ise toplam saat farkını veriyor.

Joda PeriodFormat Sınıfı
PeriodFormat sınıfı Period sınıfını string'e çevirmek için kullanılıyor. Örnek:

DateTime sd = new DateTime(1973,1,1,0,0,0);
DateTime ed = new DateTime(1973,1,31,23,59,59);
Period p = new Period(sd,ed);
//Çıktı olarak 4 weeks, 2 days, 23 hours, 59 minutes and 59 seconds verir
System.out.println(PeriodFormat.getDefault().print(p));

Joda PeriodFormatterBuilder Sınıfı
Bu sınıfı PeriodFormat sınıfını yaratmak için kullanılıyor. Örnek olarak aşağıdaki kod parçasını buradan aldım.

PeriodFormat sınıfı ile verilen Period'u istenilen formatta yazdırma
Timer - How do I calculate the difference between two dates using Joda Time? örneğinde ise

DateTime dt = new DateTime();
DateTime twoHoursLater = dt.plusHours(2).plusMinutes(10).plusSeconds(5);
Period period = new Period(dt, twoHoursLater);
PeriodFormatterBuilder HHMMSSFormater =
        new PeriodFormatterBuilder().appendHours().
                                     appendSeparator("-").
                                     appendMinutes().
                                     appendSeparator("-").
                                     appendSeconds();
System.out.println(HHMMSSFormater.toFormatter().print(period));

PeriodFormat sınıfı ile verilen metini Period olarak okuma
Örnek:
Önce PeriodFormatBuilder kullanılarak bir PeriodFormat sınıfı oluşturuluyor ve  PeriodFormat sınıfının parse() metodu kullanılarak metin Period sınıfına çeviriliyor.

Joda SingleFieldPeriod Türevleri (İki tarih arasındaki fark)
Period ile iki tarih arasındaki farkı bir çok birim cinsinden alabiliyoruz.Eğer sadece tek bir birim cinsinden farkı öğrenmek istersek aşağıdaki sınıfları kullanabiliriz. 

Seconds
Seconds sınıfı saniye farkını bulur. Örnek:

int seconds = Seconds.secondsBetween(rightNow, targetDateTime)

Minutes
Minutes sınıfı dakika farkını bulur. Farkı bulurken time zone bilgisinin etkisiz olduğunu anlatan bu soru da oldukça bilgilendirici.

Hours
Hours sınıfı saat farkını bulur.

int hours =Hours.hoursBetween(new DateTime(today), new DateTime(StartTime1)).getHours();

Days
Days sınıfı daysBetween() metodu ile gün farkını bulur.

Bir başka örnek

Months
Örnekte iki tane tarih arasındaki fark ay cinsinden bulunuyor.
 
SQL
dobs tablosundan dob sütununu çekip sistem saatine bakarak ikisi arasındaki yılı bulan kod aşağıda.

select floor(months_between(sysdate,dob)/12) from dobs;

 

DateTime İşlemleri

Not: Bu yazı ile ilgili olarak Epoch ve API başlıklı yazıya göz atabilirsiniz.
Not2: Joda-Time başlıklı yazı mutlaka okunması gereken bir yazı


Jülyen
Jülyen takvimde bir şey yapıldığını hiç görmedim.
Joda
Jülyen tarih saat bilgisi için aşağıdaki kod kullanılabilir.

Hicri Takvim
Joda
Gregoryan ve Hicri takvim arasında dönüşüm için örnek burada.

Gregoryan Takvim
Anladığım kadarıyla Gregoryan takvim ile ISO takvim aynı şeyler.
Gregoryan Gün (Sadece Gün Bilgisi)

Gregoryan Gün Yaratma
Joda

LocalDate start = new LocalDate(2012, 05, 1);

Bu sınıf aynı boost eşleniği gibi sadece gün bilgisi içerir. Saat bilgisini içermez. Zaten yarım bilgi içerdiği için ReadablePartial arayüzünden türemiştir. Örneğin doğum günü bilgisini tutmak için kullanılabilir.How to convert an epoch date to joda times LocalDate?
sorusunda da açıklandığı gibi bu sınıfı ileri veya geri oynatabilme imkanı da mevcut.

Bir diğer önemli nokta ise bu sınıfa 1 Ocak 1970'ten önceki tarihlerin de atanabilmesi. Data type for storing a date prior to 1970-01-01 sorusuna aşağıdaki örnek verilmiş.

Boost
boost::gregorian::date sıfını sadece tarih bilgisini içerir. Saat bilgisini içermez.

bu sınıfın yıl bilgisine erişmek için year() metodu kullanılır. Örnek:

gregorian::date sınıfı bir string'de parse etme imkanı da var.

using namespace boost::gregorian;
string s("2012-01-12");
date d2 = from_string(s);

Bir başka örnek:

std::string s_date = "1922-02-29";
boost::gregorian::date d = boost::gregorian::from_date(s_date);

date_input_face ile parse etmek için örnek:

#include <iostream>
#include "boost/date_time/gregorian/gregorian.hpp"

int main(int argc, char *argv[])
{
  std::string s_date = "1922-02-28";
  std::stringstream ss(s_date);
  boost::gregorian::date_input_facet *df = new boost::gregorian::date_input_facet("%Y-%m-%d");
  ss.imbue(std::locale(ss.getloc(), df));
  date d;
  ss>>d;
  std::cout<<d<<std::endl;
}

gregorian::date sınıfını verilen tarih için yaratma imkanı da bulunmakta.

using namespace boost::gregorian;
date d(2002,Jan,10);

Eğer verilen tarih geçersiz ise std::out_of_range exception'ı atılır.

 boost::gregorian::date_period sınıfı iki date arasındaki zamanı temsil etmek için kullanılır. Aşağıdaki örnekte gösterildiği gibi iki gün arasındaki farkı bulmak için kullanılabilir.

date_period dp(date(2002,Jan,1),
               days(2));
dp.length() --> 2

QT

QT ile gelen QDate sınıfı Gregoryan gün işlemleri için kullanılabilir

Gregoryan Gün ve Saat Yaratma
Joda
LocalDateTime sınıfı ile saat dilimi bilgisi içermeyen bir nesne yaratılır.
   

Verilen İki Günü Karşılaştırma

Boost
İki günü karşılaştırmak için "<", ">" operatörleri kullanılabilir. Örnek

SQL
MySQL ile verilen bir güne ait kayıtları çekmek mümkün. Örnek'te DATE_ADD fonksiyonu yerine INTERVAL kullanılmış:

Yerel Saat (Sadece Saat)

Geceyarısından Beri Geçen Saniyeyi Zamana Çevirme

Joda

Bir başka örnek ise

LocalTime localTime = new LocalTime(13, 30, 26, 0);// 1:30:26PM

Eğer DateTime nesnesinin sadece saat kısmını almak istiyorsak DateTime.toLocalTime() metodu da kullanılabilir.

QT
QT ile gelen QTime sınıfı sadece saat işlemleri için kullanılabilir.

Geceyarısından Beri Geçen Milisaniyeyi Bulma

Joda
JodaTime Get Current Milliseconds From Beginning Of Day başlıklı soruda geceyarısından beri geçen milisaniyeyi hesaplamak için şöyle bir cevap var.

long result = new DateTime().millisOfDay().getMillis(); 

Tarih ve Saat İşlemleri

Belli Tarihi Atama
boost

ptime t4(date(2002,May,31), hours(20));  

Joda
Buradaki soruda DateTime sınıfının aşağıdaki constructor metodu kullanılarak belli bir tarih atanabileceği gösterilmiş. Eğer verilen tarih hatalı ise IllegalFieldValueException atılıyor.

DateTime dt = new DateTime(2012, 2, 12, 0, 0); // 12 Şubat 2012 gece yarısı

Bu soruda ise withDate ile belli bir tarih atanabileceği gösterilmiş.

Gece Yarısını Atama
Java

Calendar cal = Calendar.getInstance();
//şu anı al
cal.setTime(new Date());

// Set time fields to zero 
cal.set(Calendar.HOUR_OF_DAY, 0);
cal.set(Calendar.MINUTE, 0);
cal.set(Calendar.SECOND, 0);
cal.set(Calendar.MILLISECOND, 0);

Joda
DateMidnight kullanılabilir.

DateMidnight midnight = DateMidnight.now ();

Aşağıdaki örneklerde gece yarısını bulmak için başka yöntemler de gösteriliyor.

DateTime d;//
d.toDateMidnight();//DateMidnight

d.withTimeAtStartOfDay();//DateTime

Verilen Tarihin Saat Başını Alma

boost
Örneği buradan aldım.

boost::posix_time::ptime now= boost::posix_time::second_clock::local_time();

year_ = now.date().year();
month_ = now.date().month();
day_ = now.date().day();
hours_= now.time_of_day().hours();

Java
Java: getMinutes and getHours başlıklı soruda açıklanıyor.

Joda

Joda ile getHourOfDay() metodu kullanılarak verilen DateTime sınıfının saat başı öğrenilebilir.

Verilen TarihinYılın Kaçıncı Haftası Olduğunu Alma

Joda
Joda getWeekYear() metodu kullanılarak verilen DateTime sınıfının yılın kaçıncı haftası olduğu öğrenilebilir. Representing week of year with jodatime sorusuna da bakılabilir.

calculate weeks for one month in jodatime sorusuna da bakılabilir.

Verilen Tarihin Haftanın Kaçıncı Günü Olduğunu Alma

Hafta günleri Pazar'dan ve 1 sayısından başla.
Java
Calendar sınıfının get(Calendar.DAY_OF_WEEK) metodu ile haftanın kaçıncı günü olduğu bulunabilir. Örnek'te Aralık 2012'de 5 tane Pazar, Pazartes, ve Cumartesi günü olduğu kontrol ediliyor. 
Joda
Joda getDayOfWeek() metoduyla bu yapılabilir.

1 <= time.getDayOfWeek() && time.getDayOfWeek() <= 5 //Pazartesi ve Cuma arasında

Eğer haftanın kaçın günü olduğunu metin olarak almak istersek aşağıdaki gibi yapabiliriz.

Verilen Tarihin 1,2,3,4. Pazar gününü bulma
Java
Joda Time: Get first/second/last sunday of month sorusunda Java ile örnek var.

Joda
Joda - How to find “Second Thursday of Month”  sorusunda yukarıdakine benzer bir örnek var. Her iki çözümde de önce withDayOfMonth() ile ay başına gidiliyor. Daha sonra ise withDayOfWeek ile istenilen gün atanıyor. 

int year = 2012;
int month = 1;
int day = 1;
LocalDate start = new LocalDate(year, month, day);
LocalDate date = start.withDayOfMonth(1).withDayOfWeek(4);
date = (date.isBefore(start)) ? date.plusWeeks(2) : date.plusWeeks(1);

Verilen Tarihi İleri Alma
Boost
Örneği buradan aldım.

using namespace boost::posix_time;
ptime start = second_clock::local_time();
ptime end = start + minutes(4)+seconds(2);  

Java

Java'da tarih hesaplaması için her zaman Calendar arayüzü kullanılır. Calendar arayüzünü gerçekleştiriren takvim ise GregorianCalendar sınıfıdır.

Calendar calendar = new GregorianCalendar(); calendar.add(Calendar.DAY_OF_MONTH, 30);

Verilen tarihi ileri alırken, calendar.set(Calendar.DAY_OF_WEEK, Calendar.SUNDAY); şeklindeki kullanım tarihi bir sonraki pazar gününe ilerletmek zorunda değil!

C#
c#: whats the easiest way to subtract time? sorusundaki örnekte de açıklandığı gibi aşağıdaki şekilde yapılabilir.

Apache Commons

DateUtils sınıfı yukarıdaki Java ile yapılan işlemleri zaten yapan bir sınıf. addXXX() gibi metodları kullanması oldukça kolay.

Joda

Joda ile gelen DateTime sınıfı değiştirilemez ancak ekle çıkartma yapılarak yeni bir sınıf elde edilebiliyor.

DateTime d2 = new DateTime().plusDays(30);

Aşağıdaki örnekte DateTime sınıfının aynı String gibi değiştirilemez olduğu gösterilmiş.

Bir başka örnek ise saati ileri alırken dakikayı da atamak

 DateTime d2 = new DateTime().plusHours(1).withMinuteOfHour (0);//Saati ileri al,dakikayı ata

Joda ile gelen MutableDateTime sınıfı setter() metodlara sahip olduğu için değiştirilebiliyor.

Bir başka örnek:


Joda'nın aşağıdaki yapısını bilmek faydalı.

C
Bu dil ile tarih hesaplaması yapmak çok zor ancak Addition some interval to tm structs başlıklı yazıda struct tm veri yapısını ileri bir tarihe almak için standart matematik işlemleri ve mktime() metodunun kullanılması öneriliyor.
mktime() metodu tarih/saat normalizasyonu yaptığı için bu işlemin çalıştığı söyleniyor.

Verilen Tarihi Tatile Denk Gelmeyecek Şekilde İleri Alma
Bu da çözülmesi gıcık problemlerden birisi.
Joda
joda time - add weekdays to date sorusunda aşağıdaki çözüm önerilmiş

addDays(DateTime dateTime, int days) {
    for(int i=0;i<days;i++){
        dateTime.plusDays(1);
        if(dateTime.getDayOfWeek()==6)
            dateTime.plusDays(2); // if Saturday add 2 more days
    }
}

 
Verilen Tarihi Geri Alma
Boost

Java

Java'da tarih hesaplaması için her zaman Calendar arayüzü kullanılır. Calendar arayüzünü gerçekleştiriren takvim ise GregorianCalendar sınıfıdır.

Calendar calendar = new GregorianCalendar();

calendar.add(Calendar.DATE, -1);

Bir başka alternatif ise yaz saati uygulamasını dikkate almadan direkt milisaniyeleri çıkartmaktır.

Date date = new Date(System.currentTimeMillis() - 24 * 60 * 60 * 1000L);

Joda

LocalDate today = LocalDate.now();
LocalDate yesterday = today.minus(Period.days(1));

Eğer istenirse bir DateTime nesnesinden milisaniye de çıkarılabilir. Why does JodaTime's DateTime class have a minusMillis() method? sorusu minus(long) ile minusMillis(int) arasındaki farkı açıklıyor.

C#

DateTime.Now.AddMinutes (-1); veya DateTime.Now.AddSeconds (-6);

Buradaki örnekte geçen cuma ve ondan önceki 6 cuma daha bulunuyor.

SQL
Örnekte verilen tarihi geri alma gösteriliyor.
 
Verilen Tarihi İleri/Geri Alma ve Yaz/Kış Saati Açıklaması
Java
Bu konuyu açıklayan bir yazı da Java's java.util.Calendar başlıklı yazı da var.
Calendar ile tarihi ileri alırken Yaz/Kış saati değişimi de dikkate alınır. Örneğin 

cal.add( Calendar.DAY_OF_YEAR, 1 );

kodunda How to offset Date to adjust to DST in Java sorusunda açıklandığı gibi 24 saat değil hesaplama yapılarak gerekirse 23 saat eklenir.


Verilen İki Tarihi Karşılaştırma
Java
Date sınıfını compareTo metodu kullanılabilir. Örnek :

Joda
Joda ile saat dilimi değil "an" karşılaştırılır. Aşağıdaki örnekte aynı olan iki an saat dilimleri farklı olsa bile hep false dönerler.
DateTime estDT = new DateTime(DateTimeZone.forID("America/Puerto_Rico")).withMillisOfSecond(0);
DateTime londonDT = new DateTime(DateTimeZone.forID("Europe/London")).withMillisOfSecond(0);
System.out.println("Comparison " + londonDT.isBefore(estDT));//false
System.out.println("Comparison " + londonDT.isAfter(estDT)); //false


isAfter ile > kontrolü yapılıyor.

isBefore ile < kontrolü yapılıyor. 

<= kontrolü için !after kontrolü yapılmalı.

>= komtrolü için !before kontrolü yapılmalı.

>= ve <= içinse aşağıdaki gibi yapılabilir.
 
isBeforeNow örneğinde verilen tarihin şu andan önce olup olmadığı kontrol ediliyor

isAfterNow ile verilen tarihin şu andan sonra olup olmadığı kontrol ediliyor.

equals ile verilen iki tarihin aynı olup olmadığı kontrol ediliyor.

while (weekday.isBefore(end) || weekday.equals(end))

Periyod İle İşlemler (İki tarih arasındaki fark)
Bu kısım çok uzun olduğu için İki Tarih Arasındaki Fark başlıklı yazıya taşıdım.

Duration İşlemleri
Duration tanım olarak başlangıç ve bitişi olmayan süre anlamına geliyor. Yani elapsed time difference. 2 saat 3 dakika gibi. Aslında Türkçe'de "her 2 dakikalık periyotta bir" gibi bir cümle kurarsak mana olarak doğru ancak Joda dilinde Duration sınıfına denk geliyor.

Apache
DurationFormatUtils ile verilen süreyi String olarak formatlama imkanı var.

//Çıktı olarak 23546_15:26:40.000 verir
return DurationFormatUtils.formatDuration(2034430000000L,"dd_HH:mm:ss.SSS");

Joda Duration
Duration sınıfı da iki tarih arasındaki farkı bulmak için kullanılabilir. Yalnız bu sınıf sadece milisaniye cinsinden çalışıyor. How to compare Joda DateTime objects with acceptable offset (tolerance)? sorusunda iki Duration nesnesini karşılaştırma örneği verilmiş.

Bir başka örnekte ise iki tarih arasındaki farkın 30 dakikadan az olduğu kontrolü yapılmış.

Boost

Boost ile diğer zaman birimlerini de temsil etme imkanı var. Örneğin 10 mikrosaniyeyi temsil etmek için:

boost::posix_time::time_duration fractionalSeconds(0, 0, 0,10);

unix timestamp to boost::posix_time::ptime sorusuna göz atmak ta faydalı olabilir.
Interval İle İşlemler
Interval tanım olarak başlangıç ve bitiş zamanı belli olan aralık anlamına geliyor. Saat 8 ve 10 arası gibi.
Joda Interval
Interval yaratmak için örnek:

// Now
DateTime dt = new DateTime();

// Now plus three years and a half
DateTime plusDuration = dt.plus(new Duration(110376000000L));

// Define and calculate the interval of time
Interval interval = new Interval(dt.getMillis(), plusDuration.getMillis());

Interval'ı String'den parse etmek için örnek:

Burada Interval ile ISO 8601 stringi parse etme konusu açıklanmış.
 
TimeStamp'ten Çevirme

C++

Yeni C++ ile gelen duration sınıfı da bu iş için kullanılabilir.

typedef std::chrono::duration<double, std::ratio<1>> d_seconds;
d_seconds since_epoch_full(324324.342);

How to convert a fractional epoch timestamp (double) to an std::chrono::time_point? sorusuna göz atmak ta faydalı olabilir.
Joda
Converting Unix timestamp to String with Joda Time sorusunda da açıklandığı gibi Unix Timestamp değerleri saniye cinsinden tutuluyor. Eğer bunu Joda DateTime nesnesine çevirmek istiyorsak aşağıdaki gibi saniyeyi milisaniyeye çevirmemiz lazım.


Saat Dilimi ile Çalışma
Saat dilimlerinin listelenmesinde farklı veritabanları kullanılıyor. Bunlardan en popüler olanı tz database,
diğer ismiyle Olson database. Ancak her yazılım bu veritabanı ile uyumlu değil, örneğin Microsoft kendi veritabanını kullanıyor.
 
Saat dilimi ile çalışmaya başlamadan önce saat dilimi ile System.currentTimeMillis() metodu arasındaki ilişkiyi anlamak lazım.

Java
Saat dilimini temsil eden sınıf TimeZone. Türkiyedeki saat diliminin ismini almak için aşağıdaki kod kullanılabilir.

TimeZone.getDefault().getDisplayName(); // Eastern European Time verir

Bir başka örnekte ise default saat dilimini atama gösteriliyor.

TimeZone.setDefault(TimeZone.getTimeZone("Etc/UTC")); //veya
TimeZone.setDefault(TimeZone.getTimeZone("UTC"));

Aşağıdaki örneği buradan changeTimezone metodundan aldım. Verilen bir Timestamp nesnesini bir başka saat dilimine göre çeviriyor. Bu örneğin JDBC sunucusunda ne işe yaradığını bilmiyorum. Bence JDBC sunucusu bu çevirim işini yapmamalı.

TimeZone fromTz = //
TimeZone toTz = //
Timestamp tstamp = //

Calendar fromCal = Calendar.getInstance(fromTz);
fromCal.setTime(tstamp);

int fromOffset = fromCal.get(Calendar.ZONE_OFFSET)   + fromCal.get(Calendar.DST_OFFSET);
Calendar toCal = Calendar.getInstance(toTz);
toCal.setTime(tstamp);

int toOffset = toCal.get(Calendar.ZONE_OFFSET) + toCal.get(Calendar.DST_OFFSET);
int offsetDiff = toOffset - fromOffset;
long toTime = toCal.getTime().getTime();
toTime += offsetDiff;

Timestamp changedTimestamp = new Timestamp JavaDoc(toTime);

return changedTimestamp;

Aşağıdaki örnekte verilen string saat dilimine göre parse ediliyor.

 
TimeZone sınıfı ile saat diliminin kaç dakikalık farka sahip olduğunu hesaplama kodunu buradan aldım.

Timezone tz = TimeZone.getTimeZone("Europe/Oslo");
tz.getOffset(new Date().getTime()) / 1000 / 60;   //yields +120 minutes

Joda
Saat dilimini temsil etmek için DateTimeZone sınıfı kullanılıyor. Joda tarafından desteklenen saat dilimilerini burada bulabilirsiniz.

DateTimeZone.getDefault(); 

Bu sınıfı TimeZone sınıfını kullanarak yaratmak için aşağıdaki kod kullanılabilir.

TimeZone javaZone = TimeZone.getDefault();
DateTimeZone jodaTimezone = DateTimeZone.forTimeZone(javaZone);

Eğer verilen saat diliminin Joda tarafından tanınıp tanınmadığını bilmek istiyorsak aşağıdaki gibi yapabiliriz.

boolean valid = DateTimeZone.getAvailableIDs().contains(id);

UTC Saatini Yerel Saate Çevirme
boost
local_date_time sınıfı ile yapılıyor. Örnek:
 
Yerel Saati Bir Başka Saat Dilimindeki Zamana Çevirme

boost
Aşağıdaki örnekte yerel saat bir başka saat dilimine çeviriliyor. Çevrim için boost::date_time::local_adjustor sınıfına yerel saat diliminin GMT -5 olduğu söyleniyor.

#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/date_time/local_time_adjustor.hpp>
#include <iostream>

using namespace boost::posix_time;
using namespace boost::date_time ;

int main (void) {
   ptime now = second_clock::local_time();
   ptime adjUSDST = local_adjustor<ptime, -5, us_dst>::utc_to_local(now);
   ptime adjNODST = local_adjustor<ptime, -5, no_dst>::utc_to_local(now);
   std::cout << "now: " << now << std::endl;
   std::cout << "adjUSDST: " << adjUSDST << std::endl;
   std::cout << "adjNODST: " << adjNODST << std::endl;
   return 0;
}

   Java

//Japonyadaki saate çevir
Calendar japanCal = Calendar.getInstance(TimeZone.getTimeZone("Japan"));
japanCal.setTimeInMillis(Calendar.getInstance().getTimeInMillis());

Bir başka örnekte ise Calendar kullanmadan çevirme örneği var.

Date currentTime = new Date();
      
DateFormat ausFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");
ausFormat.setTimeZone(TimeZone.getTimeZone("Australia/Melbourne"));

//get the time string in australian timezone
String ausTime  = ausFormat.format(currentTime);

Joda
Joda ile gelen DateTime sınıfı eğer yaratılırken bir saat dilimi atanarak yaratılmaz ise sistemin saat dilimini esas alır. JodaTime-Passing a string directly to DateTime's constructor sorusunda da açıklandığı gibi bu durumda verilen saatin başka bir saat dilimine ait olduğunu tesbit ederse verilen saat yerel saat dilimine uyacak şekilde ileriye veya geriye alarak değiştirir. Yani içinde tuttuğu milisaniye miktarını değiştirir. Dolayısıyla DateTime sınıfı her zaman saat diliminden haberdardır.

Yine buradaki soruda da withYear, withXXX() metodları ile verilen rakamları da milisaniyeye çevirirken ileri veya geri alabileceği anlatılmış.

Aşağıdaki test kodunda ZonedChronology sınıfının verilen değeri UTC olarak kabul ettiği ve yerel saate göre uyarladığı net bir şekilde görülebiliyor.

Joda Time - different between timezones sorusunda yerel saati bir başka saat dilimine çevirmek için withZone metodu kullanılmış.

Buradaki örnekte saati dilimi tutulsa bile verilen milisaniye değerinin hep aynı olduğu gösteriliyor.

 
Direkt olarak bir başka zaman dilimine ait saat yaratmak için ise DateTime(DateTimeZone zone) constructor kullanılabilir.

DateTimeZone sınıfını yaratmak için bir çok metod var. Bunlar forID(), forOffsetHours() gibi metodlar olabilir.

Bir başka örnekte ise DateTime(long instant, DateTimeZone zone) constructor kullanılıyor.
ya da bu örnekte olduğu gibi 

// (GMT -1) 23/10/2010 23:00:00 
DateTime dateTime = new DateTime(2010, 10, 23, 23, 0, 0, 0, DateTimeZone.forOffsetHours(-1));  DateTime inAnotheTimeZone = dateTime.withZone(DateTimeZone.forOffsetHours(1));

olabilir. Bu şekil kullanımda artık yeni nesnenin saati dilimi yaratılırken verildiği için saati ileri geri alma olmaz.
Yaz Saati Uygulaması
Joda
Her saat dilimi yaz saatini desteklemez. Örneğin GTM saat diliminde yaz saati uygulaması yoktur. Örnek:

TimeZone zone = TimeZone.getTimeZone("GMT");
zone.useDaylightTime();//false döner

Saat Dilimleri Arasındaki Süre Farkı
Boost
Örnekte UTC ile yerel saat arasındaki fark bulunmuş.

using namespace boost::posix_time;
using namespace boost::gregorian;

time_duration UTC_Diff;
{
    ptime someUTC_Time(date(2008, Jan, 1), time_duration(0, 0, 0, 0));
    ptime someLocalTime = boost::date_time::c_local_adjustor::utc_to_local(someUTC_Time);
    UTC_Diff = someLocalTime - someUTC_Time;
}

Buradaki örnekte ise UTC  ile yerel saat arasındaki fark bulunmuş ve +02:00 gibi string olarak gösterilmiş.

Buradaki örnekte benzer bir şekilde UTC ile yerel saat arasındaki fark bulunmuş.

c_local_adjustor sınıfının açıklması ise burada. UTC zamanı yerel zaman çeviriyor.

boost::date_time::c_local_adjustor uses the C-API to adjust a moment given in utc to the same moment in the local time zone. 

Joda
Buradaki örnekte saat dilimleri arasındaki süre farkını bulmak için aşağıdaki örnek verilmiş.

DateTime nowHere = DateTime.now();
DateTime nowZur = nowHere.withZone(DateTimeZone.forID("Europe/Zurich"));
Period per=new Period(nowHere.toLocalDateTime(),nowZur.toLocalDateTime());
System.out.println(per.toStandardSeconds().getSeconds());

------------------------------------YAZMA İŞLEMLERİ-------------------------------------------------
ISO 8601 formatında yazma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.

Belirsiz bir formatta yazma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.

-------------------------------------OKUMA İŞLEMLERİ-----------------------------------------------
ISO 8601 formatında okuma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.

Belirsiz bir formatta okuma
Konuyu DateTime'ı String Olarak Okuma ve Yazma İşlemleri başlıklı yazıya taşıdım.
 
DateTimeFormat ve Thread Safety

Java
DateFormat ve SimpleDateFormat sınıfları thread-safe değil.Java'daki Date sınıfı saat dilimi ve gösterim bilgisini bilmez. Sadece Epoch'tan beri geçen süreyi tutan sabit bir sınıf gibi düşünülebilir. Bu durum anladığım kadarıyla C#'ta da aynı.

Joda
Joda ile parse ve print işlemleri için DatetimeFormat sınıfı kullanılıyor ve bu sınıf thread-safe. 
 
Karşılaştığım bazı zaman formatları
Bu konuyu not almak istedim çünkü envai çeşit zaman formatı var.

Gün/Saat ve Saat Dilimi alanı örnekleri

"2010-10-03T16:58:07.000+02:00" : Burada tek dikkat edilmesi gereken bu saatin yerel saati göstermesi ve gün/saat bilgisi arasındaki T harfi ve saat dilimi alanı. Bu bilgi yerel saatin 16:58:07 olduğunu milisaniyenin değerinin de 000 olduğunu ve yerel saatin GMT'den 2 saat önde olduğunu bildiriyor.

"Tue, 14 Aug 2012 07:26:33 +0000" : Bu saat yukarıdaki ile aynı bilgileri gösteriyor. Tek fark gün isminin de yazılı olması. Bu saati parse etmek için "EEE, dd MMM yyyy HH:mm:ss Z" formatı kullanılabilir. 

ISO 8601 ile duration P harfi ile başlar. Örneğin P10Y 10 sene anlamına gelmektedir.

Locale İşlemleri
Java
SimpleDateFormat(pattern,Locale) metodu kullanılarak farklı bir dilde formatlama yapmak mümkün. Örnek:

Sabit Değerler
Joda
Joda ile gelen DateTimeConstants sınıfı bir çok sabit değeri içeriyor.