Java LocalDate 시간대 설정 방법 | Java 날짜 및 시간

소개

Java 개발자는 종종 LocalDate 객체에 적절한 시간대를 설정하는 것을 포함하여 날짜 및 시간 정보를 처리해야 합니다. 이 랩에서는 Java 에서 시간대를 사용하는 방법을 안내하며, 다양한 지역에서 날짜를 올바르게 처리하는 방법을 이해하는 데 도움이 되는 실습 예제를 제공합니다. 시간대 개념을 시연하고 이러한 기술의 실용적인 응용 프로그램을 배우기 위해 간단한 Java 프로그램을 만들 것입니다.

Java Time API 기본 이해

이 단계에서는 Java Time API 에 대해 배우고 시간대를 탐색하기 위한 첫 번째 프로그램을 만들 것입니다. 최신 Java Time API 는 java.time 패키지의 일부로 Java 8 에 도입되었으며 날짜 및 시간 처리를 위한 포괄적인 클래스를 제공합니다.

Java Time API 주요 클래스

시간대를 사용하기 전에 사용할 핵심 클래스를 이해해 보겠습니다.

LocalDate: 시간 또는 시간대 없이 날짜를 나타냅니다 (년 - 월 - 일)
ZoneId: 시간대 식별자를 나타냅니다
ZonedDateTime: 시간대가 있는 날짜 및 시간을 나타냅니다
Instant: 특정 시점을 나타냅니다 (타임스탬프)

첫 번째 시간대 프로그램 만들기

시스템에서 사용 가능한 시간대를 탐색하기 위해 Java 파일을 만들어 보겠습니다. WebIDE 를 열고 다음 단계를 따르세요.

왼쪽의 탐색기 패널에서 /home/labex/project 디렉토리로 이동합니다.
project 폴더를 마우스 오른쪽 버튼으로 클릭하고 "New File"을 선택합니다.
파일 이름을 TimeZoneExplorer.java로 지정합니다.
파일에 다음 코드를 추가합니다.

import java.time.ZoneId;
import java.util.Set;

public class TimeZoneExplorer {
    public static void main(String[] args) {
        // Get the system default time zone
        ZoneId defaultZone = ZoneId.systemDefault();
        System.out.println("Your system default time zone: " + defaultZone);

        // Display total number of available time zones
        Set<String> allZones = ZoneId.getAvailableZoneIds();
        System.out.println("Number of available time zones: " + allZones.size());

        // Print the first 10 time zones (alphabetically sorted)
        System.out.println("\nFirst 10 time zones:");
        allZones.stream()
                .sorted()
                .limit(10)
                .forEach(zoneId -> System.out.println("  - " + zoneId));

        // Display some common time zones
        System.out.println("\nSome common time zones:");
        System.out.println("  - New York: " + ZoneId.of("America/New_York"));
        System.out.println("  - London: " + ZoneId.of("Europe/London"));
        System.out.println("  - Tokyo: " + ZoneId.of("Asia/Tokyo"));
        System.out.println("  - Sydney: " + ZoneId.of("Australia/Sydney"));
    }
}

Ctrl+S 를 누르거나 File > Save 를 클릭하여 파일을 저장합니다.

이제 이 Java 프로그램을 컴파일하고 실행해 보겠습니다.

메뉴에서 Terminal > New Terminal 을 클릭하여 터미널을 엽니다.
Java 프로그램을 컴파일합니다.

cd ~/project
javac TimeZoneExplorer.java

프로그램을 실행합니다.

java TimeZoneExplorer

다음과 유사한 출력을 볼 수 있습니다.

Your system default time zone: UTC
Number of available time zones: 600

First 10 time zones:
  - Africa/Abidjan
  - Africa/Accra
  - Africa/Addis_Ababa
  - Africa/Algiers
  - Africa/Asmara
  - Africa/Asmera
  - Africa/Bamako
  - Africa/Bangui
  - Africa/Banjul
  - Africa/Bissau

Some common time zones:
  - New York: America/New_York
  - London: Europe/London
  - Tokyo: Asia/Tokyo
  - Sydney: Australia/Sydney

