Deep Java

Java LocalDate පැහැදිලි කිරීම: Java 8 සහ ඊළඟ සංස්කරණවල දිනය කළමනාකරණයට සම්පූර්ණ මාර්ගෝපදේශය

දත්ත සැකසුම සහ එකතුව (Java සම්මත පුස්තකාලය)

.

目次

LocalDate යනු කුමක්ද?

Java හි දිනය සැකසීම සංස්කරණ 8 සිට ගණනාවක් වෙනස් වී ඇත. මෙම වෙනස්වීමේ මධ්‍යයේ LocalDate පවතී. LocalDate යනු අක්‍රිය (immutable) වස්තුවක් වන අතර එය දිනයක් පමණක් (අවුරුදු, මාසය, දිනය, උදා: 2025-06-26) නියෝජනය කරයි; කාලය හෝ කාලකලාපය ගැන කිසිදු අදහසක් නොමැත. එය ඔබට අද දිනය හෝ විශේෂිත දින දර්ශන සරල හා ආරක්ෂිත ලෙස සැකසීමට ඉඩ සලසයි.

පරණ Date පන්තීන් සමඟ වෙනස්කම්

Java 8 පෙර, java.util.Date සහ java.util.Calendar වැනි පන්තීන් සාමාන්‍යයෙන් භාවිතා කරනු ලැබුණි. එහෙත්, මෙම පන්තීන්ට කිහිපයක් ගැටළු තිබුණි, ඒ අතර දෝෂප්‍රවණ නිර්මාණය (උදා: ශූන්‍ය-අධාරිත මාස), තන්තුව-ආරක්ෂිත නොවීම, සහ අනූනිත API යනවා ඇත. ඒ නිසා, ඒවා බොහෝ විට දෝෂ හෝ අනපේක්ෂිත හැසිරීමක් ඇති කරයි.

LocalDate මෙම ගැටළු විසඳා පහත ලක්ෂණ ලබා දෙයි:

  • අවුරුදු, මාසය, දිනය පමණක් පැහැදිලි කළමනාකරණය (උදා: 2025 ජූනි 26)
  • අක්‍රිය වස්තුව (අගයන් වෙනස් කළ නොහැකි, ආරක්ෂාව තහවුරු කරයි)
  • අනූනිත ක්‍රියා නාම සහ API නිර්මාණය (උදා: plusDays(1) මඟින් ඊළඟ දිනය, getMonthValue() මඟින් මාස අංකය)
  • කාලකලාපයෙන් ස්වාධීන (පද්ධතිය හෝ සේවාදායක සැකසුම් මත නොනැරඹී සමාන හැසිරීම)

LocalDate භාවිතා කළ යුතු අවස්ථා කුමක්ද?

LocalDate යනු දිනයන් පැහැදිලිව, කාල තොරතුරු අවශ්‍ය නොවන, සහ දිනය ක්‍රියාකාරකම් ආරක්ෂිත හා පහසුවෙන් ක්‍රියාත්මක කිරීමට අවශ්‍ය වන විට ඉතා සුදුසුය. සාමාන්‍ය භාවිතයන් අතර ඇතුළත් වේ:

  • කාලය නොමැති දිනයන් ලේඛනය කිරීම, උදා: උපන්දිනයන් හෝ සංවත්සරයන්
  • කාලසටහන්, අවසන් දිනයන්, සහ නියමිත දිනයන් කළමනාකරණය
  • අවසන් දිනයන් හෝ ඉතිරි දින ගණනය කිරීම

මෙම හේතු නිසා, LocalDate Java හි දිනය සැකසීමේ නව ප්‍රමිතිය ලෙස සැලකිය හැක. ඊළඟ කොටසේ, LocalDate හි මූලික භාවිතය සහ ආරම්භ කිරීම පිළිබඳ විස්තර කරනු ඇත.

LocalDate සමඟ මූලික මෙහෙයුම්

LocalDate දිනය සංස්කරණය සඳහා අනූනිත හා සරල API එකක් ලබා දෙයි. මෙම කොටස සාමාන්‍යයෙන් භාවිතා වන ලක්ෂණ concrete උදාහරණ සමඟ පැහැදිලි කරයි.

