ආයුබෝවන්, Java කෝඩර්ස්ලා!

කොහොමද ඉතින් ඔක්කොටම? ගොඩක් දවස්කින් අලුත් දෙයක් ගැන කතා කරන්න අවස්ථාවක් ලැබුණා. අද අපි කතා කරන්න යන්නේ Java development වලදී අපිට නිතරම වගේ මුහුණ දෙන්න වෙන, ඒ වගේම සමහර වෙලාවට හුඟක් අවුල් සහගත වෙන්න පුළුවන් මාතෘකාවක් ගැන – ඒ තමයි Dates and Times, විශේෂයෙන්ම Java 8 එක්ක ආපු අලුත්ම java.time API එක ගැන.

කලින් Java වල තිබ්බ java.util.Date සහ java.util.Calendar කියන classes දෙක පාවිච්චි කරලා dates සහ times manage කරන එක හරිම අමාරු වැඩක්. ඕවගෙ තිබ්බ issues ගොඩයි – mutable වීම, thread-safe නැතිවීම, confusing API එක, ඒ වගේම time zone conversions වලදී ඇතිවෙන headache එක, මේ හැමදේම developersලට ලොකු හිසරදයක් වුණා. අර දවස් තිහේ මාසෙට දවස් තිස්එකක් දාන කේස් එහෙම ආවම අයියෝ කියල හිතෙනවනෙ නේද?

ඒත් Java 8 එක්ක ආපු java.time package එක මේ හැම ප්‍රශ්නයකටම කදිම විසඳුමක් දුන්නා. මේක Joda-Time library එකේ inspiration එකෙන් හදපු, හුඟක් පහසු, thread-safe, immutable වගේම clear API එකක්. අද මේ article එකෙන් අපි මේ අලුත් API එකේ basics ටිකක් explore කරමු. වැඩේ ලේසියි, බය වෙන්න එපා!

1. LocalDate: දින වකවානු සමඟ වැඩ කිරීම (Working with Dates)

මුලින්ම අපි බලමු LocalDate කියන class එක ගැන. නමෙන්ම කියවෙනවා වගේ, මේකෙන් අපිට date එකක් (year, month, day) represent කරන්න පුළුවන්, වෙලාව (time) හෝ time zone එකක් නැතුව. ඒ කියන්නේ 2023-10-27 වගේ නිකංම නිකං date එකක් විතරයි.

LocalDate පාවිච්චි කරන්නේ කොහොමද?

දැනට තියෙන date එක ගන්න නම් මෙහෙම ලියන්න පුළුවන්:

import java.time.LocalDate;

public class DateExamples {
    public static void main(String[] args) {
        // දැනට තියෙන date එක ගන්න
        LocalDate today = LocalDate.now();
        System.out.println("අද දවස: " + today);

        // අපි කැමති date එකක් හදාගන්න
        LocalDate birthday = LocalDate.of(1990, 5, 15);
        System.out.println("මගේ උපන් දිනය: " + birthday);

        // String එකකින් date එකක් parse කරන්න (ISO 8601 format)
        LocalDate specificDate = LocalDate.parse("2024-01-20");
        System.out.println("විශේෂ දවසක්: " + specificDate);
    }
}

LocalDate objects immutable නිසා, මොනවා හරි වෙනස්කම් කරනකොට අලුත් object එකක් return කරනවා. මේක thread-safe විදිහට වැඩ කරන්න හුඟක් වැදගත්.

Dates Modify කිරීම

දවස්, මාස, අවුරුදු add කරන්න, අඩු කරන්න, ඒ වගේම date එකක specific කොටසක් වෙනස් කරන්න LocalDate වලට methods තියෙනවා:

import java.time.DayOfWeek;
import java.time.LocalDate;

public class DateModificationExamples {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();

        // දවස් 5ක් එකතු කරන්න
        LocalDate futureDate = today.plusDays(5);
        System.out.println("දවස් 5කින් පසු: " + futureDate);

