[JAVA] 날짜와 시간

시간은 언제나 개발자에게 골칫거리였다.
단순한 날짜 출력부터 시작해, 시간 간격 계산, 시차 반영, 일광 절약 시간제 적용까지, 정확하게 구현하려 할수록 복잡도는 기하급수적으로 증가한다.

이런 문제를 해결하기 위해 자바 8에서는 새로운 날짜와 시간 API인 java.time 패키지를 도입했다.

이 글에서는 java.time이 왜 필요한지, 어떤 구조로 되어 있는지, 그리고 실무에서 어떻게 활용할 수 있는지를 단계적으로 정리한다.

 

1. 날짜와 시간 라이브러리가 필요한 이유

날짜와 시간을 다룰 때 단순한 덧셈이나 뺄셈만으로는 정확한 처리가 어렵다.
실제 시간 계산은 다음과 같은 문제들로 인해 복잡해진다.

1) 윤년 계산

지구가 태양을 한 바퀴 도는 데 걸리는 시간은 약 365.2425일이다. 이를 보정하기 위해 윤년이 도입되었으며, 4년에 한 번씩 2월 29일이 추가된다. 하지만 윤년은 4의 배수라고 해서 무조건 적용되는 것이 아니라, 100으로 나누어 떨어지면 제외되고, 다시 400으로 나누어 떨어지면 윤년이 되는 복잡한 규칙을 따른다. 예를 들어, 2000년은 윤년이지만 1900년은 윤년이 아니다.

2) 월별 날짜 수 차이

각 월은 28일, 30일, 31일 등 다양한 일수를 가진다. 예를 들어, 1월과 3월은 31일, 4월은 30일, 2월은 28일 또는 29일이다. 날짜 연산 시 이러한 차이를 고려하지 않으면 잘못된 결과를 초래할 수 있다.

3) 일광 절약 시간(DST)

일부 국가는 여름철에 표준 시간보다 1시간을 앞당겨 사용하는 일광 절약 시간제를 시행한다. 미국 뉴욕의 경우 3월 둘째 주부터 11월 첫째 주까지 DST가 적용되며, 이 기간에는 UTC 오프셋이 –4:00으로 바뀐다. 이를 반영하지 않고 단순 시간차만 계산할 경우 오차가 발생한다.

4) 타임존(Time Zone)

세계는 UTC 기준으로 여러 시간대로 나뉘어 있다. 같은 시각이라도 지역에 따라 다른 시간을 가지며, 타임존에 따라 자동 조정되는 방식이 필요하다. 예를 들어 서울은 UTC+9, 뉴욕은 DST 적용 여부에 따라 UTC–5 또는 –4이다.

이러한 복잡한 요소를 수동으로 계산하는 것은 비효율적이며 오류 가능성이 크다. 따라서 자바는 이를 자동으로 처리하기 위해 java.time 패키지를 제공한다.

 

2. java.time 패키지의 핵심 구성

자바 8부터 도입된 java.time 패키지는 Joda-Time 라이브러리의 설계를 참고하여 다음과 같은 구조를 제공한다.

• LocalDate, LocalTime, LocalDateTime: 타임존을 고려하지 않는 날짜 및 시간
• ZonedDateTime, OffsetDateTime: 시간대와 오프셋을 포함한 시간 표현
• Instant: UTC 기준의 절대 시간
• Period, Duration: 시간 간격을 나타내는 객체
• ChronoUnit, ChronoField: 시간의 단위 및 필드 정의
• DateTimeFormatter: 날짜와 시간의 포맷팅 및 파싱 처리

패키지 전체는 불변 객체(immutable)를 중심으로 구성되어 있어, 멀티스레드 환경에서도 안전하게 사용할 수 있다. 또한 메서드 체이닝과 명확한 API 설계로 코드 가독성이 높고, 로직 작성이 단순해진다.

 

 

3. 날짜와 시간을 나타내는 주요 클래스

java.time 패키지는 날짜와 시간 정보를 처리하는 데 특화된 다양한 클래스를 제공한다. 그중에서도 가장 기본이 되는 세 가지 클래스는 LocalDate, LocalTime, LocalDateTime이다. 이들은 타임존을 고려하지 않는 지역(local) 기반의 시간 표현에 적합하다.

 