වත්මන් දිනය ලබා ගැනීම

අද දිනය ලබා ගැනීමට, LocalDate.now() ක්‍රමය භාවිතා කරන්න. එය කාලකලාපයෙන් ස්වාධීනව (system date) LocalDate නමැති වස්තුවක් ලෙස ආපසු දෙයි.

import java.time.LocalDate;

LocalDate today = LocalDate.now();
System.out.println(today); // Example: 2025-06-26

විශේෂිත දිනයක් නිර්මාණය කිරීම

අතීත හෝ අනාගතයේ 任意 දිනයක් නිර්මාණය කිරීමට, LocalDate.of(int year, int month, int dayOfMonth) භාවිතා කරන්න. මෙය ඔබට 2024 දෙසැම්බර් 31 වැනි දිනයන් නිදහස්ව නිර්මාණය කිරීමට ඉඩ සලසයි.

LocalDate specialDay = LocalDate.of(2024, 12, 31);
System.out.println(specialDay); // 2024-12-31

문자열යෙන් දිනය පාර්ස් කිරීම

“2023-03-15” වැනි 문자열යක් සිට LocalDate ලබා ගැනීමට, LocalDate.parse(String text) ක්‍රමය භාවිතා කරන්න. 문자열ය සාමාන්‍ය ISO ආකෘතිය (“YYYY-MM-DD”) අනුගමනය කරන්නේ නම්, අමතර සැකසුම් අවශ්‍ය නොවේ.

LocalDate parsedDate = LocalDate.parse("2023-03-15");
System.out.println(parsedDate); // 2023-03-15

අභිරුචි ආකෘතියක් සමඟ පාර්ස් කිරීම (අතිරේක)

“2023/03/15” වැනි අභිරුචි ආකෘතියක දිනයන් සැකසීමට, DateTimeFormatter සමඟ parse() එකතු කළ හැකිය.

import java.time.format.DateTimeFormatter;

DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate formattedDate = LocalDate.parse("2023/03/15", formatter);
System.out.println(formattedDate); // 2023-03-15

ඉහත පෙන්වා ඇති පරිදි, LocalDate හි මූලික මෙහෙයුම් අනූනිත හා සරල වේ. නවීන Java කේතයේ, දිනය ආරම්භ කිරීම සහ පරිවර්තනය කිරීම අඩු ගැටළුවක් වේ. ඊළඟ අධ්‍යයනයේ, LocalDate වෙතින් අවුරුදු, මාස, දිනය, සහ සතියේ දිනය (weekday) අගයන් ලබා ගැනීම පිළිබඳ විස්තර කරනු ඇත.

අවුරුදු, මාස, දිනය, සහ සතියේ දිනය ලබා ගැනීම

LocalDate ඔබට දිනය පමණක් නොව, අවුරුදු, මාස, දිනය, සහ සතියේ දිනය වැනි තනි කොටස්ද පහසුවෙන් ලබා ගැනීමට ඉඩ සලසයි. මෙම කොටස මෙම සාමාන්‍යයෙන් භාවිතා වන අංග ලබා ගැනීමේ ක්‍රම පැහැදිලි කරයි.

අවුරුදු, මාස, සහ දිනය ලබා ගැනීම

LocalDate නමැති වස්තුවකින් එක් එක් කොටස ලබා ගැනීමට, අදාළ getter ක්‍රම භාවිතා කරන්න.

LocalDate date = LocalDate.of(2025, 6, 26);

int year = date.getYear();           // Year (e.g. 2025)
int month = date.getMonthValue();    // Month as a number (1–12, e.g. 6)
int day = date.getDayOfMonth();      // Day of month (1–31, e.g. 26)

System.out.println("Year: " + year);
System.out.println("Month: " + month);
System.out.println("Day: " + day);

මාස සහ සතියේ දින නාම ලබා ගැනීම

LocalDate මස සහ සතියේ දින නාම ලබා ගැනීමට සහය දක්වයි, ඔබට පෙළ ආකාරයේ නිරූපණ අවශ්‍ය වන විට මෙය ප්‍රයෝජනවත් වේ.

  • මාස නාමය (ඉංග්‍රීසි නිරූපණය) getMonth() භාවිතා කිරීමෙන් Month enum අගයක් (උදා. JUNE) ලබා දේ.
    import java.time.Month;