        // මාස 2ක් අඩු කරන්න
        LocalDate pastDate = today.minusMonths(2);
        System.out.println("මාස 2කට පෙර: " + pastDate);

        // අවුරුදු 10ක් එකතු කරන්න
        LocalDate tenYearsLater = today.plusYears(10);
        System.out.println("අවුරුදු 10කින්: " + tenYearsLater);

        // Date එකේ Year එක වෙනස් කරන්න
        LocalDate newYear = today.withYear(2025);
        System.out.println("අලුත් අවුරුද්දක්: " + newYear);

        // මාසය, දවස ගන්න
        int year = today.getYear();
        int month = today.getMonthValue();
        int day = today.getDayOfMonth();
        DayOfWeek dayOfWeek = today.getDayOfWeek();
        System.out.println("අද අවුරුද්ද: " + year + ", මාසය: " + month + ", දිනය: " + day + ", සතියේ දවස: " + dayOfWeek);

        // Dates Compare කරන්න
        LocalDate date1 = LocalDate.of(2023, 10, 26);
        LocalDate date2 = LocalDate.of(2023, 10, 27);

        System.out.println("date1 is before date2: " + date1.isBefore(date2));
        System.out.println("date1 is after date2: " + date1.isAfter(date2));
        System.out.println("date1 is equal to date2: " + date1.isEqual(date2));
    }
}

2. LocalTime: වෙලාව සමඟ වැඩ කිරීම (Working with Time)

LocalTime කියන්නේ LocalDate වගේමයි, හැබැයි මේකෙන් වෙලාව (hours, minutes, seconds, nanoseconds) විතරක් represent කරනවා, date එක හෝ time zone එකක් නැතුව. උදාහරණයක් විදිහට 14:30:15 වගේ වෙලාවක්.

LocalTime පාවිච්චි කරන්නේ කොහොමද?

import java.time.LocalTime;

public class TimeExamples {
    public static void main(String[] args) {
        // දැනට තියෙන වෙලාව ගන්න
        LocalTime now = LocalTime.now();
        System.out.println("දැන් වෙලාව: " + now);

        // අපි කැමති වෙලාවක් හදාගන්න (පැය, මිනිත්තු)
        LocalTime meetingTime = LocalTime.of(9, 30);
        System.out.println("ਮੀটিং එකේ වෙලාව: " + meetingTime);

        // පැය, මිනිත්තු, තප්පර
        LocalTime lunchTime = LocalTime.of(12, 0, 0);
        System.out.println("ලන්ච් ටයිම්: " + lunchTime);

        // String එකකින් time එකක් parse කරන්න
        LocalTime specificTime = LocalTime.parse("17:45:30");
        System.out.println("විශේෂ වෙලාවක්: " + specificTime);
    }
}

Times Modify කිරීම

import java.time.LocalTime;

public class TimeModificationExamples {
    public static void main(String[] args) {
        LocalTime now = LocalTime.now();

        // පැය 2ක් එකතු කරන්න
        LocalTime futureTime = now.plusHours(2);
        System.out.println("පැය 2කින් පසු: " + futureTime);

        // මිනිත්තු 30ක් අඩු කරන්න
        LocalTime pastTime = now.minusMinutes(30);
        System.out.println("මිනිත්තු 30කට පෙර: " + pastTime);

        // තප්පර, මිලි තප්පර ගන්න
        int hour = now.getHour();
        int minute = now.getMinute();
        int second = now.getSecond();
        System.out.println("පැය: " + hour + ", මිනිත්තු: " + minute + ", තප්පර: " + second);

        // Times Compare කරන්න
        LocalTime time1 = LocalTime.of(10, 0);
        LocalTime time2 = LocalTime.of(12, 30);
        System.out.println("time1 is before time2: " + time1.isBefore(time2));
    }
}

3. LocalDateTime: දින සහ වෙලාව එකට (Date and Time Together)