3.1 LocalDate

LocalDate는 날짜만 표현하는 클래스이다. 시간 정보는 포함하지 않으며, 내부적으로 연(year), 월(month), 일(day) 정보를 가진다.

주요 기능

• 날짜 생성: 현재 날짜 또는 특정 날짜 생성
• 날짜 계산: 날짜 더하기, 빼기
• 날짜 비교: 이전/이후 여부 판단
• 날짜 필드 조회: 연도, 월, 일 등 개별 필드 조회

예시코드:

import java.time.LocalDate;

public class LocalDateExample {
    public static void main(String[] args) {
        LocalDate today = LocalDate.now();
        LocalDate birthDate = LocalDate.of(1990, 5, 15);

        LocalDate nextWeek = today.plusWeeks(1);
        boolean isBefore = birthDate.isBefore(today);

        System.out.println("오늘 날짜: " + today);
        System.out.println("태어난 날짜: " + birthDate);
        System.out.println("다음 주: " + nextWeek);
        System.out.println("생일이 오늘보다 이전인가? " + isBefore);
    }
}

 

 

3.2 LocalTime

LocalTime은 시간만 표현하는 클래스이다. 날짜 정보는 없으며, 시(hour), 분(minute), 초(second), 나노초(nanosecond) 단위를 지원한다.

주요 기능

• 시간 생성: 현재 시간 또는 특정 시간 생성
• 시간 계산: 시, 분, 초 더하기/빼기
• 시간 비교: 이전/이후 판단
• 시간 필드 조회: 시, 분, 초 값 얻기

예시코드:

import java.time.LocalTime;

public class LocalTimeExample {
    public static void main(String[] args) {
        LocalTime now = LocalTime.now();
        LocalTime meeting = LocalTime.of(14, 30);

        LocalTime after30Min = meeting.plusMinutes(30);

        System.out.println("현재 시간: " + now);
        System.out.println("회의 시간: " + meeting);
        System.out.println("회의 종료 예상 시간: " + after30Min);
    }
}

 

 

3.3 LocalDateTime

LocalDateTime은 LocalDate와 LocalTime을 합친 형태로, 날짜와 시간을 모두 포함하는 클래스이다. 타임존은 포함되지 않는다.

주요 기능

• 날짜와 시간 동시 생성
• 날짜 및 시간 계산
• 날짜 또는 시간 부분 분리 가능 (toLocalDate(), toLocalTime())
• 비교 및 연산 가능

예시코드:

import java.time.LocalDateTime;
import java.time.LocalDate;
import java.time.LocalTime;

public class LocalDateTimeExample {
    public static void main(String[] args) {
        LocalDateTime now = LocalDateTime.now();
        LocalDateTime appointment = LocalDateTime.of(2025, 12, 1, 10, 0);

        LocalDateTime reminder = appointment.minusDays(1);

        LocalDate datePart = appointment.toLocalDate();
        LocalTime timePart = appointment.toLocalTime();

        System.out.println("현재 날짜와 시간: " + now);
        System.out.println("예약 시간: " + appointment);
        System.out.println("하루 전 알림 시간: " + reminder);
        System.out.println("예약 날짜만: " + datePart);
        System.out.println("예약 시간만: " + timePart);
    }
}

 

 

4. 시간대(Time Zone) 처리: ZonedDateTime, OffsetDateTime

날짜와 시간의 정확한 처리를 위해서는 타임존(Time Zone) 개념을 고려해야 한다.
같은 시각이라도 지역마다 시간이 다르며, 일광 절약 시간제(DST)가 적용되는 경우에는 시차가 자동으로 조정되기도 한다. 이러한 문제를 처리하기 위해 자바는 ZonedDateTime과 OffsetDateTime 클래스를 제공한다.

 

 

 

4.1 ZonedDateTime

ZonedDateTime은 날짜(LocalDate), 시간(LocalTime), 시간대(ZoneId) 정보를 모두 포함한다.
서울, 뉴욕, 런던 등 지리적 위치 기반의 시간대를 명시할 수 있으며, 해당 지역의 일광 절약 시간제(DST)도 자동 반영된다.