Month monthName = date.getMonth(); // JUNE (uppercase English)
System.out.println(monthName);
  • සතියේ දින නාමය getDayOfWeek() DayOfWeek enum එකක් (උදා. THURSDAY) ලබා දේ.
    import java.time.DayOfWeek;

DayOfWeek dayOfWeek = date.getDayOfWeek(); // THURSDAY (uppercase English)
System.out.println(dayOfWeek);

ජපන් භාෂාවේ මාස සහ සතියේ දින නාම පෙන්වීම

ඔබට මාස හෝ සතියේ දින නාම ඉංග්‍රීසි වෙනුවට ජපන් භාෂාවේ පෙන්වීමට අවශ්‍ය නම්, DateTimeFormatter භාවිතා කර ප්‍රතිඵලය අභිරුචි කරගත හැක.

import java.time.format.DateTimeFormatter;
import java.util.Locale;

DateTimeFormatter formatter =
    DateTimeFormatter.ofPattern("yyyy年MM月dd日(E)", Locale.JAPANESE);
String formatted = date.format(formatter); // 2025年06月26日(木)
System.out.println(formatted);

ලබාගත් කොටස් සාරාංශය

LocalDate හි ප්‍රධාන ශක්තියක් වන්නේ එය අවුරුදු, මාස, දිනය, සහ සතියේ දින අන්තර්ගත ක්‍රම භාවිතා කර ලබා ගැනීමට ඉඩ දීමයි. මෙම ස flexibilitiy ව්‍යාපාරික සහ වෙබ් යෙදුම් වල දිනය කළමනාකරණය ඉතා පහසු කරයි.

දිනය ගණනය (එකතු කිරීම සහ අඩු කිරීම)

දින එකතු කිරීම හෝ අඩු කිරීම වැනි දිනය ගණනයන් කාලසටහන් කළමනාකරණය සහ අවසන් දිනය ගණනය සඳහා නිතර අවශ්‍ය වේ. LocalDate සමඟ, “දින තුනක් පසු”, “සතියක් පෙර” හෝ “දින දෙකක් අතර වෙනස්කම” වැනි මෙහෙයුම් ආරක්ෂිතව සහ අන්තර්ගතව සිදු කළ හැක.

දිනයන් එකතු කිරීම

  • දින එකතු කිරීම
    LocalDate today = LocalDate.of(2025, 6, 26);
LocalDate threeDaysLater = today.plusDays(3); // Three days later
System.out.println(threeDaysLater); // 2025-06-29
  • මාස හෝ අවුරුදු එකතු කිරීම
    LocalDate nextMonth = today.plusMonths(1); // One month later
LocalDate nextYear = today.plusYears(1);   // One year later
System.out.println(nextMonth); // 2025-07-26
System.out.println(nextYear);  // 2026-06-26

දිනයන් අඩු කිරීම

  • දින, මාස, හෝ අවුරුදු අඩු කිරීම
    LocalDate lastWeek = today.minusWeeks(1);   // One week earlier
LocalDate previousDay = today.minusDays(1); // Previous day
System.out.println(lastWeek);    // 2025-06-19
System.out.println(previousDay); // 2025-06-25

දිනයන් අතර වෙනස්කම් ගණනය කිරීම

  • දින වල වෙනස්කම ගණනය කිරීම
    import java.time.temporal.ChronoUnit;

LocalDate start = LocalDate.of(2025, 6, 1);
LocalDate end = LocalDate.of(2025, 6, 26);

long daysBetween = ChronoUnit.DAYS.between(start, end); // 25
System.out.println(daysBetween); // 25
  • වෙනත් ඒකක (මාස, අවුරුදු) භාවිතා කර වෙනස්කම් ගණනය කිරීම
    long monthsBetween = ChronoUnit.MONTHS.between(start, end); // 0
long yearsBetween = ChronoUnit.YEARS.between(start, end);   // 0

සාරාංශය