이 프로그램은 Java 의 시간대에 대한 개요를 제공합니다. Java Time API 를 사용하여 시간대를 탐색하는 첫 번째 Java 프로그램을 성공적으로 만들었습니다. 다음 단계에서는 LocalDate 와 시간대를 함께 사용하는 방법을 배우게 됩니다.

LocalDate 객체 생성 및 시간대 적용

이 단계에서는 LocalDate 객체를 생성하고 시간대를 적용하는 방법을 배우게 됩니다. LocalDate 객체 자체에는 시간대 정보가 포함되어 있지 않지만, 시간대를 연결하여 ZonedDateTime으로 변환할 수 있다는 점을 기억하세요.

LocalDate 의 제한 사항 이해

Java 의 LocalDate 클래스는 시간 또는 시간대 정보 없이 날짜를 나타냅니다. 연, 월, 일 정보만 포함합니다. 이는 다음과 같은 이유로 이해하는 것이 중요합니다.

LocalDate는 시간대에 구애받지 않습니다. 즉, 동일한 LocalDate 객체가 서로 다른 시간대에서 서로 다른 실제 날짜를 나타낼 수 있습니다.
LocalDate에 시간대를 적용하려면 ZonedDateTime으로 변환해야 합니다.

이러한 개념을 탐구하기 위해 새로운 Java 파일을 만들어 보겠습니다.

WebIDE 에서 /home/labex/project 디렉토리에 새 파일을 만듭니다.
파일 이름을 LocalDateWithTimeZone.java로 지정합니다.
다음 코드를 추가합니다.

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

public class LocalDateWithTimeZone {
    public static void main(String[] args) {
        // Create a LocalDate for January 1, 2023
        LocalDate date = LocalDate.of(2023, 1, 1);
        System.out.println("LocalDate (no time zone): " + date);

        // Format the date
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMMM dd, yyyy");
        System.out.println("Formatted date: " + date.format(formatter));

        // Get current system date
        LocalDate today = LocalDate.now();
        System.out.println("Today's date: " + today);

        // Create the same date in different time zones
        ZoneId newYorkZone = ZoneId.of("America/New_York");
        ZoneId tokyoZone = ZoneId.of("Asia/Tokyo");

        // Convert LocalDate to ZonedDateTime (attaching time zone)
        // Note: this assumes start of day (midnight) in that zone
        ZonedDateTime dateInNewYork = date.atStartOfDay(newYorkZone);
        ZonedDateTime dateInTokyo = date.atStartOfDay(tokyoZone);

        // Format for display
        DateTimeFormatter zonedFormatter = DateTimeFormatter.ofPattern("MMMM dd, yyyy HH:mm:ss z");
        System.out.println("\nJanuary 1, 2023 at start of day in different time zones:");
        System.out.println("New York: " + dateInNewYork.format(zonedFormatter));
        System.out.println("Tokyo: " + dateInTokyo.format(zonedFormatter));

        // Convert back to LocalDate
        LocalDate newYorkLocalDate = dateInNewYork.toLocalDate();
        LocalDate tokyoLocalDate = dateInTokyo.toLocalDate();

        System.out.println("\nBack to LocalDate (without time zone):");
        System.out.println("New York: " + newYorkLocalDate);
        System.out.println("Tokyo: " + tokyoLocalDate);

        // Check if they are equal
        System.out.println("\nAre the LocalDate objects equal? " + newYorkLocalDate.equals(tokyoLocalDate));
    }
}

파일을 저장합니다.

이제 이 Java 프로그램을 컴파일하고 실행해 보겠습니다.

cd ~/project
javac LocalDateWithTimeZone.java
java LocalDateWithTimeZone

다음과 유사한 출력을 볼 수 있습니다.

LocalDate (no time zone): 2023-01-01
Formatted date: January 01, 2023
Today's date: 2023-10-23

January 1, 2023 at start of day in different time zones:
New York: January 01, 2023 00:00:00 EST
Tokyo: January 01, 2023 00:00:00 JST

Back to LocalDate (without time zone):
New York: 2023-01-01
Tokyo: 2023-01-01