주요 특징

• 시간대(Asia/Seoul, America/New_York)를 기준으로 날짜와 시간을 나타낸다.
• 일광 절약 시간제(DST) 적용 여부를 자동 계산한다.
• withZoneSameInstant()을 사용해 동일 시점을 다른 시간대로 변환할 수 있다.

예시코드:

import java.time.*;

public class ZonedDateTimeExample {
    public static void main(String[] args) {
        ZonedDateTime seoulTime = ZonedDateTime.of(
            LocalDate.of(2024, 1, 1),
            LocalTime.of(9, 0),
            ZoneId.of("Asia/Seoul")
        );

        ZonedDateTime londonTime = seoulTime.withZoneSameInstant(ZoneId.of("Europe/London"));
        ZonedDateTime newYorkTime = seoulTime.withZoneSameInstant(ZoneId.of("America/New_York"));

        System.out.println("서울 회의 시간: " + seoulTime);
        System.out.println("런던 기준 시간: " + londonTime);
        System.out.println("뉴욕 기준 시간: " + newYorkTime);
    }
}

 

 

• withZoneSameInstant() 메서드는 동일한 순간(Instant*을 다른 시간대로 변환한다. 즉, 서울 오전 9시는 런던 기준 자정, 뉴욕 기준 전날 오후 7시이다.
• 이는 단순히 시각만 바꾸는 것이 아니라, 세계 표준시(UTC) 기준의 동일 시점을 다른 시간대로 정확히 반영하는 방식이다.

 

 

4.2 OffsetDateTime

OffsetDateTime은 날짜와 시간에 고정된 UTC 오프셋을 포함하는 클래스이다.
지역(예: 서울, 뉴욕)에 기반한 시간대 정보는 포함하지 않으며, 단지 UTC 기준 몇 시간 차이가 나는지만 나타낸다.

주요 특징

• UTC로부터의 오프셋(예: +09:00)을 포함
• 타임존 식별자(Asia/Seoul)는 포함되지 않음
• 일광 절약 시간제를 고려하지 않음
• 로그 기록, 표준 시간 저장 등에 적합

import java.time.*;

public class OffsetDateTimeExample {
    public static void main(String[] args) {
        LocalDateTime ldt = LocalDateTime.of(2024, 1, 1, 9, 0);
        OffsetDateTime offsetTime = OffsetDateTime.of(ldt, ZoneOffset.of("+09:00"));

        System.out.println("UTC+9 기준 시간: " + offsetTime);
    }
}

 

 

5. 기계 중심 시간 표현: Instant

Instant는 자바에서 절대 시간(Absolute Time)을 표현하는 클래스다.
기준점은 1970년 1월 1일 0시 0분 0초(UTC)이며, 이를 에포크(Epoch)라고 한다.
Instant는 이 기준으로부터의 경과 시간을 초(second) 또는 나노초(nanosecond) 단위로 저장한다.

사람이 보기 편한 날짜나 시간 정보는 포함하지 않고, 오직 "시점"만을 표현한다.

 

5.1 특징

• UTC 기준의 시점을 저장한다.
• 나노초 단위의 정밀도 제공.
• 타임존 정보는 포함하지 않음.
• 불변 객체로 스레드 안전하다.
• 시스템 간 시간 동기화, 타임스탬프 비교에 적합하다

예시코드:

import java.time.Instant;
import java.time.ZonedDateTime;
import java.time.ZoneId;

public class InstantExample {
    public static void main(String[] args) {
        Instant now = Instant.now(); // 현재 UTC 기준 시각
        System.out.println("현재 시각 (UTC 기준): " + now);

        // ZonedDateTime에서 Instant 추출
        ZonedDateTime seoulTime = ZonedDateTime.of(
            2024, 1, 1, 9, 0, 0, 0,
            ZoneId.of("Asia/Seoul")
        );
        Instant instantFromZoned = seoulTime.toInstant();
        System.out.println("서울 오전 9시의 UTC 시점: " + instantFromZoned);

        // Instant에서 다시 ZonedDateTime으로 변환
        ZonedDateTime utcConverted = instantFromZoned.atZone(ZoneId.of("UTC"));
        System.out.println("UTC 기준 시간: " + utcConverted);
    }
}

 

결과 화면:

현재 시각 (UTC 기준): 2024-01-01T00:05:10.123456Z
서울 오전 9시의 UTC 시점: 2024-01-01T00:00:00Z
UTC 기준 시간: 2024-01-01T00:00Z[UTC]

 

 

6. 시간 간격 표현: Duration, Period

시간의 정보는 단순히 "언제"만 중요한 것이 아니라, 얼마나 남았는지, 얼마나 지났는지도 중요하다.
자바의 날짜/시간 API에서는 시간의 간격(기간)을 표현하기 위해 두 가지 클래스를 사용한다:

• Period: 날짜 기반 간격 (년, 월, 일)
• Duration: 시간 기반 간격 (시, 분, 초, 나노초)

이 두 클래스는 모두 불변 객체(immutable)이며, TemporalAmount라는 공통 인터페이스를 구현한다.

 

6.1 Period – 날짜 간격

Period는 두 날짜 사이의 간격을 년/월/일 단위로 나타낸다.
예를 들어, 생일까지 며칠 남았는지, 프로젝트 마감일까지 몇 개월 남았는지를 계산할 때 사용한다.

주요 특징

• 단위: 연도, 월, 일
• 날짜 기반(LocalDate) 연산에 사용됨
• 시간 정보는 포함하지 않음

예시코드:

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

public class PeriodExample {
    public static void main(String[] args) {
        LocalDate today = LocalDate.of(2025, 7, 6);
        LocalDate deadline = LocalDate.of(2025, 10, 15);

        Period untilDeadline = Period.between(today, deadline);

        System.out.println("남은 기간: " + untilDeadline.getMonths() + "개월 "
                           + untilDeadline.getDays() + "일");
    }
}

 

결과화면:

남은 기간: 3개월 9일

 

6.2 Duration – 시간 간격

Duration은 두 시각 사이의 간격을 초/분/시/나노초 단위로 계산한다.
예를 들어, 회의 시간이 몇 분 걸렸는지, 시스템 처리 시간이 몇 초인지 등을 측정할 때 사용한다.

주요 특징

• 단위: 초, 밀리초, 나노초
• 시간 기반(LocalTime, LocalDateTime, Instant) 연산에 사용됨
• 날짜 정보는 포함하지 않음

예시 코드:

import java.time.Duration;
import java.time.LocalDateTime;

public class DurationExample {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2025, 7, 6, 14, 0);
        LocalDateTime end = LocalDateTime.of(2025, 7, 6, 15, 30);

        Duration meetingDuration = Duration.between(start, end);

        System.out.println("회의 시간(분): " + meetingDuration.toMinutes());
    }
}

 