LocalDate හි එකතු කිරීම සහ අඩු කිරීම ක්‍රම භාවිතා කිරීමෙන්, “ඊළඟ මාසයේ අවසන් දිනය” හෝ “අවසන් සිදුවීමෙන් පසු ගත වූ දින” වැනි සාමාන්‍ය දිනය ගණනයන් පහසුවෙන් ක්‍රියාත්මක කළ හැක.

LocalDate අස්ථිර නොවන බැවින්, මුල් උදාහරණය කිසි විටෙකත් වෙනස් නොවේ. සෑම මෙහෙයුමක්ම නව LocalDate උදාහරණයක් ලෙස ආපසු ලබා දේ, එය ආරක්ෂිත දිනය කළමනාකරණය සනාථ කරයි.

උසස් මෙහෙයුම්: විශේෂිත දිනයන් සකස් කිරීම

ප්‍රායෝගික දිනය කළමනාකරණයේ, සරල එකතු කිරීම හෝ අඩු කිරීම පමණක් ප්‍රමාණවත් නොවේ. සාමාන්‍ය අවශ්‍යතා අතර “මාසයේ අවසන් දිනය” හෝ “ඊළඟ මාසයේ පළමු දිනය” තීරණය කිරීම ඇතුළත් වේ. LocalDate මෙම වර්ගයේ සකස් කිරීම් සඳහා පහසු API ලබා දේ.

TemporalAdjuster භාවිතය

LocalDate සමඟ, ඔබට with() ක්‍රමය සහ TemporalAdjuster එක එකතු කර මාසයේ අවසානය, මාසයේ ආරම්භය, හෝ ඊළඟ විශේෂිත සතියේ දිනය වැනි සරල ක්‍රියාකාරකම් සිදු කළ හැක. අන්තර්ගත adjusters TemporalAdjusters පන්තියේ ලබා දී ඇත.

මාසයේ පළමු සහ අවසන් දිනය ලබා ගැනීම

  • මාසයේ අවසන් දිනය ලබා ගැනීම
    import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

LocalDate date = LocalDate.of(2025, 6, 26);
LocalDate endOfMonth = date.with(TemporalAdjusters.lastDayOfMonth());
System.out.println(endOfMonth); // 2025-06-30
  • මාසයේ පළමු දිනය ලබා ගැනීම
    LocalDate startOfMonth = date.with(TemporalAdjusters.firstDayOfMonth());
System.out.println(startOfMonth); // 2025-06-01

සතියේ දින මත පදනම් වූ සවිකිරීම්

සතියේ දින මත පදනම් වූ සවිකිරීම්—උදාහරණ olarak “මාසයේ දෙවන සඳුදා” හෝ “ඊළඟ සිකුරාදා”—ද සරලව ක්‍රියාත්මක කළ හැක.

  • ඊළඟ සිකුරාදා ලබා ගැනීම
    import java.time.DayOfWeek;

LocalDate nextFriday =
    date.with(TemporalAdjusters.next(DayOfWeek.FRIDAY));
System.out.println(nextFriday); // 2025-06-27
  • වත්මන් මාසයේ දෙවන සඳුදා ලබා ගැනීම
    LocalDate secondMonday =
    date.with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.MONDAY));
System.out.println(secondMonday); // 2025-06-09

වසරේ ආරම්භය හෝ අවසානයට සවිකිරීම

ඔබට ඒම ක්‍රමය භාවිතා කර වසරේ පළමු හෝ අවසන් දිනය ලබා ගත හැක.

LocalDate startOfYear =
    date.with(TemporalAdjusters.firstDayOfYear());
LocalDate endOfYear =
    date.with(TemporalAdjusters.lastDayOfYear());

System.out.println(startOfYear); // 2025-01-01
System.out.println(endOfYear);   // 2025-12-31

අභිරුචි Adjusters නිර්මාණය

ඔබට විශේෂ ව්‍යාපාර නීති මත පදනම් වූ අභිරුචි දිනය-සවිකිරීම තර්කයක් අවශ්‍ය නම්, TemporalAdjuster අතුරුමුහුණත ඔබම ක්‍රියාත්මක කළ හැක.