Are the LocalDate objects equal? true

시연된 주요 개념

이 프로그램은 몇 가지 중요한 개념을 시연합니다.

시간대 정보 없이 LocalDate 객체 생성
atStartOfDay(ZoneId)를 사용하여 동일한 LocalDate에 서로 다른 시간대 적용
ZonedDateTime을 다시 LocalDate로 변환
서로 다른 시간대의 동일한 달력 날짜가 동일한 LocalDate 객체를 생성함을 보여줍니다.

중요한 참고 사항

atStartOfDay(ZoneId)를 사용하면 Java 는 지정된 시간대의 00:00:00 (자정) 을 가정합니다.
연, 월, 일이 동일한 두 개의 LocalDate 객체는 원래 시간대에 관계없이 동일한 것으로 간주됩니다.
시간대 간에 날짜를 제대로 처리하려면 LocalDate 대신 일반적으로 ZonedDateTime을 사용해야 합니다.

다음 단계에서는 서로 다른 시간대 간의 날짜 변환을 처리하는 방법을 배우게 됩니다.

시간대 간 날짜 변환

이 단계에서는 전 세계 사용자를 대상으로 하는 애플리케이션에서 흔히 요구되는 사항인 서로 다른 시간대 간에 날짜를 변환하는 방법을 배우게 됩니다. 특정 날짜와 시간을 한 시간대에서 다른 시간대로 변환하는 방법을 보여주는 프로그램을 만들 것입니다.

시간대 변환 이해

시간대 간에 변환할 때, 기본이 되는 시간의 순간은 동일하게 유지되지만, 현지 날짜 및 시간 표현은 변경됩니다. 이는 이해해야 할 중요한 개념입니다.

동일한 시간의 순간은 서로 다른 시간대에서 다르게 표현됩니다.
변환할 때 시간의 순간을 변경하는 것이 아니라, 표현 방식을 변경하는 것입니다.

시간대 변환을 탐구하기 위해 새로운 Java 파일을 만들어 보겠습니다.

WebIDE 에서 /home/labex/project 디렉토리에 새 파일을 만듭니다.
파일 이름을 TimeZoneConverter.java로 지정합니다.
다음 코드를 추가합니다.

import java.time.*;
import java.time.format.DateTimeFormatter;

public class TimeZoneConverter {
    public static void main(String[] args) {
        // Define our date formatter
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z");

        // Create a specific date and time in New York time zone
        ZoneId newYorkZone = ZoneId.of("America/New_York");
        LocalDateTime dateTimeInNewYork = LocalDateTime.of(2023, 5, 15, 9, 0, 0); // May 15, 2023, 9:00 AM
        ZonedDateTime newYorkDateTime = dateTimeInNewYork.atZone(newYorkZone);

        System.out.println("Original Date and Time:");
        System.out.println("New York: " + newYorkDateTime.format(formatter));

        // Convert to different time zones
        ZoneId londonZone = ZoneId.of("Europe/London");
        ZoneId tokyoZone = ZoneId.of("Asia/Tokyo");
        ZoneId sydneyZone = ZoneId.of("Australia/Sydney");

        // The conversion maintains the same instant but changes the local time representation
        ZonedDateTime londonDateTime = newYorkDateTime.withZoneSameInstant(londonZone);
        ZonedDateTime tokyoDateTime = newYorkDateTime.withZoneSameInstant(tokyoZone);
        ZonedDateTime sydneyDateTime = newYorkDateTime.withZoneSameInstant(sydneyZone);

        System.out.println("\nSame instant in different time zones:");
        System.out.println("London: " + londonDateTime.format(formatter));
        System.out.println("Tokyo: " + tokyoDateTime.format(formatter));
        System.out.println("Sydney: " + sydneyDateTime.format(formatter));

        // Extract the LocalDate from each ZonedDateTime
        System.out.println("\nExtracted LocalDate from each ZonedDateTime:");
        System.out.println("New York date: " + newYorkDateTime.toLocalDate());
        System.out.println("London date: " + londonDateTime.toLocalDate());
        System.out.println("Tokyo date: " + tokyoDateTime.toLocalDate());
        System.out.println("Sydney date: " + sydneyDateTime.toLocalDate());

        // Check if the Instant values are the same
        System.out.println("\nInstant comparisons:");
        System.out.println("New York and London represent the same instant: "
                + newYorkDateTime.toInstant().equals(londonDateTime.toInstant()));
        System.out.println("New York and Tokyo represent the same instant: "
                + newYorkDateTime.toInstant().equals(tokyoDateTime.toInstant()));
    }
}

