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.

DateTime'ı String Olarak Okuma ve Yazma İşlemleri

Not : DateTime İşlemleri başlıklı yazıya göz atabilirsiniz.

ISO 8601 formatında yazma

Joda
Joda zaten ISO 8601 formatında çalışmak üzere tasarlandığı için bu işlem çok kolay. DateTimeFormatter sınıfını yaratan 3 tane factory sınıftan birisi olan ISODateTimeFormat sınıfını kullanmak yeterli.

//Çıktı olarak : bugünün tarihi olan 2012-05-08T08:48:02.332+03:00 alırız

DateTime dt = new DateTime();
DateTimeFormatter fmt = ISODateTimeFormat.dateTime();
String str = fmt.print(dt);

Eğer istenirse DateTimeFormatter DateTime sınıfının toString() metoduna da geçilebiliyor. Örnek:

DateTimeFormatter formatter = DateTimeFormat.forPattern("MM/dd/yyyy");
DateTime dateTime = new DateTime();
dateTime.toString(formatter);

Boost
to_iso_extended_string veya to_iso_string() metodları ile verilen nesne stringe çevirilebilir.

//Çıktı olarak 2011-08-02 alırız.

Belirsiz bir formatta yazma

Joda

String dateFormat = ("MM/dd/yyyy");
DateTime date;
String formattedDate = DateTimeFormat.forPattern(dateFormat).print(date);

Aşağıda DateTimeFormat sınıfının kullanım ile ilgili daha detaylı bilgi var.

SQL
Oracle Date veri tipini kendi bildiği bir yapıda saklıyor.

 Bu yapıyı istediğimiz bir şekle çevirmek için TO_CHAR metodunu kullanırız. Örnek:

-------------------------------------OKUMA İŞLEMLERİ-----------------------------------------------
ISO 8601 formatında okuma
ISO8601 tarihleri standartlaştırıyor. Aşağıdaki şekilde görülebilir.

ISO8601 basic ve extended format olarak kullanılabiliyor. Basic formatta arada hiç ayraç yokken, extended formatta tarih alanları arasında "-" , zaman alanları arasında ise ":" işareti kullanılıyor. Saniyeden ile milisaniye arasında ise "." ayracı var. Tarih ve zaman alanları arasındaki T işareti ise opsiyonel.

Bu standart ile 3 türlü gösterim şekli var. Bildiğimiz takvim gösterimi, Yılın kaçıncı günü gösterimi (Ordinal), Yılın kaçıncı haftası gösterimi (Week). Aşağıdaki şekildeki tarihlerin hepsi aynı zamanı gösteriyor.

Boost
date
Date sınıfının from_simple_string metodu ISO8601 formatında günleri okuyabiliyor. Örnek:

ptime
Boost ile gelen from_iso_string() metodu ile delimeter kullanmayan stringleri okuyup tekrar zamana çevirebilme imkanı var.

//Çıktı olarak 2012-Sep-27 06:23:39 verir 
std::cout << boost::posix_time::from_iso_string("20120927T062339");

time_from_string metodu ile de delimeter kullanan stringi okuma imkanı var. Örnek:

iso_extended_string formatında okuma işlemini ise buradan aldım. boost'un time_input_facet sınıfının set_iso_extended_format metodu ile belirtilen formatta okuma yapılabiliyor.

Joda

Eğer timezone UTC ise aşağıdaki gibi parse edebiliriz.

DateTimeFormatter formatter = ISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC);
DateTime datetime = formatter.parseDateTime(dateAsString); 

Bir başka örnekte ise 

DateTime.parse("2012-08-16T07:22:05Z") //UTC saat dilimindeki ISO8601 saat örneği

yukarıdaki ile aynı işlemi yapar.


Yalnız yukarıdaki örneklerde verilen saat kendi saat dilimimize göre çevirilir.
Eğer çevirilme yapılmasın isteniyorsa aşağıdaki gibi yapılabilir.

val date1 = formatter.withOffsetParsed().parseDateTime("2012-01-03T00:00:00Z");

veya

val formatter = ISODateTimeFormat.dateTimeNoMillis
val date1 = formatter.withZone(DateTimeZone.UTC).parseDateTime("2012-01-03T00:00:00Z")

Eğer parse işlemi başarısız olursa IllegalArgumentException atılır.

ISO 8601'in başka formatları da vardır. Örneğin ISO week date (xxxx-'W'ww-e yani  2006-W52-7) veya sadece date (yyyy-MM-dd yani 1981-04-05) gibi. Bu tür stringleri parse etmek için aşağıdaki örnek kullanılabilir.

Belirsiz bir formatta okuma
boost
boost ile gelen boost::gregorian::date_input_facet ve boost::posix_time::time_input_facet sınıflarını kullanarak  date veya datetime okuma imkanı var.

Örnek:
boost'un time_input_facet sınıfı ile belirtilen formatta okuma yapılabiliyor.

Bir başka örnek:

  