දැන් අපි බලමු LocalDateTime කියන class එක. මේක LocalDate එකයි LocalTime එකයි එකතු කරලා හදපුවා වගේ. ඒ කියන්නේ date එකයි time එකයි දෙකම එකට තියෙනවා, හැබැයි time zone එකක් නැතුව. 2023-10-27T14:30:15 වගේ දෙයක්.

LocalDateTime පාවිච්චි කරන්නේ කොහොමද?

import java.time.LocalDateTime;

public class DateTimeExamples {
    public static void main(String[] args) {
        // දැනට තියෙන date සහ time එක ගන්න
        LocalDateTime now = LocalDateTime.now();
        System.out.println("දැන් date/time එක: " + now);

        // අපි කැමති date සහ time එකක් හදාගන්න
        LocalDateTime projectDeadline = LocalDateTime.of(2024, 12, 31, 23, 59, 59);
        System.out.println("ප්‍රොජෙක්ට් ඩෙඩ්ලයින්: " + projectDeadline);

        // String එකකින් parse කරන්න
        LocalDateTime eventTime = LocalDateTime.parse("2023-11-15T18:00:00");
        System.out.println("ඊවන්ට් එකේ වෙලාව: " + eventTime);

        // LocalDate සහ LocalTime වලින් එකතු කරන්න
        // LocalDate today = LocalDate.now();
        // LocalTime currentTime = LocalTime.now();
        // LocalDateTime combinedDateTime = LocalDateTime.of(today, currentTime);
        // System.out.println("එකතු කළ date/time: " + combinedDateTime);
    }
}

LocalDateTime වලත් LocalDate සහ LocalTime වල වගේම plus..., minus..., with... වගේ methods තියෙනවා date සහ time manipulate කරන්න. ඒ වගේම get... methods පාවිච්චි කරලා date සහ time components ගන්නත් පුළුවන්.

4. ZonedDateTime: කාල කලාප සමඟ (With Time Zones)

දැන් අපි එනවා ගොඩක් වැදගත් කොටසකට – ZonedDateTime. Local Date/Time objects වලට time zone information එකක් නැහැ. ඒත් real-world applications වලදී, විශේෂයෙන්ම international applications වලදී, time zones manage කරන එක හුඟක් වැදගත්. ZonedDateTime එකෙන් date එකක්, time එකක්, ඒ වගේම time zone එකක් (e.g., 'America/New_York', 'Asia/Colombo') represent කරනවා.

ZonedDateTime පාවිච්චි කරන්නේ කොහොමද?

import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.LocalDateTime;

public class ZonedTimeExamples {
    public static void main(String[] args) {
        // දැනට තියෙන time zone එකේ ZonedDateTime එක ගන්න
        ZonedDateTime nowInColombo = ZonedDateTime.now(ZoneId.of("Asia/Colombo"));
        System.out.println("කොළඹ දැන් වෙලාව: " + nowInColombo);

        // London time zone එකේ ZonedDateTime එක ගන්න
        ZonedDateTime nowInLondon = ZonedDateTime.now(ZoneId.of("Europe/London"));
        System.out.println("ලන්ඩන් දැන් වෙලාව: " + nowInLondon);

        // LocalDateTime එකක් ZoneId එකකට convert කරන්න
        LocalDateTime ldt = LocalDateTime.of(2023, 10, 27, 10, 0);
        ZoneId colomboZone = ZoneId.of("Asia/Colombo");
        ZonedDateTime zdtInColombo = ZonedDateTime.of(ldt, colomboZone);
        System.out.println("කොළඹ 2023-10-27 10:00:00: " + zdtInColombo);

        // Time zones අතර convert කරන්න
        ZoneId newYorkZone = ZoneId.of("America/New_York");
        ZonedDateTime zdtInNewYork = zdtInColombo.withZoneSameInstant(newYorkZone);
        System.out.println("ඒකම New York වල: " + zdtInNewYork);

        // Available time zones බලන්න
        // Set<String> allZoneIds = ZoneId.getAvailableZoneIds();
        // System.out.println("සියලුම Time Zones: " + allZoneIds);
    }
}