파일을 저장합니다.

이제 이 Java 프로그램을 컴파일하고 실행해 보겠습니다.

cd ~/project
javac TimeZoneConverter.java
java TimeZoneConverter

다음과 유사한 출력을 볼 수 있습니다.

Original Date and Time:
New York: 2023-05-15 09:00:00 EDT

Same instant in different time zones:
London: 2023-05-15 14:00:00 BST
Tokyo: 2023-05-15 22:00:00 JST
Sydney: 2023-05-15 23:00:00 AEST

Extracted LocalDate from each ZonedDateTime:
New York date: 2023-05-15
London date: 2023-05-15
Tokyo date: 2023-05-15
Sydney date: 2023-05-15

Instant comparisons:
New York and London represent the same instant: true
New York and Tokyo represent the same instant: true

시간대 변환을 위한 주요 메서드

시간대 간 변환을 위한 주요 메서드는 withZoneSameInstant(ZoneId)이며, 다음을 수행합니다.

동일한 시간의 순간 (타임라인의 동일한 지점) 을 유지합니다.
시간대를 변경합니다.
이에 따라 현지 날짜 및 시간 구성 요소를 조정합니다.

사용했던 다른 중요한 메서드는 다음과 같습니다.

atZone(ZoneId): LocalDateTime에 시간대를 연결합니다.
toInstant(): Instant(시간대가 없는 타임라인의 지점) 으로 변환합니다.
toLocalDate(): 날짜 부분 (년, 월, 일) 만 추출합니다.

중요한 관찰 사항

출력에서 다음을 확인하세요.

뉴욕 오전 9 시는 런던 오후 2 시와 동일한 순간입니다.
이 예제에서는 시간 차이가 날짜를 변경할 만큼 크지 않았기 때문에 모든 시간대에서 현지 날짜가 동일 (5 월 15 일) 합니다.
Instant 객체는 동일한 순간을 나타내기 때문에 같습니다.

다음 단계에서는 실용적인 응용 프로그램인 시간대 간의 날짜 변경 처리에 대해 배우게 됩니다.

시간대 간 날짜 변경 처리

이 단계에서는 시간대 간 변환 시 날짜가 변경되는 경우를 처리하는 방법을 배우게 됩니다. 이는 마감일, 이벤트 날짜 또는 영업일이 지역에 따라 다르게 해석될 수 있는 국제 애플리케이션에서 특히 중요합니다.

날짜 변경 문제

시간대 차이로 인해 시간의 순간은 동일하더라도 현지 날짜가 변경될 수 있습니다. 예를 들어, 뉴욕에서 저녁일 때 도쿄에서는 이미 다음 날일 수 있습니다. 이는 다음과 같은 사항에 영향을 미칠 수 있습니다.

비즈니스 마감일
항공편 도착/출발 날짜
컨퍼런스 또는 이벤트 날짜
계약 만료일

이러한 날짜 변경을 보여주는 프로그램을 만들어 보겠습니다.

WebIDE 에서 /home/labex/project 디렉토리에 새 파일을 만듭니다.
파일 이름을 DateChangeAcrossTimeZones.java로 지정합니다.
다음 코드를 추가합니다.

import java.time.*;
import java.time.format.DateTimeFormatter;