Örneği buradan aldım.

 
Java
Formatlama işleme için kullanılan parametrelerin görevleri aşağıdaki gibi.
Gün İçin
dd : Ayın kaçıncı günü olduğunu okur örneğin 08-AUG-12 12.00.00 AM için dd 08 kısmını okumak için kullanılır.
DD : Yılın kaçıncı günü olduğunu okur

EEE :  Günün harf olarak kısaltılmış halini okur. Örneğin İngilizce locale kullanılıyorsa "Sun" gibi
Ay için
MMM : Ayın harf olarak kısaltılmış halini okur. Örneğin İngilizce locale kullanılıyorsa "Dec" gibi
MM : Ayın rakam olarak girilmiş halini okur
Yıl İçin
yyyy : Yılı okur
yy :  Yılı 19xx olarak okur. 12 rakamı için 2012 yerine 1912'yı bulur. Kullanılmasını tavsiye etmem.
Saat İçin
hh : AM/PM formatında saati okur. Saat değeri 1-12 arasındadır.
HH : 24 saat formatında saati okur. Saat değeri 0-23 arasındadır.
aa : AM/PM kısmını okur
Dakika İçin
mm : Dakikayı okur
Saniye İçin
ss : Saniyeyi okur
Milisaniye İçin
SSS: Milisaniyeyi okur
Saat Dilimi İçin
z : Saat dilimi kısmını okur. Saat dilimlerine isim verilir.
Z : RFC 822 formatında saat dilimi. Bu formatta saat dilimi -0700 şeklinde gösterilir.

Java ile SimpleDateFormat sınıfı bu işi hallediyor.

DateFormat dateFormat = new SimpleDateFormat("E M d HH:mm:ss z yyyy");
Date date = dateFormat.parse("Thu Jun 07 13:01:59 IST 2007");

Bir başka örnekte eğer istenirse kullanılan tarih deseni applyPattern() metodu ile değiştirilebiliyor.

Apache Commons
DateUtils sınıfının parseDate veya parseDateStrictly metodları kullanılarak, formatını hiç bilmediğimiz bir stringi bir format dizisi vererek, okumak mümkün.

Joda ve DateTimeFormat.forPattern
Aşağıdaki örnek ISO 8601 ile aynı olmasına rağmen elle parse ediliyor.

String date = "2010-10-03T16:58:07.000+02:00";
DateTimeFormatter formatter = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
DateTime dateTime = formatter.parseDateTime(date);

Burada dikkat edilmesi gereken nokta DateTimeFormat sınıfına "dd.MM.yyyy" verilse bile yıl alanına 4 haneli yıl yerine iki haneli yıl girilse bile doğru parse ediyor. Örneği yıla 12 girilirse yılı 2012 yerine direk olan M.S. 12 gibi algılıyor.

Bir başka örnek ise

String date = "Sun, 20 May 2012 01:07:11 +0000";
DateTimeFormatter formatter = DateTimeFormat.forPattern("EEE, dd MMM YYYY HH:mm:ss Z");
DateTime dateTime = formatter.parseDateTime(date);

Joda ve DateTimeFormatter.patternForStyle
Buradaki soruda anlatıldığı gibi patternForStyle metodu ile  locale'e göre Short,Medium,Long,Full deseni bulunabilir.

Joda ve DateTimeFormatter.withOffsetParsed
DateTimeFormatter.parseDateTime() metodu verilen string'i yerel saat dilimine çevirir. Ancak çevirmesin istiyorsak withOffsetParsed() ile kullanabiliriz. Örnek:

DateTimeFormatter dfOne = DateTimeFormat.forPattern("EEE MMM dd HH:mm:ss 'GMT'Z yyyy");

//Yerel saate çevirir
//Mon Mar 16 04:10:40 GMT+0530 2009DateTime dateTime1 = dfOne.parseDateTime("Mon Mar 16 8:40:40 GMT+1000 2009");

//Yerel saate çevirmez
//Mon Mar 16 08:40:40 GMT+1000 2009DateTime dateTime3 = dfOne.withOffsetParsed().parseDateTime("Mon Mar 16 8:40:40 GMT+1000 2009");

 
Joda ve DateTimeFormatterBuilder
Android using Joda time to calculate diference between dates başlıklı soruda DateTimeFormatterBuilder kullanımına bir örnek var.

 Bir başka örnek ise

QT

QDate fixDate = QDate::fromString ("27092012", "ddMMyyyy");

C#
DateTime.ParseExact ile istenilen formatta okuma yapılabilir. Örnek:

DateTime date = DateTime.ParseExact(txtDate.Text, "dd-MM-yyyy HH:mm:ss", CultureInfo.InvariantCulture); 

Bir başka örnekte ise

DateTime a = DateTime.ParseExact("2013-Jan-31", "yyyy-MMM-dd", CultureInfo.InvariantCulture);

DateTime.TryParseExact metodu ise birden çok formatta okuma işlemini yapabilmeyi sağlar.

DateTime sınıfı da aynı QT'deki gibi Date ve Time olarak ayrı ayrı property'lere ayrılabilir.