withZoneSameInstant() කියන method එක හුඟක් වැදගත්. මේකෙන් කරන්නේ absolute time එක maintain කරගෙන, time zone එක විතරක් වෙනස් කරන එක. ඒ කියන්නේ ලංකාවේ උදේ 10ට meeting එකක් තිබ්බොත්, New York වලට ඒ වෙලාව කීයද කියල මේකෙන් බලාගන්න පුළුවන්. ඒක නියමයි නේද?

5. Dates සහ Times Formatting කිරීම (DateTimeFormatter)

අවසාන වශයෙන්, අපි බලමු මේ dates සහ times අපිට ඕන විදිහට format කරගන්නේ කොහොමද කියලා. java.time.format.DateTimeFormatter class එකෙන් අපිට custom patterns පාවිච්චි කරලා date/time strings හදාගන්නත්, parse කරන්නත් පුළුවන්.

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;

public class FormattingExamples {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        LocalDateTime now = LocalDateTime.now();

        // Basic ISO date format (default for LocalDate)
        String isoDate = today.format(DateTimeFormatter.ISO_DATE);
        System.out.println("ISO Date: " + isoDate); // 2023-10-27

        // Custom format එකක් හදාගන්න
        DateTimeFormatter customFormatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");
        String formattedDate = today.format(customFormatter);
        System.out.println("Custom Date: " + formattedDate); // 27/10/2023

        // තව custom format එකක්, time එක්ක
        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formattedDateTime = now.format(dateTimeFormatter);
        System.out.println("Formatted Date-Time: " + formattedDateTime);

        // String එකක් parse කරන්න custom format එකක් පාවිච්චි කරලා
        String dateString = "05-12-2023 14:30";
        DateTimeFormatter parser = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm");
        LocalDateTime parsedDateTime = LocalDateTime.parse(dateString, parser);
        System.out.println("Parsed Date-Time: " + parsedDateTime);
    }
}

ofPattern() method එකට දෙන pattern string එකේ symbols වල තේරුම මෙහෙමයි (මේවා ISO 8601 standard එකට අනුකූලයි):

• yyyy: Year (e.g., 2023)
• MM: Month (01-12)
• dd: Day of month (01-31)
• HH: Hour (00-23)
• mm: Minute (00-59)
• ss: Second (00-59)
• SSS: Millisecond (000-999)

අවසාන වශයෙන්…

java.time API එක කියන්නේ Java 8 වල ආපු ලොකුම සහ වැදගත්ම features වලින් එකක්. මේකෙන් Date සහ Time manipulation හුඟක් පහසු, ආරක්ෂිත, සහ readable කරලා තියෙනවා. LocalDate, LocalTime, LocalDateTime, ZonedDateTime, DateTimeFormatter මේ හැම එකක්ම තමන්ගේම කාර්යභාරයක් ඉටු කරනවා. ඒ වගේම Period (dates අතර වෙනස) සහ Duration (times අතර වෙනස) වගේ classes ගැනත් මම අද කතා නොකලත්, ඒවත් හුඟක් වැදගත්. ඔබට ඒවා ගැනත් පසුව explore කරන්න පුළුවන්.

ඔබේ Java project වලදී අනිවාර්යයෙන්ම මේ අලුත් API එක පාවිච්චි කරන්න පුරුදු වෙන්න. පරණ Date සහ Calendar classes වලින් ඈත් වෙලා මේ අලුත්, සුපිරි ක්‍රමයට adjust වෙන්න. මුලින් පොඩ්ඩක් අමුතු වගේ දැනුණත්, පුරුදු වුණාම හුඟක් ලේසි බව ඔබට තේරෙයි.

මේ article එක ගැන ඔබේ අදහස්, ප්‍රශ්න, යෝජනා කමෙන්ට් section එකේ දාගෙන යන්න අමතක කරන්න එපා. තව මේ වගේ technical topics ගැන කතා කරන්න ඕන නම්, ඒවත් කියන්න! එහෙනම්, හැමෝටම ජය වේවා! Happy Coding!