public class DateChangeAcrossTimeZones {
    public static void main(String[] args) {
        // Define formatter for easy reading
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z");

        // Define our time zones
        ZoneId newYorkZone = ZoneId.of("America/New_York");
        ZoneId tokyoZone = ZoneId.of("Asia/Tokyo");

        // Create a late evening time in New York
        LocalDateTime lateEveningNY = LocalDateTime.of(2023, 5, 15, 22, 0, 0); // May 15, 10:00 PM
        ZonedDateTime nyDateTime = lateEveningNY.atZone(newYorkZone);

        // Convert to Tokyo time
        ZonedDateTime tokyoDateTime = nyDateTime.withZoneSameInstant(tokyoZone);

        System.out.println("Date/Time Comparison:");
        System.out.println("New York: " + nyDateTime.format(formatter));
        System.out.println("Tokyo:    " + tokyoDateTime.format(formatter));

        // Extract just the dates for comparison
        LocalDate nyDate = nyDateTime.toLocalDate();
        LocalDate tokyoDate = tokyoDateTime.toLocalDate();

        System.out.println("\nDate Comparison:");
        System.out.println("New York date: " + nyDate);
        System.out.println("Tokyo date:    " + tokyoDate);
        System.out.println("Same date? " + nyDate.equals(tokyoDate));

        // Calculate the date difference
        System.out.println("\nThe date in Tokyo is " +
                (tokyoDate.isAfter(nyDate) ? "after" : "before") +
                " the date in New York");

        // Practical example: Conference spanning multiple days
        System.out.println("\n--- International Conference Example ---");
        LocalDate conferenceStart = LocalDate.of(2023, 6, 1);
        LocalDate conferenceEnd = LocalDate.of(2023, 6, 3);

        // Create a conference schedule - for each day, sessions run from 9 AM to 5 PM in New York
        System.out.println("Conference runs from June 1-3, 2023 (New York time, 9 AM - 5 PM daily)");

        // Display the conference schedule in Tokyo time
        System.out.println("\nConference Schedule in Tokyo time:");

        // Loop through each day of the conference
        for (int day = 0; day < 3; day++) {
            LocalDate currentDate = conferenceStart.plusDays(day);

            // Morning session (9 AM New York time)
            ZonedDateTime nyMorning = ZonedDateTime.of(currentDate, LocalTime.of(9, 0), newYorkZone);
            ZonedDateTime tokyoMorning = nyMorning.withZoneSameInstant(tokyoZone);

            // Afternoon session (5 PM New York time)
            ZonedDateTime nyAfternoon = ZonedDateTime.of(currentDate, LocalTime.of(17, 0), newYorkZone);
            ZonedDateTime tokyoAfternoon = nyAfternoon.withZoneSameInstant(tokyoZone);

            System.out.println("NY Day " + (day + 1) + " (" + currentDate + "):");
            System.out.println("  Tokyo: " + tokyoMorning.format(formatter) + " to " +
                    tokyoAfternoon.format(formatter));
        }
    }
}

파일을 저장합니다.

이제 이 Java 프로그램을 컴파일하고 실행해 보겠습니다.

cd ~/project
javac DateChangeAcrossTimeZones.java
java DateChangeAcrossTimeZones

다음과 유사한 출력을 볼 수 있습니다.

Date/Time Comparison:
New York: 2023-05-15 22:00:00 EDT
Tokyo:    2023-05-16 11:00:00 JST

Date Comparison:
New York date: 2023-05-15
Tokyo date:    2023-05-16
Same date? false

The date in Tokyo is after the date in New York

--- International Conference Example ---
Conference runs from June 1-3, 2023 (New York time, 9 AM - 5 PM daily)

Conference Schedule in Tokyo time:
NY Day 1 (2023-06-01):
  Tokyo: 2023-06-01 22:00:00 JST to 2023-06-02 06:00:00 JST
NY Day 2 (2023-06-02):
  Tokyo: 2023-06-02 22:00:00 JST to 2023-06-03 06:00:00 JST
NY Day 3 (2023-06-03):
  Tokyo: 2023-06-03 22:00:00 JST to 2023-06-04 06:00:00 JST

주요 관찰 사항