LocalDate සහ TemporalAdjusters එකතු කිරීමෙන්, සංකීර්ණ දිනය ගණනය කිරීම්ද සරල හා වගකීමකින් පිරුණු බවට පත්වේ. මෙය කාලසීමා හෝ ව්‍යාපාර-විශේෂ කාලසටහන් හසුරවීමේදී විශේෂයෙන් ප්‍රයෝජනවත් වේ.

LocalDate සහ LocalDateTime සමඟ වැඩ කිරීම

Java Date and Time API (java.time පැකේජය) තුළ, LocalDate එක දිනයක් පමණක් නියෝජනය කරයි, LocalDateTime දිනය සහ වේලාව දෙකම නියෝජනය කරයි. ප්‍රායෝගිකව, සංවර්ධකයන්ට මෙම වර්ග දෙක අතර පරිවර්තනය කිරීමට අවශ්‍ය වේ. මෙම කොටස මෙම පරිවර්තන කෙරෙහි විස්තර කරයි.

LocalDate එක LocalDateTime වෙත පරිවර්තනය කිරීම

LocalDate එකට වේලාව තොරතුරු එක් කර LocalDateTime වෙත පරිවර්තනය කිරීමට, atTime() හෝ atStartOfDay() භාවිතා කරන්න.

  • විශේෂිත වේලාවක් එක් කිරීම
    import java.time.LocalDate;
import java.time.LocalDateTime;

LocalDate date = LocalDate.of(2025, 6, 26);
LocalDateTime dateTime =
    date.atTime(14, 30, 0); // 2025-06-26 14:30:00
System.out.println(dateTime);
  • දවසේ ආරම්භයේ LocalDateTime එක නිර්මාණය කිරීම
    LocalDateTime startOfDay =
    date.atStartOfDay(); // 2025-06-26T00:00
System.out.println(startOfDay);

LocalDateTime එක LocalDate වෙත පරිවර්තනය කිරීම

LocalDateTime එකෙන් දිනයේ කොටස පමණක් ලබා ගැනීමට, toLocalDate() ක්‍රමය භාවිතා කරන්න.

import java.time.LocalDateTime;

LocalDateTime dateTime =
    LocalDateTime.of(2025, 6, 26, 14, 30);
LocalDate dateOnly = dateTime.toLocalDate();
System.out.println(dateOnly); // 2025-06-26

LocalDate සහ LocalTime එකතු කිරීම

LocalDate සහ LocalTime එකතු කර LocalDateTime එකක් නිර්මාණය කළ හැක.

import java.time.LocalTime;

LocalTime time = LocalTime.of(9, 0);
LocalDateTime combined =
    date.atTime(time); // 2025-06-26T09:00
System.out.println(combined);

සාරාංශය

  • atTime() හෝ atStartOfDay() භාවිතා කර LocalDate එක LocalDateTime වෙත පරිවර්තනය කරන්න
  • toLocalDate() භාවිතා කර LocalDateTime එක LocalDate වෙත පරිවර්තනය කරන්න
  • දිනය සහ වේලාව වෙන් කිරීම සහ එකතු කිරීම වාස්තු විද්‍යාත්මක පද්ධති වල සාමාන්‍ය වේ

දෝෂ හසුරුවීම සහ හොඳ පුරුදු

.Date handling can easily lead to unexpected exceptions if invalid values or formats are used. Even when working with LocalDate, exceptions may occur due to non-existent dates or parsing errors. This section explains common exceptions and best practices for handling them safely.

නොපවතින දිනයක් නිරූපණය කිරීම

ඔබ නොපවතින දිනයක්—උදාහරණයක් ලෙස 2023 පෙබරවාරි 30—සෑදීමට උත්සාහ කළහොත් DateTimeException එකක් නිකුත් වේ.

import java.time.LocalDate;

// Example that throws an exception
LocalDate invalidDate = LocalDate.of(2023, 2, 30);

එවැනි අවස්ථාවල, εξαදෝෂය අල්ලා ගනිමින් එය සුදුසු ලෙස හසුරවීම වැදගත් වේ.

try {
    LocalDate invalidDate = LocalDate.of(2023, 2, 30);
} catch (DateTimeException e) {
    System.out.println("An invalid date was specified: " + e.getMessage());
}