결과화면:

회의 시간(분): 90

 

 

7. 날짜와 시간 조작 및 비교

자바의 날짜·시간 API는 단순한 조회를 넘어서, 날짜와 시간을 조작(add, subtract)하거나 비교하는 기능을 제공한다. 실무에서는 일정 조정, 마감일 연장, 시작일 계산, 기간 비교 등의 작업이 자주 발생한다.

java.time 패키지에서는 모든 날짜/시간 객체가 불변 객체(immutable)이기 때문에 조작 메서드는 기존 값을 변경하지 않고 새로운 인스턴스를 반환한다.

 

7.1 날짜 및 시간 더하기 / 빼기

모든 날짜/시간 클래스(LocalDate, LocalTime, LocalDateTime 등)는 다음과 같은 메서드를 제공한다:

• plusXxx(): 날짜/시간을 더함
• minusXxx(): 날짜/시간을 뺌
• plus(long amount, TemporalUnit unit): 단위와 함께 사용
• minus(long amount, TemporalUnit unit): 단위와 함께 사용

예시 코드１(날짜 더하고 빼기)

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;

public class DateAddSubtractExample {
    public static void main(String[] args) {
        LocalDate today = LocalDate.of(2025, 7, 6);

        LocalDate plusTenDays = today.plusDays(10);
        LocalDate minusThreeMonths = today.minusMonths(3);
        LocalDate plusPeriod = today.plus(2, ChronoUnit.YEARS);

        System.out.println("오늘 날짜: " + today);
        System.out.println("10일 후: " + plusTenDays);
        System.out.println("3개월 전: " + minusThreeMonths);
        System.out.println("2년 후: " + plusPeriod);
    }
}

 