뉴욕에서 5 월 15 일 오후 10 시일 때 도쿄에서는 이미 5 월 16 일 오전 11 시입니다.
이러한 두 ZonedDateTime 객체에서 추출한 LocalDate 객체는 서로 다릅니다.
컨퍼런스 예제에서 뉴욕 컨퍼런스의 각 날짜는 도쿄에서 이틀에 걸쳐 진행됩니다.
뉴욕에서 오전 9 시에 시작하는 세션은 도쿄에서는 같은 날 오후 10 시에 시작합니다.
뉴욕에서 오후 5 시에 종료되는 세션은 도쿄에서는 다음 날 오전 6 시에 종료됩니다.

실용적인 응용 분야

시간대 간의 날짜 변경을 이해하는 것은 다음과 같은 경우에 중요합니다.

국제 행사: 참가자가 올바른 현지 날짜와 시간을 알 수 있도록 합니다.
글로벌 비즈니스 마감일: 각 현지 시간대에서 마감일이 언제 발생하는지 명확하게 전달합니다.
여행 계획: 시간대를 넘나드는 장거리 항공편의 도착 날짜를 정확하게 계산합니다.
계약 관리: 서로 다른 지역에서 만료일을 적절하게 결정합니다.

다음이자 마지막 단계에서는 실제 응용 프로그램에 대한 일반적인 시간대 변환 작업을 관리하는 데 도움이 되는 유틸리티 클래스를 만들 것입니다.

시간대 유틸리티 클래스 생성

이 마지막 단계에서는 일반적인 시간대 작업을 캡슐화하는 재사용 가능한 유틸리티 클래스를 만들 것입니다. 이를 통해 배운 개념을 실제 응용 프로그램에 대한 실용적인 도구를 만드는 데 적용하는 방법을 보여줍니다.

재사용 가능한 시간대 유틸리티 구축

일반적인 시간대 작업을 위한 메서드가 있는 유틸리티 클래스를 만들어 보겠습니다.

WebIDE 에서 /home/labex/project 디렉토리에 새 파일을 만듭니다.
파일 이름을 TimeZoneUtil.java로 지정합니다.
다음 코드를 추가합니다.

import java.time.*;
import java.time.format.DateTimeFormatter;
import java.util.List;
import java.util.ArrayList;

/**
 * Utility class for common time zone operations.
 */
public class TimeZoneUtil {

    // Common date time formatter
    private static final DateTimeFormatter FORMATTER =
            DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss z");

    /**
     * Converts a LocalDate to the same date in a specific time zone.
     * Uses start of day (midnight) in the target zone.
     */
    public static ZonedDateTime toZonedDateTime(LocalDate date, ZoneId zone) {
        return date.atStartOfDay(zone);
    }

    /**
     * Converts a date-time from one time zone to another,
     * preserving the same instant in time.
     */
    public static ZonedDateTime convertTimeZone(ZonedDateTime dateTime, ZoneId targetZone) {
        return dateTime.withZoneSameInstant(targetZone);
    }

    /**
     * Formats a ZonedDateTime object to a readable string.
     */
    public static String format(ZonedDateTime dateTime) {
        return dateTime.format(FORMATTER);
    }

    /**
     * Determines if a date-time in one zone falls on a different date
     * when converted to another zone.
     */
    public static boolean dateChangeOccurs(ZonedDateTime dateTime, ZoneId targetZone) {
        LocalDate originalDate = dateTime.toLocalDate();
        LocalDate targetDate = convertTimeZone(dateTime, targetZone).toLocalDate();
        return !originalDate.equals(targetDate);
    }

    /**
     * Gets the current date-time in multiple time zones.
     */
    public static List<ZonedDateTime> getCurrentDateTimeInZones(List<ZoneId> zones) {
        Instant now = Instant.now();
        List<ZonedDateTime> results = new ArrayList<>();

        for (ZoneId zone : zones) {
            results.add(now.atZone(zone));
        }

        return results;
    }
}

이제 유틸리티를 시연하기 위한 테스트 클래스를 만듭니다.
TimeZoneUtilDemo.java라는 새 파일을 만듭니다.
다음 코드를 추가합니다.

import java.time.*;
import java.util.Arrays;
import java.util.List;