ස්ට්‍රින්ග් විග්‍රහ කිරීමේදී εξαදෝෂ

LocalDate.parse() භාවිතා කරන විට, ස්ට්‍රින්ග් ආකෘතිය අවලංගු නම් හෝ දිනයම නොපවතින නම් DateTimeParseException එකක් නිකුත් වේ.

import java.time.format.DateTimeParseException;

try {
    LocalDate date = LocalDate.parse("2023/02/30");
} catch (DateTimeParseException e) {
    System.out.println("Failed to parse date: " + e.getMessage());
}

හොඳ පුරුදු

  • ආදාන අගයන් පෙර පරීක්ෂා කරන්න පරිශීලක ආදාන ලබා ගන්නා විට, εξαදෝෂ වැළැක්වීමට ආකෘතිය සහ අගය දෙකම විග්‍රහ කිරීමට පෙර පරීක්ෂා කරන්න.
  • εξαදෝෂ අල්ලා පරිශීලක‑හිතකාමී පණිවුඩ ලබා දෙන්න යෙදුම බිඳ වැටීමට ඉඩ නොදෙමින්, පරිශීලකයාට පැහැදිලි සහ අවබෝධය ඇති දෝෂ පණිවුඩ ලබා දෙන්න.
  • අප්‍රතිවර්තනීයත්වය (immutability) භාවිතා කරන්න LocalDate අප්‍රතිවර්තනීය බැවින්, ගණනයේ ප්‍රතිඵල සැමවිටම නව අවස්ථා ලෙස සලකන්න, පවතින ඒවා අලුත් කිරීමේ වෙනුවට.

සාමාන්‍ය වැරදි

  • ලීප් වර්ෂවල පෙබරවාරි 29 ක සැලසුම් කිරීම
  • වලංගු පරාසයෙන් පිටත අගයන් නිරූපණය කිරීම (උදා: මාසය = 13, දිනය = 0)
  • ස්ට්‍රින්ග් විග්‍රහ කිරීමේදී අසමත් ආකෘති

මෙම ගැටළු ආරම්භකයන් අතර විශේෂයෙන් පොදු වන අතර, අතිරේක අවධානයක් අවශ්‍ය වේ.

LocalDate සඳහා ප්‍රායෝගික භාවිතා උදාහරණ

LocalDate සරල දිනය සුරැකීමට පමණක් සීමා නොවේ—එය වාස්තුක ව්‍යාපාර පද්ධති සහ යෙදුම් වල පුළුල් ලෙස භාවිතා වේ. පහත කිහිපයක් ප්‍රායෝගික උදාහරණ වේ.

උපන්දිනය සහ වයස ගණනය

වෙනෙකුගේ උපන් දිනය මත පදනම්ව වයස ගණනය කිරීම සාම්ප්‍රදායික භාවිතයක් වේ. LocalDate සමඟ Period භාවිතා කිරීමෙන් මෙය පහසු වේ.

import java.time.LocalDate;
import java.time.Period;

LocalDate birthDay = LocalDate.of(1990, 8, 15);
LocalDate today = LocalDate.now();

Period period = Period.between(birthDay, today);
int age = period.getYears();
System.out.println("Age: " + age);

අවසන් දිනයන් සහ නියමිත දිනයන් කළමනාකරණය

LocalDate කාර්ය කළමනාකරණ පද්ධති සඳහාද ප්‍රයෝජනවත් වන අතර, අවසන් දිනයක් දක්වා ඉතිරි දින ගණනය කිරීම වැනි කාර්යයන්ට භාවිතා කළ හැක.

LocalDate deadline = LocalDate.of(2025, 7, 10);
long daysLeft =
    java.time.temporal.ChronoUnit.DAYS.between(today, deadline);

System.out.println("Days remaining until deadline: " + daysLeft);

කාලසටහන් සැකසීම සහ දිනදර්ශන ජනනය

“සෑම මාසයකදෙවන සඳුදා මුණගැසීම” වැනි අවශ්‍යතා TemporalAdjusters භාවිතා කරමින් පහසුවෙන් ක්‍රියාත්මක කළ හැක.

import java.time.DayOfWeek;
import java.time.temporal.TemporalAdjusters;