예시코드2 (시간 더하고 빼기)

import java.time.LocalTime;

public class TimeAddSubtractExample {
    public static void main(String[] args) {
        LocalTime now = LocalTime.of(14, 30); // 오후 2시 30분

        LocalTime after2Hours = now.plusHours(2);
        LocalTime before15Minutes = now.minusMinutes(15);

        System.out.println("현재 시간: " + now);
        System.out.println("2시간 후: " + after2Hours);
        System.out.println("15분 전: " + before15Minutes);
    }
}

 

7.2 날짜/시간 비교하기

날짜와 시간을 비교할 때는 다음 메서드를 사용할 수 있다:

• isBefore(다른시점): 이 시점이 다른 시점보다 이전인지
• isAfter(다른시점): 이 시점이 다른 시점보다 이후인지
• isEqual(다른시점): 동일한 시점인지

예시코드3 (날짜 비교)

import java.time.LocalDate;

public class DateComparisonExample {
    public static void main(String[] args) {
        LocalDate d1 = LocalDate.of(2025, 5, 1);
        LocalDate d2 = LocalDate.of(2025, 7, 6);

        System.out.println("d1이 d2보다 이전인가? " + d1.isBefore(d2));
        System.out.println("d1이 d2보다 이후인가? " + d1.isAfter(d2));
        System.out.println("d1과 d2가 같은가? " + d1.isEqual(d2));
    }
}

 

결과화면:

d1이 d2보다 이전인가? true
d1이 d2보다 이후인가? false
d1과 d2가 같은가? false

 

 

8. 시간의 단위와 필드: ChronoUnit, ChronoField

자바의 날짜/시간 객체는 다양한 단위(예: 년, 월, 시, 분 등)로 구성된다. 이러한 단위를 명확히 표현하기 위해 자바는 다음 두 가지 열거형(enum)을 제공한다.

• ChronoUnit: 시간을 측정하는 기준 단위
• ChronoField: 날짜와 시간의 세부 항목(필드)

이 두 가지는 TemporalUnit, TemporalField라는 인터페이스를 구현하며, 시간 데이터를 세밀하게 조작하거나 조회할 수 있도록 해준다.

 

ChoronoUnit:

 

 

 

ChronoFiled:

 

 

위 요소들은 모두 외울 필요 없다. 기본기를 익힌 후 필요할때 찾아서 구현하는 방식을 추천한다.

 

 

8.1 ChronoUnit – 시간의 단위

ChronoUnit은 시간을 측정하는 기준 단위를 나타낸다. 대표적으로는 YEARS, MONTHS, DAYS, HOURS, MINUTES, SECONDS, MILLIS, NANOS 등이 있다.

사용 목적

• plus(), minus() 같은 메서드에 단위로 전달
• 두 날짜/시간 사이의 간격 계산

예시코드1 (ChronoUnit 사용)

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitExample {
    public static void main(String[] args) {
        LocalDateTime start = LocalDateTime.of(2024, 1, 1, 9, 0);
        LocalDateTime end = LocalDateTime.of(2025, 7, 6, 15, 30);

        long days = ChronoUnit.DAYS.between(start, end);
        long hours = ChronoUnit.HOURS.between(start, end);

        System.out.println("두 날짜 사이의 일수: " + days);
        System.out.println("두 날짜 사이의 시간 수: " + hours);
    }
}

 

결과화면:

두 날짜 사이의 일수: 552
두 날짜 사이의 시간 수: 13257

 

 

8.2 ChronoField – 시간의 세부 항목

ChronoField는 날짜나 시간의 각각의 세부 항목을 나타내며, 다음과 같은 항목들을 제공한다:

필드명의미