public class TimeZoneUtilDemo {
    public static void main(String[] args) {
        // Define time zones we want to work with
        ZoneId newYorkZone = ZoneId.of("America/New_York");
        ZoneId londonZone = ZoneId.of("Europe/London");
        ZoneId tokyoZone = ZoneId.of("Asia/Tokyo");

        // Demonstrate converting LocalDate to ZonedDateTime
        LocalDate today = LocalDate.now();
        System.out.println("Today's date: " + today);

        ZonedDateTime todayInNewYork = TimeZoneUtil.toZonedDateTime(today, newYorkZone);
        System.out.println("Today at midnight in New York: " + TimeZoneUtil.format(todayInNewYork));

        // Demonstrate converting between time zones
        ZonedDateTime todayInTokyo = TimeZoneUtil.convertTimeZone(todayInNewYork, tokyoZone);
        System.out.println("Same instant in Tokyo: " + TimeZoneUtil.format(todayInTokyo));

        // Demonstrate date change detection
        ZonedDateTime eveningInNewYork = ZonedDateTime.of(
                today, LocalTime.of(22, 0), newYorkZone);
        boolean dateChanges = TimeZoneUtil.dateChangeOccurs(eveningInNewYork, tokyoZone);
        System.out.println("\n10 PM in New York is on a different date in Tokyo: " + dateChanges);

        // Show the actual times
        System.out.println("New York: " + TimeZoneUtil.format(eveningInNewYork));
        System.out.println("Tokyo: " + TimeZoneUtil.format(
                TimeZoneUtil.convertTimeZone(eveningInNewYork, tokyoZone)));

        // Demonstrate getting current time in multiple zones
        System.out.println("\nCurrent time in different zones:");
        List<ZoneId> zones = Arrays.asList(newYorkZone, londonZone, tokyoZone);
        List<ZonedDateTime> currentTimes = TimeZoneUtil.getCurrentDateTimeInZones(zones);

        for (int i = 0; i < zones.size(); i++) {
            System.out.println(zones.get(i).getId() + ": " +
                    TimeZoneUtil.format(currentTimes.get(i)));
        }

        // Business use case: Meeting planning
        System.out.println("\n--- Business Meeting Planning ---");
        // Plan for a 2 PM meeting in New York
        LocalDate meetingDate = LocalDate.now().plusDays(7); // Meeting next week
        LocalTime meetingTime = LocalTime.of(14, 0); // 2 PM
        ZonedDateTime meetingInNewYork = ZonedDateTime.of(meetingDate, meetingTime, newYorkZone);

        System.out.println("Meeting scheduled for: " + TimeZoneUtil.format(meetingInNewYork));
        System.out.println("For attendees in London: " +
                TimeZoneUtil.format(TimeZoneUtil.convertTimeZone(meetingInNewYork, londonZone)));
        System.out.println("For attendees in Tokyo: " +
                TimeZoneUtil.format(TimeZoneUtil.convertTimeZone(meetingInNewYork, tokyoZone)));

        // Check for date changes
        boolean londonDateChange = TimeZoneUtil.dateChangeOccurs(meetingInNewYork, londonZone);
        boolean tokyoDateChange = TimeZoneUtil.dateChangeOccurs(meetingInNewYork, tokyoZone);

        if (londonDateChange) {
            System.out.println("Note: The meeting is on a different date in London!");
        }

        if (tokyoDateChange) {
            System.out.println("Note: The meeting is on a different date in Tokyo!");
        }
    }
}

두 파일을 모두 저장합니다.

이제 데모를 컴파일하고 실행해 보겠습니다.

cd ~/project
javac TimeZoneUtil.java TimeZoneUtilDemo.java
java TimeZoneUtilDemo

다음과 유사한 출력을 볼 수 있습니다.

Today's date: 2023-10-23
Today at midnight in New York: 2023-10-23 00:00:00 EDT
Same instant in Tokyo: 2023-10-23 13:00:00 JST

10 PM in New York is on a different date in Tokyo: true
New York: 2023-10-23 22:00:00 EDT
Tokyo: 2023-10-24 11:00:00 JST

Current time in different zones:
America/New_York: 2023-10-23 13:45:23 EDT
Europe/London: 2023-10-23 18:45:23 BST
Asia/Tokyo: 2023-10-24 02:45:23 JST