LocalDate secondMonday =
    LocalDate.of(2025, 7, 1)
        .with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.MONDAY));

System.out.println("Second Monday of July: " + secondMonday);

වෙබ් පද්ධති සහ API වල දිනය වලංගු කිරීම

LocalDate පසුපස පද්ධතිවල දිනය ආදාන වලංගු කිරීම සඳහා නිතර භාවිතා වේ. උදාහරණයක් ලෙස, ඔබට අනාගත දිනයන් හෝ නියමිත පරාසයට වඩා පරණ දිනයන් ප්‍රතික්ෂේප කිරීමට අවශ්‍ය විය හැක.

LocalDate inputDate = LocalDate.parse("2024-12-31");
LocalDate tenYearsAgo = today.minusYears(10);

if (inputDate.isAfter(today)) {
    System.out.println("Future dates are not allowed");
} else if (inputDate.isBefore(tenYearsAgo)) {
    System.out.println("Please specify a date within the last 10 years");
} else {
    System.out.println("The date is valid");
}

Adoption in Training and Production Systems

As seen in many competing articles, LocalDate is now a standard topic in Java training programs and onboarding curricula. It is also widely used in production systems such as banking business-day calculations and inventory management.

FAQ (Frequently Asked Questions)

Q1. What is the difference between LocalDate and Date?

A.
LocalDate is part of the modern Java Date and Time API introduced in Java 8 and represents only a date (year, month, day). java.util.Date, on the other hand, is a legacy class that includes time and internally manages values in milliseconds.

LocalDate is immutable, intuitive, and thread-safe, and is recommended for modern Java development.

Q2. Can LocalDate handle time zones?

A.
LocalDate itself does not contain time zone information. If time zone support is required, use ZonedDateTime or OffsetDateTime. A common approach is to manage dates with LocalDate first, then convert when time zones become necessary.

Q3. What is the difference between LocalDate and LocalDateTime?

A.
LocalDate represents only a date. LocalDateTime represents both date and time (e.g. 2025-06-26 14:00). Use LocalDate for deadlines or anniversaries, and LocalDateTime for events with precise timestamps.

Q4. Can I parse custom date formats?

A.
Yes. By using DateTimeFormatter, you can parse dates in custom formats.

import java.time.format.DateTimeFormatter;

DateTimeFormatter formatter =
    DateTimeFormatter.ofPattern("yyyy/MM/dd");
LocalDate date =
    LocalDate.parse("2025/06/26", formatter);

Q5. How should I handle invalid dates or formats?

A.
Invalid dates or formats cause exceptions such as DateTimeException or DateTimeParseException. Use try-catch blocks, validate input in advance, and provide clear error messages to users.

Q6. Can I compare two LocalDate instances?

A.
Yes. Use isAfter(), isBefore(), or isEqual().

LocalDate date1 = LocalDate.of(2025, 6, 26);
LocalDate date2 = LocalDate.of(2025, 7, 1);

if (date1.isBefore(date2)) {
    System.out.println("date1 is earlier than date2");
}

Conclusion

This article provided a comprehensive explanation of Java LocalDate, from basic concepts to advanced use cases. Key points include:

  • What LocalDate is An immutable date-only object introduced in Java 8 that fixes the flaws of legacy Date and Calendar classes.
  • Basic usage Retrieving the current date, creating specific dates, and parsing strings using simple APIs.
  • Extracting components Easily retrieving year, month, day, and weekday values.
  • Date calculations Intuitive addition, subtraction, and difference calculations.
  • Date adjustments Using TemporalAdjusters to handle end-of-month, weekdays, and more.
  • Integration with time APIs Flexible conversion between LocalDate, LocalDateTime, and LocalTime.
  • Safe handling and best practices Proper exception handling and validation for robust systems.
  • Real-world applications and FAQs Practical examples such as age calculation, deadlines, scheduling, and validation.

Next Steps

Once you master LocalDate, date handling becomes straightforward and reliable. For more advanced scenarios—such as time zones, period calculations, and formatting—consider learning ZonedDateTime, Period, and DateTimeFormatter.

Use LocalDate as a powerful foundation to build clean, robust, and maintainable Java applications.