YEAR	연도
MONTH_OF_YEAR	월 (1~12)
DAY_OF_MONTH	일 (1~31)
HOUR_OF_DAY	시 (0~23)
MINUTE_OF_HOUR	분 (0~59)
SECOND_OF_MINUTE	초 (0~59)

 

이러한 필드를 사용하면 날짜/시간 객체에서 특정 부분만 조회하거나 수정할 수 있다.

 

예시코드2 (ChronoField)

import java.time.LocalDateTime;
import java.time.temporal.ChronoField;

public class ChronoFieldExample {
    public static void main(String[] args) {
        LocalDateTime dt = LocalDateTime.of(2025, 12, 25, 15, 45, 30);

        int year = dt.get(ChronoField.YEAR);
        int month = dt.get(ChronoField.MONTH_OF_YEAR);
        int hour = dt.get(ChronoField.HOUR_OF_DAY);

        System.out.println("연도: " + year);
        System.out.println("월: " + month);
        System.out.println("시: " + hour);
    }
}

 

결과화면:

연도: 2025
월: 12
시: 15

 

 

9. 날짜와 시간 포맷팅과 파싱 – DateTimeFormatter

자바에서는 날짜와 시간을 문자열로 변환하거나 문자열을 날짜/시간 객체로 해석할 때, java.time.format.DateTimeFormatter를 사용한다. 이 클래스는 형식을 지정할 수 있는 불변 객체이며, 패턴 기반 포맷 문자열 또는 미리 정의된 포맷 상수를 사용할 수 있다.

9.1 날짜와 시간 → 문자열 (포맷팅)

날짜나 시간을 사람이 읽을 수 있도록 문자열로 변환하는 과정이다.
예: 2025-07-06T15:30 → "2025년 07월 06일 오후 3시 30분"

 

예시코드1:

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

public class FormatExample {
    public static void main(String[] args) {
        LocalDateTime dateTime = LocalDateTime.of(2025, 7, 6, 15, 30);

        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String formatted = dateTime.format(formatter);

        System.out.println("포맷된 날짜: " + formatted);
    }
}

 

 

결과화면:

포맷된 날짜: 2025-07-06 15:30:00

 

 

DateTimeFormatter 패턴(공식 사이트) 

 

9.2 문자열 → 날짜와 시간 (파싱)

문자열 데이터를 날짜/시간 객체로 변환하는 과정이다.
예: "2025-12-25" → LocalDate.of(2025, 12, 25)

 

파싱 예제코드:

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

public class ParseExample {
    public static void main(String[] args) {
        String input = "2025-12-25";
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");

        LocalDate date = LocalDate.parse(input, formatter);
        System.out.println("파싱된 날짜: " + date);
    }
}

 

결과화면:

파싱된 날짜: 2025-12-25

 

9.3 포맷팅과 파싱의 주의사항

• 포맷 문자열은 대소문자 구분을 엄격히 한다.
  MM(월)과 mm(분)은 다르다.
• parse()는 문자열이 정확히 지정된 형식과 일치해야 한다.
• DateTimeFormatter는 Locale을 지정할 수도 있다.
  (예: 영어, 한글 등)

 

마무리하며:

날짜와 시간은 프로그래밍에서 가장 많이 다루면서도 자주 실수하는 주제 중 하나다.
특히 시간대, 포맷, 시간 간격 계산 등은 작은 실수 하나로도 서비스 전체의 신뢰도를 흔들 수 있다.

 

java.time 패키지는 이런 문제들을 해결하기 위해 도입된 강력한 API다.
복잡한 시간 계산도 더 이상 외울 필요 없이, 설계된 클래스를 적절히 조합해 사용하면 정확하고 명확하게 처리할 수 있다.

 

이 글에서는 LocalDate, ZonedDateTime, Duration, DateTimeFormatter 등
날짜와 시간 처리에 필요한 주요 구성 요소들을 단계적으로 살펴봤다.
자바 8 이후의 개발을 진행한다면, 이제 더 이상 Date나 Calendar에 의존하지 않아도 된다.

 

시간을 다룰 때마다 이 정리글이 작은 길잡이가 되어주길 바란다.

 

감사합니다.