--- Business Meeting Planning ---
Meeting scheduled for: 2023-10-30 14:00:00 EDT
For attendees in London: 2023-10-30 18:00:00 GMT
For attendees in Tokyo: 2023-10-31 03:00:00 JST
Note: The meeting is on a different date in Tokyo!

유틸리티 클래스의 장점

TimeZoneUtil 클래스는 다음과 같은 몇 가지 이점을 제공합니다.

캡슐화 (Encapsulation): 일반적인 시간대 작업이 단일 클래스에 캡슐화됩니다.
재사용성: 메서드는 애플리케이션의 다른 부분에서 재사용할 수 있습니다.
유지 관리 용이성: 시간대 처리에 대한 변경 사항을 한 곳에서 수행할 수 있습니다.
가독성: 유틸리티 클래스를 사용하는 코드는 더 깔끔하고 집중적입니다.

실제 응용 분야

이 유틸리티 클래스는 다음과 같은 많은 실제 시나리오에서 유용할 수 있습니다.

국제 비즈니스 애플리케이션: 시간대 간의 회의, 마감일 및 영업 시간 관리
여행 애플리케이션: 항공편 도착 시간 및 예약 기간 계산
글로벌 이벤트 관리: 서로 다른 시간대에 있는 참가자를 위한 이벤트 계획 및 일정 관리
전자 상거래: 주문 마감 시간, 배송 날짜 및 배송 기간 관리

주요 내용

이 랩에서는 다음을 배우셨습니다.

시간대 처리를 위해 Java Time API 를 사용하는 방법
LocalDate 객체를 생성하고 조작하는 방법
ZonedDateTime을 사용하여 날짜에 시간대를 적용하는 방법
서로 다른 시간대 간에 변환하는 방법
시간대 간의 날짜 변경을 처리하는 방법
시간대 작업을 위한 재사용 가능한 유틸리티 클래스를 만드는 방법

이러한 기술은 서로 다른 시간대에서 날짜와 시간을 올바르게 처리하는 강력한 Java 애플리케이션을 구축하는 데 도움이 됩니다.

요약

이 랩에서는 실용적인 실습 예제를 통해 Java 시간대와 LocalDate 객체를 사용하는 방법을 배웠습니다. 다음 내용을 살펴보았습니다.

Java Time API 및 시간대 개념의 기본 사항
LocalDate 객체를 생성하고 시간대를 적용하는 방법
서로 다른 시간대 간의 날짜 변환
멀리 떨어진 시간대 간 변환 시 발생하는 날짜 변경 처리
일반적인 시간대 작업을 위한 재사용 가능한 유틸리티 클래스 생성

이러한 기술은 서로 다른 지역에서 날짜 및 시간 정보를 올바르게 처리하는 강력한 Java 애플리케이션을 개발하는 데 필수적입니다. 국제 비즈니스 애플리케이션, 여행 서비스 또는 글로벌 이벤트 관리 시스템을 구축하든, 배운 기술은 시간대 문제를 효과적으로 관리하는 데 도움이 될 것입니다.

이 랩에서 얻은 지식을 통해 Java 애플리케이션에서 날짜 및 시간 처리를 자신 있게 구현하여 사용자가 위치에 관계없이 정확하고 일관된 정보를 받을 수 있도록 할 수 있습니다.

Java 에서 LocalDate 의 시간대 설정 방법

소개

Java Time API 기본 이해

Java Time API 주요 클래스

첫 번째 시간대 프로그램 만들기

LocalDate 객체 생성 및 시간대 적용

LocalDate 의 제한 사항 이해

시연된 주요 개념

중요한 참고 사항

시간대 간 날짜 변환

시간대 변환 이해

시간대 변환을 위한 주요 메서드

중요한 관찰 사항

시간대 간 날짜 변경 처리

날짜 변경 문제

주요 관찰 사항

실용적인 응용 분야

시간대 유틸리티 클래스 생성

재사용 가능한 시간대 유틸리티 구축

유틸리티 클래스의 장점

실제 응용 분야

주요 내용

요약