Chapter 10 날짜와 시간 & 형식화

 

 

날짜와 시간 관련 클래스 및 패키지

 

① java.util.Date

• 날짜와 시간을 다룰 목적으로 만들어진 클래스
• Date 클래스의 메서드는 거의 deprecated 되어있음
  • Java API 문서에 더 이상 사용을 권장하지 않는 대상에 deprecated가 붙어있음
• 항상 날짜와 시간을 같이 다룸 (단점)
• 안쓰는 것을 추천
• java.util.Date클래스와 java.sql.Date 클래스는 서로 다른 클래스

 

② java.util.Calendar

• Date 클래스를 개선한 새로운 클래스
• 항상 날짜와 시간을 같이 다룸 (단점)
• 덜 쓰는 것을 추천

 

③ java.time 패키지

• Date와 Calendar의 단점을 개선한 새로운 클래스
• time 패키지 쓸 것을 추천
• 날짜와 시간을 따로 다룰 수 있음 (장점)
  • 날짜 : LocalDate
  • 시간 : LocalTime
  • 날짜와 시간 같이 다룸 : LocalDateTime

 

 

 

 

 

▒ 날짜와 시간

 

◎ Calendar 클래스

• 추상 클래스이므로 직접 인스턴스 생성 못함
  •  Calendar cal = new Calendar();    → 에러!!
• getInstance() 메서드를 통해서 완전히 구현된 클래스의 인스턴스를 얻어야함
  • Calendar cal = Calendar.getInstance();  → OK.
• import java.util.Calendar; 쓸 것
• Calendar 클래스는 불변이 아닌 변경이 가능하므로 멀티 쓰레드 환경에서 안전하지 못함

 

 

□ Calendar 클래스 생성

Calendar cal = Calendar.getInstance();  // ok.

// Calendar cal = new Calendar();  // 에러. 추상클래스이므로 직접 인스턴스 생성 못함

 

 

■  Date와 Calendar 변환

• Date 클래스의 메서드는 잘 안쓰이지만 Date 클래스를 필요로 하는 메서드가 있음

□ Calendar → Date 변환

Calendar cal = Calendar.getInstance();

Date d = new Date(cal.getTimeInMillis());

 

 

□ Date → Calendar 변환

Date d = new Date();

Calendar cal = Calendar.getInstance();

cal.setTime(d);

 

■ Calender 클래스의 상수

필드명	설명
static int YEAR	년
static int MONTH	월 (0부터 시작)  ex) 0월 → 실질적으로 1 월 의미
static int WEEK_OF_YEAR	그 해의 몇 번 째 주 ( 1월1일부터 ~ 지금까지 몇번 째 주인지)
static int WEEK_OF_MONTH	그 달의 몇 번째 주
static int DATE	일  (= DAY_OF_MONTH 와 기능 동일)
static int DAY_OF_MONTH	그 달의 몇 번째 일 (= DATE와 기능 동일 )
static int DAY_OF_YEAR	그 해의 몇 번재 일 (1월1일부터 며칠 지났는지)
static int DAY_OF_WEEK	요일 (범위 : 1~7),  1 : 일요일. 2 : 월요일, 3 : 화요일 .....
static int DAY_OF_WEEK_IN_MONTH	그 달의 몇 번째 요일
static int HOUR	시간 (0~11)
static int HOUR_OF_DAY	시간(0~23)
static int MINUTE	분
static int SECOND	초
static int MILLISECOND	천분의 일초 (1/1000 초)  (범위 : 0~999)
static int ZONE_OFFSET	GMT 기준 시차 (천분의 일초 단위) 시간 단위로 값을 얻고 싶으면 (60*60*1000)을 나눠야함 시간 단위로 값을 얻을 때 나올 수 있는 값 범위 : -12 ~ 12 한국은 9시간 차이가 나므로 시간 단위로 값을 구하면 9 반환
static int AM_PM	오전/오후 구별. (0 : 오전, 1: 오후)
static int AM	오전
static int PM	오후

 

필드명	설명
static int JANUARY	0 (1월)
static int FEBRUARY	1 (2월)
static int MARCH	2 (3월)
static int APRIL	3 (4월)
static int MAY	4 (5월)
static int JUNE	5 (6월)
static int JULY	6 (7월)
static int AUGUST	7 (8월)
static int SEPTEMBER	8 (9월)
static int OCTOBER	9 (10월)
static int NOVEMBER	10 (11월)
static int DECEMBER	11 (12월)

 

필드명	설명
static int SUNDAY	1 (일요일)
static int MONDAY	2 (월요일)
static int TUESDAY	3 (화요일)
static int WEDNESDAY	4 (수요일)
static int THURSDAY	5 (목요일)
static int FRIDAY	6 (금요일)
static int SATURDAY	7 (토요일)

 

■ Calendar 클래스의 메서드

반환타입 메서드	설명
static Calendar getInstance()	시스템의 현재 날짜와 시간으로 Calendar 인스턴스 반환 원하는 날짜나 시간으로 설정하려면 set 메서드 사용할 것
int get(int field)	인스터스에 담긴 정보를 필드(상수)값을 이용해서 반환
int getActualMaximum(int field)	특정한 달의  말일 구할 때 사용됨 ex)  getActualMaximum(Calendar.DATE)
void set(int field, int value)	원하는 날짜와 시간으로 변경 ex) set(Calendar.YEAR, 2020) → 2020년으로 변경
void set(int year, int month, int date) void set(int year, int month, int date, int hourOfDay, int minute) void set(int year, int month, int date, int hourOfDay, int minute, int second)	원하는 날짜와 시간으로 변경 ex) set(2019, 12, 25, 5, 30, 25) → 2019년 12월 25일 5시 30분 25초로 변경 YEAR, MONTH, DAY_OF_MONTH, HOUR_OF_DAY, MINUTE, SECODN  필드(상수)값 대입
void clear() void clear(int field)	모든 필드 초기화 필드값 지정시, 지정된 필드 값을 기본 값으로 초기화 각 필드의 기본값은 JAVA API 문서의 GregorianCalendar 참고
long getTimeInMillis()	해당 인스턴스의 시간을 천분의 일초 단위로 변환후 반환  1970년 1월 1일 이전 날짜에 대해서는 음수 값 반환
boolean after(Object when)	해당 인스턴스가 when 객체보다 시간이 이후면 true, 아니면 false
boolean before(Object when)	해당 인스턴스가 when 객체보다 시간이 이전이면 true, 아니면 false
abstract void add(int field, int amount)	지정한 필드값을 원하는 만큼 증가 또는 감소시킬 수 있음 지정된 필드값의 변경으로 다른 필드값에게도 영향을 줄 수 있음 ex) 일수를 추가해서 달이 바뀌는 경우 등등
void roll(int field, int amount)	지정한 필드값을 원하는 만큼 증가 또는 감소시킬 수 있음 지정된 필드값의 변경으로 다른 필드값에게 영향 안줌 영향을 줄 수 있는 예외 : 필드값이 일(Calendar.DATE)필드 값이 말일(end of month)인데 roll()메서드를 통해 월(Calendar.MONTH) 필드 값 변경 시 일 필드 값이 바뀔 수 있음 (말일은 달마다 다르기 때문에)
Date getTime()	Calendar를 Date 타입으로 변환 Calendar → Date
void setTime(Date date)	Date인스턴스를 Calendar인스턴스로 변환 Date → Calendar

 

 

예제1

import java.util.Calendar;

class prac{
    public static void main (String[] args){
    	Calendar today = Calendar.getInstance();
    	
    	/* 년도 구하기 */
    	System.out.println(today.get(Calendar.YEAR));  // 2021
    	
    	/* 몇 월인지 구하기 (나온 값에 +1 해줘야함) */
    	System.out.println(today.get(Calendar.MONTH));  // 10   (11월 의미) 
    	
    	/* 일수 구하기 (= DAY_OF_MONTH 와 동일) */
    	System.out.println(today.get(Calendar.DATE));  // 8
    	
    	/* 일수 구하기 (= DATE 와 동일) */
    	System.out.println(today.get(Calendar.DAY_OF_MONTH));  // 8
    	
    	/* 요일 (1: 일요일, 2: 월요일, 3:화요일 .....) */ 
    	System.out.println(today.get(Calendar.DAY_OF_WEEK));  // 2
    	
    	/* 그 해의 몇 번째 일 */
    	System.out.println(today.get(Calendar.DAY_OF_YEAR));  // 312
    	
    	/* 이 달의 몇 번째 요일 */
    	System.out.println(today.get(Calendar.DAY_OF_WEEK_IN_MONTH));  // 2 (이 달의 둘 째주 요일)
    	
    	/* 오전/오후 구별 */
    	System.out.println(today.get(Calendar.AM_PM));  // 1
    	
    	/* 이번년에 몇 번째 주인지 구하기 */
    	System.out.println(today.get(Calendar.WEEK_OF_YEAR));  // 46
    	
    	/* 이번달에 몇 번째 주인지 구하기 */
    	System.out.println(today.get(Calendar.WEEK_OF_MONTH));  // 2

    	/* 이달의 마지막 일 구하기 */
    	System.out.println(today.getActualMaximum(Calendar.DATE));  // 30
    	
    	/* 현재 시간 구하기 */ 
    	System.out.println(today.get(Calendar.HOUR));  // 7
    	System.out.println(today.get(Calendar.MINUTE));  // 8
    	System.out.println(today.get(Calendar.SECOND));  // 5
    	
    	/* 1/1000초 (범위 : 0~999) */
    	System.out.println(today.get(Calendar.MILLISECOND));  // 257
    	
    	/* TimeZone (-12 ~ +12) */
    	System.out.println(today.get(Calendar.ZONE_OFFSET)/(60*60*1000));  // 9
    	
    } 
}

 

 

예제2  ㅡ 두 날짜간의 차이 구하기

import java.util.Calendar;

class prac{
    public static void main (String[] args) {
    	Calendar date1 = Calendar.getInstance();
    	Calendar date2 = Calendar.getInstance();  // 현재 날짜 (2021 11 08)
    	
    	
    	date1.set(2021,10,5); // 2021일 11월 5일,  date1.set(2021, NOVEMBER, 5) 와 같음
    	System.out.println(toString(date1));  // 2021년, 11월, 5일
    	System.out.println(differ(date1, date2));  // 259200초 또는 3일 차이
    	
    }
    public static String toString(Calendar date) {
    	return date.get(Calendar.YEAR) + "년, " + 
    			(date.get(Calendar.MONTH)+1) + "월, " + date.get(Calendar.DATE)+ "일";
    }
    
    public static String differ(Calendar date1, Calendar date2) {  // 두 날짜간의 차이 구하기
    	// 두 날짜간의 차이를 구하려면 천분의 일초 단위로 변환 해야함
    	long differSecond = (date1.getTimeInMillis() - date2.getTimeInMillis())/1000;
    	differSecond = Math.abs(differSecond);
    	
    	long differDay = differSecond /(60*60*24);
    	
    	return differSecond + "초 또는 " + differDay + "일 차이";
    }
    
}

두 날짜간의 차이를 구하기 위해서는 두 날짜의 최소단위인 초단위로 변경한 다음 그 차이를 구할 것

getTimeInMillis() 메서드를 통해서 1/1000초 값을 얻고 거기서 나누기 1000을 통해서 초 단위 값을 얻음

두 날짜간의 차이를 일 수로 계산하려면 두 날짜간의 차이의 초단위 값을 ( 24(시간) * 60(분) * 60(초) ) 값으로 나눌 것

 

 

예제3

import java.util.Calendar;

class prac{
    public static void main (String[] args)  {
    	final int[] TIME_UNIT = {3600, 60, 1};
    	final String[] TIME_UNIT_NAME = {"시간 ", "분 " , "초"};
    	
    	Calendar time1 = Calendar.getInstance();
    	Calendar time2 = Calendar.getInstance();
    	
    	// time1을 10시 20분 30초로 설정
    	time1.set(Calendar.HOUR_OF_DAY, 10);
    	time1.set(Calendar.MINUTE, 20);
    	time1.set(Calendar.SECOND, 30);
    	
    	// time2를 20시 30분 10초로 설정
    	time2.set(Calendar.HOUR_OF_DAY, 20);
    	time2.set(Calendar.MINUTE, 30);
    	time2.set(Calendar.SECOND, 10);
    	
    	System.out.println(toString(time1));  // 10시 20분 30초
    	System.out.println(toString(time2));  // 20시 30분 10초
    
    	long difference = Math.abs(time2.getTimeInMillis() - time1.getTimeInMillis()) /1000;
    	System.out.println(difference + "초 차이");  // 36580초 차이
    	
    	
    	String tmp = "";
    	for(int i=0; i<TIME_UNIT.length; i++) {
    		tmp += difference/TIME_UNIT[i] + TIME_UNIT_NAME[i];
    		difference %= TIME_UNIT[i];
    	}
    	System.out.println(tmp);  // 10시간 9분 40초
    
    
    }
    
    public static String toString(Calendar time) {
    	return time.get(Calendar.HOUR_OF_DAY) + "시 " + 
            time.get(Calendar.MINUTE) +"분 " + time.get(Calendar.SECOND)+ "초";
    }
    
}

 

 

예제4 ㅡ add() 메서드와 roll() 메서드 비교

import java.util.Calendar;

class prac{
    public static void main (String[] args)  {
    	Calendar date = Calendar.getInstance();
    	
    	date.set(2015,07,31); 
    	System.out.println(toString(date));  // 2015년 8월 31일
    	
    	date.add(Calendar.DATE, 1);
    	System.out.println(toString(date));  // 2015년 9월 1일
    	
    	date.add(Calendar.MONTH, -6);
    	System.out.println(toString(date));  // 2015년 3월 1일
    	
    	date.add(Calendar.DATE, 31);
    	System.out.println(toString(date));  // 2015년 4월 1일
    	
    	// roll() 메서드 사용
    	date.roll(Calendar.DATE, 31);
    	System.out.println(toString(date));  // 2015년 4월 2일
    	
    	date.roll(Calendar.DATE, -5);
    	System.out.println(toString(date));  // 2015년 4월 27일
    	
    }
    public static String toString(Calendar date) {
    	return date.get(Calendar.YEAR) + "년 " +
    			(date.get(Calendar.MONTH)+1) + "월 " + date.get(Calendar.DATE) + "일";
    }
}

기본적으로 roll() 메서는 add()메서드와 달리 다른 필드값에 영향을 주지 않음.

 

 

예제5 ㅡ roll() 메서드의 필드값 영향 예외

import java.util.Calendar;

class prac{
    public static void main (String[] args)  {
    	Calendar date = Calendar.getInstance();
    	
    	date.set(2015, 0, 31);
    	System.out.println(toString(date));  // 2015년 1월 31일 
    	
    	date.roll(Calendar.MONTH, 1);
    	System.out.println(toString(date)); // 2015년 2월 28일
    	
    }
    public static String toString(Calendar date) {
    	return date.get(Calendar.YEAR) + "년 " +
    			(date.get(Calendar.MONTH)+1) + "월 " + date.get(Calendar.DATE) + "일";
    }
}

2015년 1월 31일에서 roll() 메서드를 통해서 월(Calendar.MONTH)필드 값을 1 증가시켰더니 2015년 2월 28일이 되어버림. 원래라면 roll() 메서드는 지정한 필드값 외에는 영향을 주지 않아서 2015년 2월 31일이 되어야하지만 2월에는 31일이 존재하지 않기 때문에 2월 말일인 2015년 2월 28일로 자동 변경됨

 

 

 

예제6 ㅡ 달력 만들기1

import java.util.Calendar;

class prac{
    public static void main (String[] args)  {
    	int year = 2021, month = 5;
    	int START_DAY_OF_WEEK =0;
    	int END_DAY =0;
    	
    	Calendar sDay = Calendar.getInstance();
    	
        // 월은 0 ~ 11의 값을 가지므로 1을 빼줘야함
    	sDay.set(year, month-1, 1);
    	
    	START_DAY_OF_WEEK = sDay.get(Calendar.DAY_OF_WEEK);
    	
    	END_DAY  = sDay.getActualMaximum(Calendar.DATE);
    	
    	System.out.println("       "+year + "년 " + month + "월");
    	System.out.println(" SU MO TU WE TH FR SA");
    	
    	for(int i=1; i<START_DAY_OF_WEEK;i++) {
    		System.out.print("   ");
    	}
    	
    	for(int i=1, n=START_DAY_OF_WEEK; i<=END_DAY; i++, n++) {
    		System.out.print((i<10)? "  "+ i : " " + i);
    		
    		if(n%7==0) System.out.println();
    	}
    	
    }
}

/* 출력값
       2021년 5월
 SU MO TU WE TH FR SA
                    1
  2  3  4  5  6  7  8
  9 10 11 12 13 14 15
 16 17 18 19 20 21 22
 23 24 25 26 27 28 29
 30 31
*/

year와 month 값을 지정해줌으로써 특정 달력을 만듦

월(MONTH) 값을 Calendar 인스턴스 값에 대입할 때는 -1한 상태로 넣고 Calendar 인스턴스로부터 값을 반환 받을 때는 +1한 상태로 받을 것

 

 

 

예제 7 ㅡ 달력만들기2

import java.util.Calendar;

class prac{
    public static void main (String[] args)  {
    	int START_DAY_OF_WEEK =0;
    	int END_DAY =0;
    	
    	Calendar sDay = Calendar.getInstance();
    	int year = sDay.get(Calendar.YEAR);
    	int month = sDay.get(Calendar.MONTH) + 1;

    	START_DAY_OF_WEEK = sDay.get(Calendar.DAY_OF_WEEK);
    	END_DAY  = sDay.getActualMaximum(Calendar.DATE);
    	
    	System.out.println("       "+ year + "년 " + month + "월");
    	System.out.println(" SU MO TU WE TH FR SA");
    	
    	for(int i=1; i<START_DAY_OF_WEEK;i++) {
    		System.out.print("   ");
    	}
    	
    	for(int i=1, n=START_DAY_OF_WEEK; i<=END_DAY; i++, n++) {
    		System.out.print((i<10)? "  "+ i : " " + i);
    		
    		if(n%7==0) System.out.println();
    	}
    	
    }
}

/* 출력값
       2021년 11월
 SU MO TU WE TH FR SA
     1  2  3  4  5  6
  7  8  9 10 11 12 13
 14 15 16 17 18 19 20
 21 22 23 24 25 26 27
 28 29 30
*/

year와 month 값을 현재 날짜로 설정하여 이번달 달력을 만듦

월(MONTH) 값을 Calendar 인스턴스 값에 대입할 때는 -1한 상태로 넣고 Calendar 인스턴스로부터 값을 반환 받을 때는+1한 상태로 받을 것

 

 

 

예제8 ㅡ 달력만들기3

import java.util.Calendar;

class prac{
    public static void main (String[] args)  {
    	int year = 2021, month = 5;
    	
    	Calendar sDay = Calendar.getInstance();
    	Calendar eDay = Calendar.getInstance();
    	
    	sDay.set(year, month-1, 1);
    	eDay.set(year, month-1, sDay.getActualMaximum(Calendar.DATE));
    	
    	sDay.add(Calendar.DATE, -(sDay.get(Calendar.DAY_OF_WEEK)-1));
    	eDay.add(Calendar.DATE, 7-eDay.get(Calendar.DAY_OF_WEEK));
    	
    	System.out.println("       "+ year + "년 " + month + "월");
    	System.out.println(" SU MO TU WE TH FR SA");
    	
    	for(int n=1; sDay.before(eDay) || sDay.equals(eDay); sDay.add(Calendar.DATE, 1), n++) {
    		int day = sDay.get(Calendar.DATE);
    		
    		System.out.print(day <10? "  "+ day : " " + day);
    		if(n%7==0) System.out.println();
    	}
    	
    }
}

/* 출력값
       2021년 5월
 SU MO TU WE TH FR SA
 25 26 27 28 29 30  1
  2  3  4  5  6  7  8
  9 10 11 12 13 14 15
 16 17 18 19 20 21 22
 23 24 25 26 27 28 29
 30 31  1  2  3  4  5
*/

달력의 첫 주와 마지막주가 이전달, 이후 달과 연결되도록 출력

 

 

예제9 ㅡ 년, 월 간단한 계산

import java.util.Calendar;
import java.util.Scanner;

class prac{
    public static void main (String[] args)  {
    	String date1="201508";
    	String date2="201405";
    	
    	int month1 = Integer.parseInt(date1.substring(0,4))*12 + Integer.parseInt(date1.substring(4));
    	int month2 = Integer.parseInt(date2.substring(0,4))*12 + Integer.parseInt(date2.substring(4));

    	System.out.println(Math.abs(month2-month1)); // 15
    }
}

간단한 계산이면 Calendar를 사용하지 않고도 가능

 

 

예제10

import java.util.Calendar;

class prac{
    public static void main (String[] args)  {
    	System.out.println(getDayOfWeek(2014,5,31));  // 7
    	System.out.println(getDayOfWeek(2012,6,1));  // 6
    	
    	System.out.println(dayDiff(2014,5,1,2014,4,28));  // 3
    	
    	System.out.println(convertDateToDay(2015,6,29));  // 735778
    	System.out.println(convertDayToDate(735778));  // 2015-6-29
    }
    
    static int[] endOfMonth = {
    		31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
    };
    
    static boolean isLeapYear(int year) {  // 윤년 판별
    	return (year%4==0) && (year%100!=0) || (year%400==0);
    }
    
    static int dayDiff(int y1, int m1, int d1, int y2, int m2, int d2) {  // 두 날짜간의 차이를 일단위로 반환
    	return convertDateToDay(y1,m1,d1) - convertDateToDay(y2,m2,d2); 
    }
    
    static int getDayOfWeek(int year, int month, int day) {  // 지정한 날짜의 요일 반환 
    	Calendar date = Calendar.getInstance();
    	date.set(year, month-1, day);
    	return date.get(Calendar.DAY_OF_WEEK);
    }

    static String convertDayToDate(int day) {  // 일단위의 값을 년월일의 형태의 문자열로 변환하여 반환
    	int year = 1;
    	int month = 0;
    	while(true) {
    		int aYear = isLeapYear(year) ? 366 : 365;
    		if (day > aYear) {
    			day -= aYear;
    			year++;
    		} else break;
    	}
    	
    	while(true) {
    		int endDay = endOfMonth[month];
    		if(isLeapYear(year) && month ==1) endOfMonth[month] ++;
    		
    		if(day > endDay) {
    			day -= endDay;
    			month++;
    		} else break;
    	}
    	
    	return year + "-"+ (month+1) + "-" + day;
    }

    static int convertDateToDay(int year, int month, int day) {  // 년월일을 입력받아서 일단위로 변환
    	
    	int lastYearDay = 0;
    	int countLeapYear = 0;
    	for(int i=1; i<year-1; i++) {
    		if(isLeapYear(i)) {
    			countLeapYear++;
    		}
    	}
    	lastYearDay = (year-1)*365 + countLeapYear;
    	
    	int nowYearDay = 0;
    	for (int i=0; i<month-1; i++) nowYearDay += endOfMonth[i];
    	
    	if(isLeapYear(year)) nowYearDay++;
    	
    	return lastYearDay + nowYearDay + day;
    }
    
    
}

 

 

 

---

 

 

 

▒ 형식화 클래스

• java.text 패키지에 포함되어 있음
• 숫자, 날짜, 텍스트 데이터를 일정한 형식에 맞춰 표현할 수 있는 방법을 객체지향적으로 설계하여 표준화함
• 형식화 클래스는 형식화에 사용될 패턴을 정의하는데, 데이터를 정의된 패턴에 맞춰 형식화할 수 있을 뿐만 아니라 역으로 형식화된 데이터에서 원래의 데이터를 얻어낼 수도 있음
• 형식화된 데이터의 패턴만 정의해주면 복잡한 문자열에서도 substring()메서드를 사용하지 않고도 쉽게 원하는 값 추출 가능

 

◎ DecimalFormat

• 숫자를 다양한 형식(패턴)으로 출력할 수 있음
• 숫자 데이터를 정수, 부동소수점, 금액 등 다양한 형식으로 표현 가능, 반대로 일정한 형식의 텍스트 데이터를 숫자로 변환 가능
• 숫자 → 형식 문자열, 형식 문자열 → 숫자 둘 다 가능 
• import java.text.DecimalFormat; 쓸 것
• new 연산자를 이용해서 인스턴스 생성

 

기호	의미	패턴	결과(1234567.89)
0	10진수 (값이 없는 자리는 0으로 채움) '0' 은 표시한 자리수만큼 값을 최소한 표시	0 0.0 000000000.0000	1234568 1234567.9 0001234567.8900
#	10진수 (값이 없는 자리는 나타내지 않음) #은 표시한 소수점자리수만큼 반올림하여 표시	# #.# ##########.####	12345678 1234567.9 1234567.89
.	소수점	#.#	1234567.9
- +	음수부호 양수부호	#.#- -#.# #.#+ +#.#	1234567.9- -1234567.9 1234567.9+ +1234567.9
,	단위 구분자	#,###.## #,####.##	1,234,567.89 123,4567.89
E	지수기호	#E0 0E0 ##E0 00E0 ###E0 000E0 #.#E0 0.0E0 0.000000000E0 00.00000000E0 000.0000000E0 #.#########E0 ##.########E0 ###.#######E0	.1E7 1E6 1.2E6 12E5 123.5E4 1235E3 1.2E6 1.2E6 1.234567890E6 12.34567890E5 123.4567890E4 1.23456789E6 1.23456789E6 1.23456789E6
;	패턴 구분자 양수와 음수의 패턴을 모두 기술할 경우, 패턴 구분자	#,##.##+;#,###.##-	1,234,567.89+ (양수일 때) 1,234,567.89- (음수일 때)
%	퍼센트 (100을 곱하고 % 붙임)	#.#%	123456789%
\u2030	퍼밀(퍼센트 * 10)	#.#\u2030	1234567890%
\u00A4	통화	\u00A4 #,###	\ 1,234,568
'	escape문자	'#'#.### "#,###	#1,234,568 '1,234,568

 

 

 

 

예제1

import java.text.DecimalFormat;

public class prac {
	public static void main(String[] args){
		double number = 1234567.89;
		DecimalFormat df = new DecimalFormat("#.#E0");
		String result = df.format(number);
		System.out.println(result);  // 1.2E6
	}
}

 

 

예제2

import java.text.DecimalFormat;


class prac{
    public static void main (String[] args)  {
    	double number = 1234567.89;
    	String[] pattern = {
    			"0",    
    			"#",  
    			"0.0",  
    			"#.#", 
    			"0000000000.0000", 
    			"##########.####",
    			"#.#-",  
    			"-#.#", 
    			"#,##.##",  
    			"#,###.##",  
    			"#E0",  
    			"#0E0",
    			"##E0",
    			"00E0",
    			"####E0",
    			"0000E0",
    			"#.#E0",
    			"0.0E0",
    			"0.000000000E0",
    			"00.00000000E0",
    			"000.0000000E0",
    			"#.#########E0",
    			"##.########E0",
    			"###.#######E0",
    			"#,###.##+;#,###.##-",
    			"#.#%",
    			"#.#\u2030",
    			"\u00A4 #,###",
    			"'#'#,###",
    			"''#,###"
    	};
    	
    	for(int i=0; i< pattern.length; i++) {
    		DecimalFormat df = new DecimalFormat(pattern[i]);
    		System.out.printf("%19s : %s\n", pattern[i], df.format(number));
    	}
    	
    }
    
}

/* 출력값
                  0 : 1234568
                  # : 1234568
                0.0 : 1234567.9
                #.# : 1234567.9
    0000000000.0000 : 0001234567.8900
    ##########.#### : 1234567.89
               #.#- : 1234567.9-
               -#.# : -1234567.9
            #,##.## : 1,23,45,67.89
           #,###.## : 1,234,567.89
                #E0 : .1E7
               #0E0 : 1.2E6
               ##E0 : 1.2E6
               00E0 : 12E5
             ####E0 : 123.5E4
             0000E0 : 1235E3
              #.#E0 : 1.2E6
              0.0E0 : 1.2E6
      0.000000000E0 : 1.234567890E6
      00.00000000E0 : 12.34567890E5
      000.0000000E0 : 123.4567890E4
      #.#########E0 : 1.23456789E6
      ##.########E0 : 1.23456789E6
      ###.#######E0 : 1.23456789E6
#,###.##+;#,###.##- : 1,234,567.89+
               #.#% : 123456789%
               #.#‰ : 1234567890‰
            ¤ #,### : ￦ 1,234,568
           '#'#,### : #1,234,568
            ''#,### : '1,234,568
*/

 

 

예제3

import java.text.DecimalFormat;
import java.text.ParseException;


class prac{
    public static void main (String[] args)   {
    	DecimalFormat df = new DecimalFormat("#,###.##");
    	DecimalFormat df2 = new DecimalFormat("#.###E0");
    	
    	try {
    		Number num = df.parse("1,234,567.89");  // 기호와 문자가 포함된 문자열이 숫자로 변환
    		System.out.println(num);  // 1234567.89
    	
    		double d = num.doubleValue();  // double 타입으로 변환
    		System.out.println(d);  // 1234567.89
    		
    		System.out.println(df2.format(num));  // 1.235E6

    		
    	} catch (ParseException e) {}
    	
    }
    
}

parse(String source) 메서드를 통해 기호와 문자가 포함된 문자열을 숫자로 변환할 수 있고 반환타입은 Number 클래스타입

parse() 메서드는 DecimalFormat의 조상인 NumberFormat 클래스에 정의된 메서드 

parse()메서드 ParseException 예외가 발생할 수 있어 예외처리 필수

parseException 예외가 발생할 때는 import java.text.ParseException; 쓸 것. 단, catch문에 Exception으로 대체한다면 import문 안써도 됨

Integer.parseInt메서드는 콤마(,)가 포함된 문자열을 숫자로 변환 못함

 

 

 

---

 

◎ SimpleDateFormat 클래스

• 날짜와 시간을 다양한 형식으로 출력할 때 사용
• Date 클래스와 Calendar 클래스만으로 날짜 데이터를 원하는 형태로 다양하게 출력하는것은 불편하고 복잡
• DateFormat은 추상클래스로 SimpleDateFormat의 조상 클래스
• DateFormat 인스턴스를 생성하기 위해서는 getDateInstance() 메서드 사용할 것
  • getDateInstance() 메서드를 통해 반환된 것은 DateFormat을 상속받아 완전하게 구현한 SimpleDateFormat 인스턴스
  • DateFormat 사용시 import java.text.DateFormat; 쓸 것
• import java.text.SimpleDateFormat; 쓸 것
• 먼저 원하는 출력 형식의 패턴을 작성하여 SimpleDateFormat 인스턴스를 생성한 다음, 출력하고자 하는 Date 인스턴스를 가지고 format(Date d)를 호출하면 지정한 출력형식에 맞게 변환된 문자열을 얻음

 

 

기호	의미	보기
G	연대(BC, AD)	AD
y	년도	2006
M	월(1~12 또는 1월~12월)	10 또는 10월, OCT
w	년의 몇 번째 주 (1~53)	50
W	월의 몇 번째 주(1~5)	4
D	년의 몇 번째 일(1~366)	100
d	월의 몇번째 일(1~31)	15
F	월의 몇 번째 요일(1~5)	1
E	요일	월
a	오전/오후 (AM,PM)	PM
H	시간 (0~23)	20
k	시간 (1~24)  (잘 안쓰임)	13
K	시간 (0~12) (잘 안쓰임)	10
h	시간 (1~12)	11
m	분 (0~59)	35
s	초 (0~59)	55
S	천분의 일초 (0~999)	253
z	Time zone (General time zone)	GMT+9:00
Z	Time zone (RFC 822 time zone)	+0900
'	escape문자 (특수문자를 표현하는데 사용)	없음

 

 

◎ DateFormat 클래스

• 추상클래스이며 SimpleDateFormat 조상 클래스

 

■ DateFormat 클래스 메서드

반환타입 메서드	설명
DateFormat getDateInstance()	DateFormat 인스턴스 생성
Date parse(String source)	문자열 source를 날짜 Date 인스턴스로 변환
String format(Date date)	Date에 저장된 날짜값을 문자열로 변환

 

 

예제1

import java.util.Date;
import java.text.SimpleDateFormat;

class prac{
    public static void main (String[] args)  {
    	Date today = new Date();
    	SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); // 오늘 날짜를 yyyy-MM-dd 형태로 변환
    	
    	String result = df.format(today);
    	System.out.println(result);  // 2021-11-10
    	
    }
}

 

 

예제2

import java.util.Date;
import java.text.SimpleDateFormat;

class prac{
    public static void main (String[] args)  {
    	Date today = new Date();
    	
    	SimpleDateFormat sdf1, sdf2, sdf3, sdf4;
    	SimpleDateFormat sdf5, sdf6, sdf7, sdf8, sdf9;
    	
    	sdf1 = new SimpleDateFormat("yyyy-MM-dd");
    	sdf2 = new SimpleDateFormat("''yy년 MMM dd일 E요일");
    	sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mmss.SSS");
    	sdf4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss a");
    	
    	
    	sdf5 = new SimpleDateFormat("오늘은 올해의 D번째 날입니다");
    	sdf6 = new SimpleDateFormat("오늘은 이달의 d번째 날입니다");
    	sdf7 = new SimpleDateFormat("오늘은 올해의 w번째 주입니다");
    	sdf8 = new SimpleDateFormat("오늘은 이달의 W번째 주입니다");
    	sdf9 = new SimpleDateFormat("오늘은 이달의 F번째 E요일입니다");
    	
    	System.out.println(sdf1.format(today));
    	System.out.println(sdf2.format(today));
    	System.out.println(sdf3.format(today));
    	System.out.println(sdf4.format(today));
    	System.out.println();
    	
    	System.out.println(sdf5.format(today));
    	System.out.println(sdf6.format(today));
    	System.out.println(sdf7.format(today));
    	System.out.println(sdf8.format(today));
    	System.out.println(sdf9.format(today));
    	
    	
    }
}
/* 출력값
2021-11-10
'21년 11월 10일 수요일
2021-11-10 19:3747.214
2021-11-10 07:37:47 오후

오늘은 올해의 314번째 날입니다
오늘은 이달의 10번째 날입니다
오늘은 올해의 46번째 주입니다
오늘은 이달의 2번째 주입니다
오늘은 이달의 2번째 수요일입니다
*/

 

 

예제3

import java.util.Date;
import java.text.SimpleDateFormat;
import java.util.Calendar;
class prac{
    public static void main (String[] args)  {
    	Calendar cal = Calendar.getInstance();
    	cal.set(2005, 10, 3);
    	
    	Date day = cal.getTime();  // Calendar를 Date로 변환
    	
    	SimpleDateFormat sdf1, sdf2, sdf3, sdf4;
    	
    	sdf1 = new SimpleDateFormat("yyyy-MM-dd");
    	sdf2 = new SimpleDateFormat("yy-MM-dd E요일");
    	sdf3 = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
    	sdf4 = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss a");
    	
    	System.out.println(sdf1.format(day));  // 2005-11-03
    	System.out.println(sdf2.format(day));  // 05-11-03 목요일
    	System.out.println(sdf3.format(day));  // 2005-11-03 20:29:54.651
    	System.out.println(sdf4.format(day));  // 2005-11-03 08:29:54 오후
    }
}

Date인스턴스만 format메서드에 사용될 수 있기에 Calendar 인스턴스를 Date인스턴스로 변환함

 

예제4

import java.util.Date;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
class prac{
    public static void main (String[] args) throws ParseException  {
    	
    	DateFormat df = new SimpleDateFormat("yyyy년 MMM dd일");
    	DateFormat df2 = new SimpleDateFormat("yyyy/MM/dd");
    	
    	try {
    		Date d = df.parse("2015년 11월 23일");
    		System.out.println(df2.format(d));  // 2015/11/23
    	} catch(ParseException e) {}
    	
    	
    }
}

parse(String source) 메서드를 사용하여 날짜 데이터의 출력형식을 변환

parse(String source) 메서드는 문자열 source를 날짜 Date인스턴스로 변환해줌

 

 

예제5

import java.util.*;
import java.text.*;

class prac{
    public static void main (String[] args) {
    	
    	String pattern = "yyyy/MM/dd";
    	DateFormat  sdf = new SimpleDateFormat(pattern);

    	Scanner s = new Scanner(System.in);
    	
    	Date date = null;
    	
    	System.out.println(pattern + " 형식으로 입력하시오");
    	while(s.hasNextLine()) {
    		try {
    			date = sdf.parse(s.nextLine());
    			break;
    		} catch(ParseException e) {
    			System.out.println("다시 입력하시오");
    		}
    		
    	}
    	
    	Calendar cal = Calendar.getInstance();
    	cal.setTime(date);
    	
    	Calendar today = Calendar.getInstance();
    	
    	long day = (cal.getTimeInMillis() - today.getTimeInMillis())/ (60*60*1000);
    	System.out.println(day);
    	
    	
    }
}

/* 출력값
yyyy/MM/dd 형식으로 입력하시오
2021/11/12
24
*/

 

 

 

---

 

◎ ChoiceFormat

• 특정 범위에 속하는 값을 문자열로 변환
• 연속적 또는 불연속적인 범위의 값들을 처리하는 데 있어서 if문이나 switch문은 적절하지 못한 경우가 많은데 ChoiceFormat으로는 잘 처리할 수 있음
• import java.text.ChoiceFormat; 쓸 것

 

 

■ 생성자

ChoiceFormat form = new ChoiceFormat(double[] limits, String[] formats)


ChoiceFormat form = new ChoiceFormat(String newPattern)

 

 

 

◎ NumberFormat

• 추상클래스이며, ChoiceFormat 클래스와 DecimalFormat 클래스의 조상 클래스

 

■ 메서드

반환타입 메서드	설명
String format(double number) String format(long number)	문자열로 변환
NumberFormat getInstance()	NumberFormat 인스턴스 반환

 

 

 

예제1

import java.text.ChoiceFormat;

class prac{
    public static void main (String[] args) {
    	double[] limits = {60, 70, 80, 90};  // 낮은순으로 적을 것
    	String[] grades = {"D", "C", "B", "A"};
    	
    	int[] scores = {100, 95, 88, 70, 52, 60, 70};
    	
    	ChoiceFormat form = new ChoiceFormat(limits, grades);
    	
    	for(int i=0; i<scores.length; i++) {
    		System.out.println(scores[i] + " : " + form.format(scores[i]));
    	}
    	
    }
}

/* 출력값
100 : A
95 : A
88 : B
70 : C
52 : D
60 : D
70 : C
*/

두 개의 배열이 사용되었는데 하나(limits)는 범위의 경계값을 저장하는데 사용했고, 또 하나는(grades)는 범위에 포함된 값을 치환할 문자열을 저장하는데 사용

경계값은 double형으로 반드시 모두 오름차순으로 정렬되어 있어야하며, 치환 될 문자열의 개수는 경계값에 의해 정의된 범위의 개수와 일치해야함. 그렇지 않으면 IllegalArgumentException 예외 발생

위 예제에서 경계값은 '60~69', '70~79', '80~89', '90~' 범위가 정의됨

 

 

 

예제2

import java.text.ChoiceFormat;

class prac{
    public static void main (String[] args) {
    	String pattern = "60#D|70#C|80<B|90#A";
    	int[] scores = {91, 90, 80, 88, 70 ,52, 60};
    	
    	ChoiceFormat form = new ChoiceFormat(pattern);
    	
    	for(int i=0; i<scores.length; i++) {
    		System.out.println(scores[i] + " : " + form.format(scores[i]));
    	}
    	
    }
}

/* 출력값
91 : A
90 : A
80 : C
88 : B
70 : C
52 : D
60 : D
*/

배열대신 패턴을 사용하는것이 더 간결하게 처리 가능

패턴은 구분자로 '#'과 '<' 두가지를 제공하는데 'limit#value'의 형태로 사용

'#'은 경계값을 범위에 포함시키지만, '<'는 경계값을 포함시키지 않음

'61#D|71#C|81#B|91#A' 보다 '60<D|70<C|<80<B|90<A' 가 더 직관적이다  

 

---

 

 

◎ MessageFormat

• 데이터를 정해진 양식에 맞게 출력할 수 있게 도와줌
• 특정 형식을 가진 문자열에서 데이터를 뽑아낼 때 유용
• 데이터가 들어갈 자리를 마련해 놓은 양식을 미리 작성하고 프로그램을 이용해서 다수의 데이터를 같은 양식으로 출력할 때 사용
• SimpleDateFormat클래스의 parse() 메서드처럼 MessageFormat 클래스도 parse()메서드를 이용하면 지정된 양식에서 필요한 데이터만 추출 가능
• import java.text.MessageFormat; 쓸 것

 

예제1

import java.text.MessageFormat;

class prac{
    public static void main (String[] args) {
    	String msg = "Name: {0} \nTel: {1} \nAge: {2} \nBirthday: {3}";
    	
    	Object[] arguments = {
    			"이자바", "02-123-1234", "27", "07-09"
    	};
    	
    	String result = MessageFormat.format(msg, arguments);
    	System.out.println(result);
    }
    
}

/* 출력값
Name: 이자바 
Tel: 02-123-1234 
Age: 27 
Birthday: 07-09
*/

MessageFormat에 사용할 양식인 문자열 msg를 작성할 때 '{숫자}'로 표시된 부분이 데이터가 출력될 자리

이 자리는 순차적일 필요는 없고 여러 번 반복해서 사용 가능

해당 자리에 객체배열인 arguments에 이정된 값이 자리에 맞게 값이 들어감

 

 

 

 

 

예제2

import java.text.MessageFormat;

class prac{
    public static void main (String[] args) {
    	String msg = "Values (''{0}'', ''{1}'', ''{2}'', ''{3}'')";
    	
    	Object[][] arguments = {
    			{"이자바", "02-123-1234", "27", "07-09"},
    			{"김프로", "032-333-1234", "33", "10-07"}
    	};
    	
    	for(int i=0; i<arguments.length; i++) {
    		String result = MessageFormat.format(msg, arguments[i]);
    		System.out.println(result);
    	}
    	
    }
}

/* 출력값
Values ('이자바', '02-123-1234', '27', '07-09')
Values ('김프로', '032-333-1234', '33', '10-07')
*/

반복만으로 하나 이상의 데이터 집합을 출력

 

 

예제3

import java.text.MessageFormat;
import java.text.ParseException;

class prac{
    public static void main (String[] args) throws ParseException{
    	String[] data = {
    			"Value('이자바', '02-123-1234', '27', '07-09')",
    			"Value('김프로', '032-333-1234', '33', '10-07')"
    	};
    	
    	String pattern = "Value({0}, {1}, {2}, {3})";
    	
    	MessageFormat mf = new MessageFormat(pattern);
    	
		for(int i=0; i<data.length; i++) {
			Object[] objs = mf.parse(data[i]);
			
			for(int j=0; j<objs.length; j++) {
				System.out.print(objs[j]);
			}
			
			System.out.println();
		}
    	
    }
}

/* 출력값
'이자바''02-123-1234''27''07-09'
'김프로''032-333-1234''33''10-07'
*/

parse(String source)를 이용해서 출력된 데이터로부터 필요한 데이터만 뽑아냄

 

 

예제4

/* data1.txt */
'이자바', '02-123-1234', '27', '07-09'
'김프로', '032-333-1234', '33', '10-07'

import java.io.File;
import java.util.Scanner;
import java.io.FileNotFoundException;
import java.text.MessageFormat;
import java.text.ParseException;

class prac{
    public static void main (String[] args) throws FileNotFoundException, ParseException{
    	
    	String tableName = "Info";
    	String msg = "Insert "+ tableName + " Values ({0}, {1}, {2}, {3})";
    	String fileName = "data1.txt";
    	
    	Scanner s = new Scanner(new File(fileName));
    	String pattern = "{0}, {1}, {2}, {3}";
    	
    	MessageFormat mf = new MessageFormat(pattern);

    	while(s.hasNextLine()) {
    		String line = s.nextLine();
    		Object[] objs = mf.parse(line);
    		String result = MessageFormat.format(msg, objs);
    		System.out.println(result);
    	}
    	
    }
}


/* 출력값
Insert Info Values ('이자바', '02-123-1234', '27', '07-09')
Insert Info Values ('김프로', '032-333-1234', '33', '10-07')
*/

Scanner를 통해서 파일로부터 데이터를 라인별로 읽어옴

 

 

---

 

▒ java.time 패키지

• Date클래스와 Calendar클래스의 단점을 보완하기 위해 추가된 패키지
• time 패키지에 속한 클래스들은 모두 불변(immutable)
  • 값 변경시 메모리에 새로운 인스턴스가 생성된다는 의미
  • 멀티 쓰레드 환경에서 안전
  • 멀티 쓰레드 환경에서는 동시에 여러 쓰레드가 같은 객체에 접근할 수 있기 때문에, 변경 가능한 객체는 데이터가 잘못될 가능성이 있어 쓰레드에 안전(thread-safe)하지 않음
• time 패키지가 도입되어도 기존 작성된 프로그램과의 호환성 때문에 Date 클래스와 Calendar클래스는 여전히 사용중
• time 패키지 쓸 것을 권장
• 날짜와 시간을 하나로 표현하는 Calendar 클래스와 달리 time 패키지는 날짜와 시간을 별도의 클래스로 분리
• 시간을 표현할 때는 LocalTime 클래스 사용
• 날짜를 표현할 때는 LocalDate 클래스 사용
• 시간과 날짜 모두 표현할 때는 LocalDateTime 클래스 사용
• 시간, 날짜, 시간대(time-zone)을 모두 표현하려면 ZonedDateTime 클래스 사용
  • Calendar 클래스는 ZonedDateTime 클래스와 기능 유사
• 날짜간의 차이는 Period 클래스 사용
• 시간의 차이는 Duration 클래스 사용  
• java.Time.Instant 클래스는 Date 클래스와 기능 유사
• Instant클래스는 날짜와 시간을 초 단위(나노초)로 표현 
  • 날짜와 시간을 초단위로 표현한 값을 타임스탬프(time-stamp)라고 부름
  • 타임스탬프는 날짜와 시간을 하나의 정수로 표현한 것이므로 날짜와 시간의 차이를 계산하거나 순서를 비교할 때 유리해서 데이터베이스에 많이 사용됨
• 날짜를 더 세부적으로다룰 수 있는 Year, YearMonth, MonthDay와 같은 클래스 존재

 

 

java.tim패키지와 서브 패키지들

 

 

 

■ time 패키지 객체 생성 ㅡ now(), of()

• java.time패키지에 속한 클래스의 객체를 생성하는 가장 기본적인 방법은 now()와 of() 사용하는 것
• now() 메서드는 현재 날짜와 시간을 저장하는 객체 생성
• of() 메서드는 값을 지정할 수 있으며 각 클래스마다 다양한 종류로 정의되어 있어 필드값을 순서대로 대입하면 됨

 

 

예제1 ㅡ now() 메서드로 객체 생성

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

class prac{
    public static void main (String[] args) {
    	LocalDate date = LocalDate.now();
    	LocalTime time = LocalTime.now();
    	LocalDateTime dateTime = LocalDateTime.now();
    	ZonedDateTime dateTimeInKr = ZonedDateTime.now();
    	
    	System.out.println(date);              // 2021-11-11
    	System.out.println(time);              // 11:21:53.349
    	System.out.println(dateTime);          // 2021-11-11T11:21:53.349
    	System.out.println(dateTimeInKr);      // 2021-11-11T11:21:53.349+09:00[Asia/Seoul]
    	
    }
}

 

 

예제2 ㅡ of() 메서드로 객체 생성

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

class prac{
    public static void main (String[] args) {
    	LocalDate date = LocalDate.of(2015,11, 23);
    	LocalTime time = LocalTime.of(23,59, 59);
    	LocalDateTime dateTime = LocalDateTime.of(date, time);
    	ZonedDateTime zDateTime = ZonedDateTime.of(dateTime, ZoneId.of("Asia/Seoul"));

    	System.out.println(date);           // 2015-11-23
    	System.out.println(time);           // 23:59:59
    	System.out.println(dateTime);       // 2015-11-23T23:59:59
    	System.out.println(zDateTime);      // 2015-11-23T23:59:59+09:00[Asia/Seoul]
    	
    }
}

 

 

 

 

◎ Temporal

• 인터페이스
• 날짜와 시간을 표현하는 클래스인 LocalDate, LocalTime, LocalDateTime, ZonedDateTime 들은 모두 Temporal, TemporalAccessor, TemporalAdjuster 인터페이스를 구현한 것
• 메서드의 매개변수타입이 Temporal로 시작하는것들이 자주 등장할텐데 대부분 날짜와 시간을 위한 것이며. TemporalAmount인지 아닌지만 구분할 것

 

◎ TemporalAmount

• 인터페이스
• 날짜와 시간의차이를 표현하는 클래스인 Period, Duration 들은 모두 TemporalAmount 인터페이스를 구현한 것

 

 

 

◎ TemporalUnit

• 날짜와 시간의 단위를 정의해놓은 인터페이스
• TemporalUnit 인터페이스를 구현한 것이 열거형 ChronoUnit 클래스
  • 열거형(enumeration)은 서로 관련된 상수를 묶어서 정의해놓은 것

 

TemporalUnit(ChronoUnit)	설명
FOREVER	Long.MAX_VALUE초 (약 3천억년)
ERAS	1,000.000.000년
MILLENNIA	1,000년
CENTURIES	100년
DECADES	10년
YEARS	년
MONTHS	월
WEEKS	주
DAYS	일
HALF_DAYS	반나절
HOURS	시
MINUTES	분
SECONDS	초
MILLIS	천분의 일초 (= 10^-3)
MICROS	백만분의 일초 (= 10^-6)
NANOS	10억분의 일초 (=10^-9)

 

 

 

 

◎ TemporalField

• 년, 월, 일 등 날짜와 시간의 필드를 정의해놓은 인터페이스
• TemporalField 인터페이스를 구현한 것은 열거형 ChronoField 클래스

 

타입	TemporalField(ChronoField)	설명
int	ERA	시대
int	YEAR_OF_ERA YEAR	년
int	MONTH_OF_YEAR	월
int	DAY_OF_WEEK	요일  (1:월요일, 2: 화요일, .... 7: 일요일)
int	DAY_OF_MONTH	일
int	AMPM_OF_DAY	오전/오후
int	HOUR_OF_DAY	시간(0~23)
int	CLOCK_HOUR_OF_DAY	시간(1~24)
int	HOUR_OF_AMPM	시간(0~11)
int	CLOCK_HOUR_OF_AMPM	시간(1~12)
intint	MINUTE_OF_HOUR	분
int	SECOND_OF_MINUTE	초
int	MILLI_OF_SECOND	천분의 일초 (= 10^-3 초)
long	MICRO_OF_SECOND	백만분의 일초 (= 10^-6 초)
long	NANO_OF_SECOND	10억분의 일초 (= 10^-9 초)
int	DAY_OF_YEAR	그 해의 몇번째 날
int	EPOCH_DAY	EPOCH(1970.1.1)로 부터 몇 번째 날
int	MINUTE_OF_DAY	그 날의 몇 번째 분 (시간을 분으로 환산)
int	SECOND_OF_DAY	그 날의 몇 번째 초 (시간을 초로 환산)
int	MILLI_OF_DAY	그 날의 몇 번째 밀리초 (= 10^-3 초)
long	MICRO_OF_DAY	그 날의 몇 번째 마이크로초 (= 10^-6 초)
long	NANO_OF_DAY	그 날의 몇 번째 나노초 (= 10^-9 초)
int	ALIGNED_WEEK_OF_MONTH	그 달의 n번째 주 (1~7일 →1주, 8~14일 → 2주, .....)
int	ALIGNED_WEEK_OF_YEAR	그 해의 n번째 주 (1월 1~7일 1주, 1월 8~14 2주, .....)
int	ALIGNED_DAY_OF_WEEK_IN_MONTH	요일 (그 달의 1일을 월요일로 간주하여 계산)
int	ALIGNED_DAY_OF_WEEK_IN_YEAR	요일 (그 해의 1월1일을 월요일로 간주하여 계산)
int	INSTANT_SECONDS	년월일을 초단위로 환산. Instant에만 사용 가능 (1970-01-01 00:00:00 UTC를 0로 계산)
int	OFFSET_SECONDS	UTC와의 시차. ZoneOffset에만 사용 가능
int	PROLEPTIC_MONTH	년월을 월단위로 환산 ex)2015년 11월 → (2015*12) + 11

• ChronoFeild의 상수를 사용할 수 있는 클래스는 서로가 다 다름
• LocalDate 는 날짜를 표현하기 위한것이므로, MINUTE_OF_HOUR 와 같이 시간에 관련된 상수는 사용 못함
• 해당 클래스가 지원하지 않는 필드를 사용하면 UnSupportedTemporalTypeException 예외 발생
• 특정 상수가 가질수 있는 값의 범위를 알고 싶으면 range() 메서드를 사용할 것

 

System.out.println(ChronoField.CLOCK_HOUR_OF_DAY.range());   // 1-24
System.out.println(ChronoField.HOUR_OF_DAY.range());         // 0 -23

 

    

예제1

import java.time.LocalTime;
import java.time.temporal.ChronoField;

class prac{
    public static void main (String[] args) {
    	LocalTime now = LocalTime.now();
    	int minute = now.getMinute();
    	System.out.println(minute);  // 49
    	
    	int minute2 = now.get(ChronoField.MINUTE_OF_HOUR);
    	System.out.println(minute2);  // 49
    }
}

LocalTime클래스의 메서드 중 getMinute() 와 get(ChronoField.MINUTE_OF_HOUR)는 기능 동일

날짜와 시간에서 특정 필드의 값만 얻을 떄는 get() 메서드나 get으로 시작하는 메서드를 이용할 것

 

 

 

예제2

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

class prac{
    public static void main (String[] args) {
    	LocalDate today = LocalDate.now();
    	
    	LocalDate tomorrow = today.plus(1, ChronoUnit.DAYS);
    	System.out.println(tomorrow);  // 2021-11-12
    	
    	LocalDate tomorrow2 = today.plusDays(1);
    	System.out.println(tomorrow);  // 2021-11-12
        
    }
}

LocalDate 클래스의 메서드 중 plus()와 plusDays()는 기능 동일

특정 날짜와 시간에서 지정된 단위의 값을 더하거나 뺄 때는 plus() 또는 minus() 메서드에 열거형ChronoUnit을 사용할 것

 

 

 

◎ LocalDate

• java.time 패키지의 가장 기본적인 클래스
• 날짜를 표현할 때 사용
• now() 메서드 또는 of() 메서드를 통해 인스턴스 생성
• LocalDate 클래스의 월(month) 값의 범위는 1~12 까지
  
  • Calendar 클래스는 월(month)값의 범위가  0~11 까지
• LocalDate 클래스의 요일값의 범위는 1~7 (1: 월요일, 2: 화요일, 3: 일요일..... 7: 일요일)
  • Calendar 클래스의 요일 값의 범위는 1~7 (1: 일요일, 2: 월요일, 3: 화요일, ...... 7: 토요일)

 

■ LocalDate 클래스 상수

제어자 타입 상수	설명
static LocalDate MAX	+999999999-12-31
static LocalDate MIN	-999999999-01-01

 

■ LocalDate 클래스 메서드

제어자 반환타입 메서드	설명
static LocalDate of(int year, Month month, int dayOfMonth) static LocalDate of(int year, int month, int dayOfMonth)	지정된 날짜 값을 가진 LocalDate 인스턴스 생성
static LocalDate now()	오늘 날짜 값을 가진 LocalDate 인스턴스 생성
static LocalDate ofYearDay(int year, int dayOfYear)	해당 연도에 몇 번째일 인지 지정
① static LocalDate parse(CharSequence text) ② static LocalDate parse(CharSequence text, DateTimeFormatter formatter)	① 문자열을 파싱하여 LocalDate 인스턴스 생성 매개변수를 "yyyy-MM-dd" 양식으로 적을 것 ② formatter 양식에 맞게 문자열을 파싱하여 LocalDate 인스턴스 생성
int getYear()	년도(year)값 반환
int getMonthValue()	월(month)값 반환  반환값 범위 : 1~12
Month getMonth()	월(month)값을 영어로 반환 ex) NOVEMBER
int getDayOfMonth	일(day)값 반환
int getDayOfYear()	같은 해의 1일1일부터 몇 번쨰 일
DayOfWeek getDayOfWeek()	요일값을 영어로 반환 ex) FRIDAY
int getDayOfWeek().getValue()	요일값 반환 1: 월요일, 2: 화요일, ....., 7: 일요일
int lengthOfMonth()	해당 달의 총 일수 (해당 달의 마지막 일)
int legnthOfYear()	해당 년의 총 일 수 (윤년일 경우 366, 윤년이 아닐 경우 365)
boolean isLeapYear()	윤년 여부 확인 윤년이면 true, 아니면 false
long getLong(TemporalField field)	필드값을 long 타입으로 반환
int get(TemporalField field)	필드 값을 int 타입으로 반환
① LocalDate with(TemporalAdjuster adjuster) ② LocalDate with(TemporalField field, long newValue)	① adjuster값으로 바뀐 시간과 날짜값을 가진 ZonedDateTime 인스턴스 생성 ② field값이 newValue값으로 바뀐 ZonedDateTime 인스턴스 생성
LocalDate withYear(int year)	년도(year)값 변경
LocalDate withMonth(int month)	월(month)값 변경
LocalDate withDayOfMonth(int dayOfMonth)	일(day)값 변경
LocalDate plus(long amountToAdd, TemporalUnit unit) LocalDate plus(TemporalAmount amountToAdd)	지정된 unit값에 amountToAdd값을 더함
LocalDate plusYears(long yearsToAdd)	년도(year)값에 yearsToAdd값 더함
LocalDate plusMonths(long monthsToAdd)	월(month)값에 monthToAdd값 더함
LocalDate plusDays(long daysToAdd)	일(day)값에 daysToAdd값 더함
LocalDate plusWeeks(long weeksToAdd)	주(week)값에 weeksToAdd값 더함
int compareTo(ChronoLocalDate other)	같으면1 other보다 이전이면 -1 other보다 이후면 1
boolean isAfter(ChronoLocalDate other)	other보다 이후면 true
boolean isBefore(ChronoLocalDate other)	other보다 이전이면 true
boolean isEqual(ChronoLocalDate other)	서로 같으면 true
boolean equals(Object obj)	서로 같으면 true
LocalDateTime atTime(int hour, int minute) LocalDateTime atTime(int hour, int minute, int second) LocalDateTime atTime(int hour, int minute, int second, int nanoOfSecond) LocalDateTime atTime(LocalTime time) LocalDateTime atTime(offsetTime time)	매개변수의 시간값을 추가한 LocalDateTime 인스턴스 생성
LocalDateTime atStrartOfDay()	자정 시간(00:00)을 추가한 LocalDateTime 인스턴스 생성
ZoneDateTime atStartOfDay(ZoneId zone)	매개변수의 시간대를 추가한 ZoneDateTime 인스턴스 생성
Period until(ChronoLocalDate endDateExclusive)	endDateExclusive 날짜와 차이값을 가진 Period 인스턴스 생성
long until(Temporal endDateExclusive, TemporalUnit unit)	unit양식에 맞는 값을 뺸 값
long toEpochDay()	에포크날(1970-010-01)로 부터 날짜를 세어서 반환
String format(DateTimeFormatter formatter)	지정된 형식에 맞게 문자열로 변환

• getMonthVolue() 메서드와 getMonth().getValue() 메서드는 서로 같음
• equals()메서드가 있는데 isEqual()메서드를 제공하는 이유는 연표(chronology)가 다른 두 날짜를 비교하기 위함
  • 모든 필드가 일치해야하는 equals()와 달리 isEqual()은 오직 날짜만 비교
• toEpochDay() 메서드를 이용해서 Period 클래스를 사용하지 않고 둘 날짜간의 일수를 편리하게 계산할 수 있음. 단, 두 날짜 모두 Epoch Day(1970-01-01) 이후 날짜여야 함

 

 

예제1

import java.time.LocalDate;

class prac{
    public static void main (String[] args) {

    	LocalDate today = LocalDate.now();
    	LocalDate day = LocalDate.of(2021, 12, 31);
    	LocalDate day2 = LocalDate.ofYearDay(1900,365);   // 1900년도에 365번째 일 → 1900년 12월 12일
    	LocalDate day3 = LocalDate.parse("2015-05-07");
    	
    	System.out.println(today);     // 2021-11-11
    	System.out.println(day);       // 2021-12-31
    	System.out.println(day2);      // 1900-12-31
    	System.out.println(day3);      // 2015-05-07
    	
    }
}

 

 

예제2

import java.time.LocalDate;
import java.time.chrono.JapaneseDate;

class prac{
    public static void main (String[] args) {
    	LocalDate kDate = LocalDate.of(1999, 12, 31);
    	JapaneseDate jDate = JapaneseDate.of(1999, 12, 31);
    	
    	System.out.println(kDate.equals(jDate));    // false
    	System.out.println(kDate.isEqual(jDate));   // true
    	
    }
}

kDate와 jDate의 YEAR_OF_ERA가 다르기 때문에 equals() 메서드에서는 false 반환

 

 

◎ LocalTime

• java.time 패키지의 가장 기본적인 클래스
• 시간을 표현할 때
• now() 메서드 또는 of() 메서드를 통해 인스턴스 생성

 

■ LocalTime 상수

제어자 타입 상수	설명
static LocalTime MAX	23:59:59.999999999
static LocalTime MIN	00:00
static LocalTime NOON	12:00 (정오)
static LocalTime MIDNIGHT	00:00 (자정)

 

■ LocalTime 클래스 메서드

제어자 반환타입	제어자 반환타입 메서드	설명
static LocalTime	of(int hour, int min) of(int hour, int min, int sec) of(int hour, int min, int sec, int nanoOfSecond)	지정된 시간 값을 가진 LocalDate 인스턴스 생성
static LocalTime	now()	현재 시간 값을 가진 LocalDate 인스턴스 생성
static LocalTime	ofSecondOfDay(long secondOfDay)	0시 0분 0초부터 secondOfDay초가 지난 시간을 의미 0  ≤ secondOfDay < 86400    (하루는 86400초)
static LocalTime	① parse(CharSequence text) ② parse(CharSequence text, DateTimeFormatter formatter)	① 문자열을 파싱하여 LocalTime 인스턴스 생성 매개변수를 "HH:mm:ss" 양식으로 적을 것  (ss는 생략 가능) ② DateTimeFormatter 양식에 맞게 문자열을 파싱하여 LocalTime 인스턴스 생성
int	getHour()	시
int	getMinute()	분
int	getSecond()	초
int	getNano()	나노초
long	getLong(TemporalField field)	필드값을 long 타입으로 반환
int	get(TemporalField field)	필드 값을 int 타입으로 반환
LocalTime	① with(TemporalAdjuster adjuster) ② with(TemporalField field, long newValue)	① adjuster값으로 바뀐 시간과 날짜값을 가진 ZonedDateTime 인스턴스 생성 ② field값이 newValue값으로 바뀐 ZonedDateTime 인스턴스 생성
LocalTime	withHour(int hour)	시 값 변경
LocalTime	withMinute(int minute)	분 값 변경
LocalTime	withSecond(int second)	초 값 변경
LocalTime	withNano(int nanoOfSecond)	나노 초 값 변경
LocalTime	plus(TemporalAmount amountToAdd) plus(long amountToAdd, TemporalUnit unit)	지정된 unit값에 amountToAdd값을 더함
LocalTime	plusHours(long hoursToAdd)	시 값에 hoursToAdd값 더함
LocalTime	plusMinutes(long minutesToAdd)	분 값에 minutesToAdd값 더함
LocalTime	plusSeconds(long secondsToAdd)	초 값에 secondsToAdd값 더함
LocalTime	plusNanos(long nanosToAdd)	나노초 값에 nanosToAdd값 더함
LocalTime	truncatedTo(TemporalUnit unit)	지정된 것보다 작은 단위의 필드를 0으로 만듦
int	compareTo(LocalTime other)	같으면 0 other인스턴스보다 이전이면 -1 other인스턴스보다 이후면 1
boolean	isAfter(LocalTime other)	other보다 이후면 true
boolean	isBefore(LocalTime other)	other보다 이전이면 true
LocalDateTime	atDate(LocalDate date)	매개변수인 날짜값을 추가한 LocalDateTime 인스턴스 생성
OffsetTime	atOffset(ZoneOffset offset)	매개변수인 offset값을 추가한 offsetTime 인스턴스 생성
long	until(Temporal endExclusive, TemporalUnit unit)	매개변수값을 가진 시간과의 차이 반환
int	toSecondOfDay()	시간을 초단위로 변환
long	toNanoOfDay()	시간을 나노초단위로 변환
String	format(DateTimeFormatter formatter)	지정된 형식에 맞게 문자열로 반환

• toSecondOfDay() 메서드 또는 toNanoOfDay()메서드를 통해서 Duration클래스를 사용하지 않고도 시간차이를 구할 수 있음

 

 

예제1

import java.time.LocalTime;

class prac{
    public static void main (String[] args) {
    	
    	LocalTime now = LocalTime.now();
    	LocalTime time = LocalTime.of(17, 30, 17);
    	LocalTime time2 = LocalTime.ofSecondOfDay(86399);   // 0시 0분 0초로부터 86399초가 지남 → 23시 59분 59초
    	LocalTime time3 = LocalTime.parse("14:25:30");
    	
    	System.out.println(now);     // 13:52:55.962 
    	System.out.println(time);    // 17:30:17
    	System.out.println(time2);   // 23:59:59
    	System.out.println(time3);   // 14:25:30
    	
    }
}

 

예제2

import java.time.LocalTime;
import java.time.temporal.ChronoUnit;

class prac{
    public static void main (String[] args) {
    	LocalTime now = LocalTime.of(19, 21, 35);
    	now  =now.truncatedTo(ChronoUnit.HOURS);  // 시(hour)보다 작은 단위를 0으로 만듦
    	System.out.println(now);  // 19:00
    }
}

 

 

예제3

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

class prac{
    public static void main (String[] args) {
    	LocalDate today = LocalDate.now();
    	LocalTime now = LocalTime.now();
    	
    	LocalDate birthDate = LocalDate.of(1999, 12, 31);
    	LocalTime birthTime = LocalTime.of(23, 59, 59);
    	
    	System.out.println(today);  // 2021-11-11
    	System.out.println(now);  // 21:28:54.193
    	System.out.println(birthDate);  // 1999-12-31
    	System.out.println(birthTime);  // 23:59:59
    	
    	System.out.println(birthDate.withYear(2000));  // 2000-12-31
    	System.out.println(birthDate.plusDays(1));  // 2000-01-01
    	System.out.println(birthDate.plus(1, ChronoUnit.DAYS));  // 2000-01-01
    	
    	
    	System.out.println(birthTime.truncatedTo(ChronoUnit.HOURS));  // 23:00
    	
    	System.out.println(ChronoField.CLOCK_HOUR_OF_DAY.range());  // 1 - 24
    	System.out.println(ChronoField.HOUR_OF_DAY.range());  // 0 - 23
 
    }
}

 

 

 

 

◎ Instant 클래스

• Instant 클래스는 에포크 타임(EPOCH TIME, 1970-01-01 00:00:00 UTC)로부터 경과된 시간을 나노초 단위로 표현
• 단일 진법(10진법)으로만 다루기 때문에 계산 용이
• Instant 인스턴스를 생성하려면 now() 메서드 또는 ofEpochSecond() 메서드 이용할 것
• 특정 시점의 타임스탬프(Time-Stamp)로 사용
• 주로 특정한 두 시점간의 시간적 우선순위를 따질 때 사용
• java.util.Date 클래스와 기능 유사. 차이점은 Date 클래스는 로컬 컴퓨터의 현재 날짜와 시간 정보를 기준으로 하지만 Instant 클래스는 협정세계시(1970-01-01 00:00:00 UTC)가 기준 
  
  • Instant 클래스는 기존의 java.util.Date를 대체하기 위한 것
• Instant는 항상 UTC(+00:00)를 기준으로 하기 때문에 LocalTime과 차이가 있을 수 있음
  • 한국은 시간대가 UTC 기준 '+09:00' 이므로 Instant와 LocalTime간에 9시간의 시간차가 발생 가능
  • 시간대를 고려하는 경우 OffsetDateTime 클래스를 사용하는것이 더 나을 수도 있음

 

■ Instant 메서드

제어자 반환타입 메서드	설명
static Instant now() static Instant now(Clock clock)	현재 시간 값을 가진 Instant 인스턴스 생성
static Instant ofEpochSecond(long epochSecond) static Instant ofEpochSecond(long epochSecond, long nanoAdjustment)	에포크 타임 1970-01-01 00:00:00 UTC 기준으로부터 second초 값이 지난 Instant 인스턴스 생성
long getEpochSecond()	초 단위의 타임스태프값 반환
long toEpochMilli()	밀리초 단위의 타임스태프값 반환
long getnano()	나노초 단위의 타임스태프값 반환

 

■ 인스턴스 상수

제어자 타입 상수	설명
static Instant EPOCH	epoch 인스턴스
static Instant MAX	'1000000000-12-31T23:59:59.999999999Z' 값을 가진 Instant 인스턴스
static Instant MIN	'-1000000000-01-01T00:00Z' 값을 가진  Instant 인스턴스

 

 

 

■ Instant 클래스와 Date 클래스간의 변환

 

Date → Instant  (Date 메서드)

반환타입	메서드	설명
Instant	toInsatnt()	Date → Instant 변환

 

Instant → Date (Date 메서드)

제어자 반환타입	메서드	설명
static Date	from(Instant instant)	Instant → Date 변환

 

 

 

 

 

◎ LocalDateTime 클래스

• LocalDate 클래스와 LocalTime 클래스를 합친것
• of()메서드 또는 now() 메서드를 통해 인스턴스 생성
• import java.time.LocalDateTime; 쓸 것

 

■  LocalDateTime 메서드

제어자 반환타입	접근자 반환타입 메서드	설명
static LocalDateTime	now()	현재 시간과 날짜 값을 가진 LocalDateTime 인스턴스 생성
static LocalDateTime	of(int year, int month, int dayOfMoth, int hour, int minute) of(int year, int month, int dayOfMonth, int hour, int minute, int second) of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond) of(int year, Month month, int dayOfMonth, int hour, int minute) of(int year, Month month, int dayOfMonth, int hour, int minute, int second) of(int year, Month month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond) of(LocalDate date, LocalTime time)	매개변수의 값에 따른 시간와 날짜 값을 가진 LocalDateTime 인스턴스 생성
LocalDate	toLocalDate()	LocalDate 인스턴스로 변환
LocalTime	toLocalTime()	LocalTime 인스턴스로 변환
ZoneDateTime	atZone(ZoneId zone)	매개변수인 zone 시간대를 합친 ZoneDateTime 인스턴스 생성
LocalDateTime	① with(TemporalAdjuster adjuster) ② with(TemporalField field, long newValue)	① adjuster값으로 바뀐 시간과 날짜값을 가진 ZonedDateTime 인스턴스 생성 ② field값이 newValue값으로 바뀐 ZonedDateTime 인스턴스 생성
String	format(DateTimeFormatter formatter)	지정된 형식에 맞게 문자열로 반환
static LocalDateTime	① parse(CharSequence text) ② parse(CharSequence text, DateTimeFormatter formatter)	① 문자열을 파싱하여 LocalDateTime 인스턴스 생성 "yyyy-MM-ddTHH:mm:ss" 양식으로 넣을것 ex) "2015-07-01T17:15:23" ② formatter 양식의 문자열을 파싱하여 LocalDateTime 인스턴스 생성

 

 

예제1

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

class prac{
    public static void main (String[] args) {
    	LocalDateTime dateTime = LocalDateTime.of(2015, 11 , 12, 5, 24, 36);
    	LocalDateTime today = LocalDateTime.now();
    	System.out.println(dateTime);  // 2015-11-12T05:24:36
    	System.out.println(today);  // 2021-11-12T12:10:50.992
    	
    	LocalDate date = LocalDate.of(2021,11, 12);
    	LocalTime time = LocalTime.of(12,34 ,56);
    	
    	LocalDateTime dt = LocalDateTime.of(date, time);
    	LocalDateTime dt2 = date.atTime(time);
    	LocalDateTime dt3 = date.atTime(16, 50, 30);
    	LocalDateTime dt4 = date.atStartOfDay();
    	LocalDateTime dt5 = time.atDate(date);
    	LocalDateTime dt6 = time.atDate(LocalDate.of(2015, 12, 31));
    	
    	System.out.println(dt);  // 2021-11-12T12:34:56
    	System.out.println(dt2);  // 2021-11-12T12:34:56
    	System.out.println(dt3);  // 2021-11-12T16:50:30
    	System.out.println(dt4);  // 2021-11-12T00:00
    	System.out.println(dt5);  // 2021-11-12T12:34:56
    	System.out.println(dt6);  // 2015-12-31T12:34:56
    	
    }
}

여러 방법의 LocalDateTime 인스턴스 생성 

 

 

예제2

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

class prac{
    public static void main (String[] args) {
    	LocalDateTime dt = LocalDateTime.of(2021,10,15, 12,34,55);
    	LocalDate date = dt.toLocalDate();
    	LocalTime time = dt.toLocalTime();
    	
    	System.out.println(dt);  // 2021-10-15T12:34:55
    	System.out.println(date);  // 2021-10-15
    	System.out.println(time);  // 12:34:55
    	
    }
}

LocalDateTime을 LocalDate 또는 LocalTime으로 변환

 

 

 

 

◎ ZonedDateTime

• LocalDateTime 클래스와 시간대(time-zone)를 합친 클래스
• import java.time.ZonedDateTime; 쓸 것
• 기존에는 TimeZone 클래스로 시간대를 다뤘지만 새로운 시간 패키지에서는 ZoneId 클래스를 사용
• LocalDateTime클래스에 atZone() 메서드를 사용해서 시간대 정보를 추가하여 ZonedDateTime 인스턴스를 얻을 수 있음
• GregorianCalendar 클래스와 유사

 

 

■ ZonedDateTime 메서드

제어자 반환타입	메서드	설명
static ZonedDateTime	① now() ② now(ZoneId zone) ③ now(Clock clock)	① 기본시간대와 현재날짜와 시간값을 가진 ZonedDateTime 인스턴스 생성 ② 매개변수인 zone값의 시간대를 가진 현재 시간와 날짜값을 가진ZonedDateTime 인스턴스 생성 ③ 기본 시간대와 매개변수인 clock을 값을 가진 ZonedDateTime 인스턴스 생성
static ZonedDateTime	of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneId zone) of(LocalDate date, LocalTime time, ZoneId zone) of(LocalDateTime localDateTime, ZoneId zone)	매개변수 값을 가진 ZonedDateTime 인스턴스 생성
ZoneDateTime	withZoneSameInstant(ZoneId zone)	시간과 날짜값은 유지한채 매개변수인 zone 시간대값을 가진 ZonedDateTime 인스턴스 반환
ZoneOffset	getOffset()	UTC로부터 몇 초만큼 차이가 나는지 그 차이값을 갖는  ZoneOffSet 인스턴스 생성
OffsetDateTime	toOffsetDateTime()	시간과 날짜를 OffsetDateTime 인스턴스로 변환후 생성
LocalDate	toLocalDate()	ZonedDateTime → LocalDate 변환
LocalTime	toLocalTime()	ZonedDateTime → LocalTime 변환
LocalDateTime	toLocalDateTime()	ZonedDateTime → LocalDateTime 변환
OffsetDateTime	toOffsetDateTime()	ZonedDateTime → OffsetDateTime 변환
long	toEpochSecond()	epoch시간 기준으로 날짜와 시간을 초 단위로 변환
Instant	toInstant()	ZonedDateTime → Instant 변환
ZoneId	getZone()	시간대 값을 가져옴 ex) 'Asia/Seoul' , 'Europe/Paris'
ZonedDateTime	① with(TemporalAdjuster adjuster) ② with(TemporalField field, long newValue)	① adjuster값으로 바뀐 시간과 날짜값을 가진 ZonedDateTime 인스턴스 생성 ② field값이 newValue값으로 바뀐 ZonedDateTime 인스턴스 생성
static ZonedDateTime	① parse(CharSequence text) ② parse(CharSequence text, DateTimeFormatter formatter)	① 문자열을 파싱하여 ZonedDateTime 인스턴스 생성 "yyyy-MM-ddTHH:mm:ss+UTC[ZoneId]" ex) "2015-10-11T12:34:56+09:00[Asia/Seoul]" ex) "2017-11-12T01:25:58+01:00[Europe/Paris]" ② formatter 양식에 맞게 ZonedDateTime 인스턴스 생성
String	format(DateTimeFormat formatter)	formatter 양식에 맞게 문자열로 생성

• toEpochSecond() 메서드와 toInstant() 메서드는 ChronoZonedDateTime 인터페이스에서 상속 받은 것

 

 

■ GregorianCalendar 클래스 메서드

제어자 반환타입	메서드	설명
static GregorianCalendar	from(ZonedDateTime zdt)	ZonedDateTime → GregorianCalendar 변환
ZonedDateTime	toZonedDateTime()	GregorianCalendar → ZonedDateTime 변환

• GregorianCalendar클래스 와 ZonedDateTime 클래스 변환 방법

 

◎ ZoneId 클래스

• ZoneId 클래스는 일광 절약시간(DST, Daylight Saving Time)을 자동적으로 처리해주므로 편함
• ZoneId 클래스 사용시 import java.timeZoneId; 쓸 것
• 사용가능한 ZoneId의 목록은 ZoneId.getAvailableZoneIds()로 얻을 수 있음

 

■ ZoneId 메서드

제어자 반환타입	메서드	설명
static ZoneId	of(String zoneId)	zodeid값을 가진 ZoneId인스턴스 생성
abstract String	getId()	시간대 값을 문자열로 변환

 

 

예제1

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

class prac{
    public static void main (String[] args) {
    	LocalDateTime dateTime = LocalDateTime.now();
    	ZoneId zid = ZoneId.of("Asia/Seoul"); 
    	System.out.println(zid);  // Asia/Seoul
    	
    	ZonedDateTime zdt = dateTime.atZone(zid);
    	System.out.println(zdt);  // 2021-11-12T12:30:16.137+09:00[Asia/Seoul]
    	
    }
}

LocalDateTime 클래스에 ZoneId 클래스를 합쳐 ZonedDateTime 클래스 인스턴스 생성

 

 

예제2

import java.time.LocalDate;
import java.time.ZoneId;
import java.time.ZonedDateTime;

class prac{
    public static void main (String[] args) {
    	ZoneId zid = ZoneId.of("Asia/Seoul");
    	System.out.println(zid);  // Asia/Seoul
    	
    	ZonedDateTime zdt = LocalDate.now().atStartOfDay(zid);
    	System.out.println(zdt);  // 2021-11-12T00:00+09:00[Asia/Seoul]
    	
    }
}

LocalDate 인스턴스의 atStartOfDay(ZoneId zone) 메서드를 이용하여 ZonedDateTime 인스턴스 생성 

 

 

예제3

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

class prac{
    public static void main (String[] args) {
    	ZoneId nyId = ZoneId.of("America/New_York");
    	ZonedDateTime nyTime = ZonedDateTime.now().withZoneSameInstant(nyId);
    	
    	System.out.println(nyId);    // America/New_York
    	System.out.println(nyTime);  // 2021-11-12T02:58:49.199-05:00[America/New_York]
    }
}

현재 날짜의 현재 시간에 특정 시간대를 구함

 

 

◎ ZoneOffset 클래스

• UTC로부터 얼마만큼 떨어져있는지를 ZoneOffSet 클래스로으로 표현
• 서울은 +9 (UTC보다 9시간 빠름, 9시간 = 32400초) 
• import java.time.ZoneOffset; 쓸 것
• ZoneId는 일광절약시간처럼 시간대와 관련된 규칙들을 포함하고 있는데 ZoneOffset은 단지 시간대를 시간의 차이로만 구분

 

 

■ ZoneOffset 메서드

제어자 반환타입	메서드	설명
int	get(TemporalField field)	offset 인스턴스에 저장된 field값을 가져옴

 

 

 

예제1

import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.temporal.ChronoField;

class prac{
    public static void main (String[] args) {
    	ZoneOffset krOffset = ZonedDateTime.now().getOffset();
    	System.out.println(krOffset);  // +09:00
    	
    	ZoneOffset krOffset2 = ZoneOffset.of("+9");
    	System.out.println(krOffset2);  // +09:00
    	
    	int krOffsetInsec = krOffset.get(ChronoField.OFFSET_SECONDS);
    	System.out.println(krOffsetInsec);  // 32400
    	
    }
}

ZonedDateTime.now().getOffset() 이랑 ZoneOffset.of("+9") 와 기능이 동일

 

 

◎ OffsetDateTime 클래스

• OffsetDateTime 클래스는 ZoneOffset으로 시간대 표현
• 서로 다른 시간대의 컴퓨터간의 통신에 유용
• ZonedDateTime은 ZoneId로 구역을 표현하는데 OffsetDateTime 클래스는 ZoneId가 아닌 ZoneOffset을 사용
• 같은 지역내의 컴퓨터간에 데이터를 주고 받을 때, 전송시간을 표현하기에 LocalDateTime이면 충분하지만, 서로 다른 시간대에 존재하는 컴퓨터간의 통신에는 OffsetDateTime이 필요
• OffsetDateTime 클래스는 ZonedDateTime처럼, LocalDate와 LocalTime에 ZoneOffset을 더하거나, ZonedDateTime에 toOffsetDateTime()을 호출해서 얻을 수 있음 

 

 

■ OffsetDateTime 메서드

제어자 반환타입	메서드	설명
static OffsetDateTime	of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset) of(LocalDate date, LocalTime time, ZoneOffset offset) of(LocalDate date, LocalTime time, ZoneId zone)	매개변수의 값을 가진 OffsetDateTime 인스턴스 생성

 

 

 

예제1

import java.time.LocalDate;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;

class prac{
    public static void main (String[] args) {
    	LocalDate date = LocalDate.now();
    	LocalTime time = LocalTime.now();
    	ZoneId zid = ZoneId.of("Asia/Seoul");
    	
    	ZonedDateTime zdt = ZonedDateTime.of(date, time, zid);
    	System.out.println(zdt);
    	
    	OffsetDateTime odt = zdt.toOffsetDateTime();
    	System.out.println(odt);
    }
}

ZonedDateTime 클래스의 toOffsetDateTime() 메서드를 통해 OffsetDateTime 인스턴스 생성

 

 

 

 

 

예제2

import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.OffsetDateTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;

class prac{
    public static void main (String[] args) {
    	LocalDate date = LocalDate.of(2021, 11, 12);
    	LocalTime time = LocalTime.of(19, 13);
    	LocalDateTime dt = LocalDateTime.of(date, time);
    	ZoneId zid = ZoneId.of("Asia/Seoul");
    	ZonedDateTime zdt = dt.atZone(zid);
    	
    	// 시간대를 문자열로 변환
    	String strZid = zdt.getZone().getId();
    	ZoneId zi = zdt.getZone();
    	
    	
    	ZonedDateTime seoulTime = ZonedDateTime.now();
    	ZoneId nyId = ZoneId.of("America/New_York");

    	// 시간대를 nyId 값으로 변경
    	ZonedDateTime nyTime = ZonedDateTime.now().withZoneSameInstant(nyId);
    	
    	// ZonedDateTime → OffsetDateTime 변환
    	OffsetDateTime odt = zdt.toOffsetDateTime();
    	
    	
    	System.out.println(zi);          // Asia/Seoul
    	System.out.println(strZid);      // Asia/Seoul
    	System.out.println(dt);         // 2021-11-12T19:13
    	System.out.println(zid);        // Asia/Seoul
    	System.out.println(nyTime);     // 2021-11-12T05:28:33.478-05:00[America/New_York]
    	System.out.println(zdt);        // 2021-11-12T19:13+09:00[Asia/Seoul]
    	System.out.println(odt);        // 2021-11-12T19:13+09:00
    	
    }
}

 

 

 

 

 

◎ TemporalAdjusters 클래스

• 날짜 계산 메서드를 정의해놓은 것
• plus(), minus() 메서드로 날짜를 계산하기엔 복잡하기에 TemporalAdjusters 클래스를 사용할 것
• import TemporalAdjusters; 쓸 것

 

■ TemporalAdjusters 메서드

제어자 반환타입	메서드	설명
static TemporalAdjuster	firstDayOfNextYear()	다음 해의 첫 날
static TemporalAdjuster	firstDayOfNextMonth()	다음달의 첫 날
static TemporalAdjuster	firstDayOfYear()	올 해의 첫 날
static TemporalAdjuster	firstDayOfMonth()	이번 달의 첫 날
static TemporalAdjuster	lastDayOfYear()	올해의 마지막 날
static TemporalAdjuster	lastDayOfMonth()	이번 달의 마지막 날
static TemporalAdjuster	firstInMonth(DayOfWeek dayOfWeek)	이번 달의 첫 번째 ? 요일
static TemporalAdjuster	lastInMonth(DayOfWeek dayOfWeek)	이번 달의 마지막 ?요일
static TemporalAdjuster	previous(DayOfWeek dayOfWeek)	지난 ?요일 (당일 미포함)
static TemporalAdjuster	previousOrSame(DayOfWeek dayOfWeek)	지난 ?요일(당일 포함)
static TemporalAdjuster	next(DayOfWeek dayOfWeek)	다음 ?요일 (당일 미포함)
static TemporalAdjuster	nextOfSame(DayOfWeek dayOfWeek)	다음 ?요일 (당일 포함)
static TemporalAdjuster	dayOfWeekInMonth(int ordinal, DayOfWeek dayOfWeek)	이번 달의 n번째 ?요일

 

 

 

 

◎ TemporalAdjuster 인터페이스 구현

public interface TemporalAdjuster {
    Temporal adjustInto(Temporal temporal);
}

• 필요시 날짜 계산 메서드를 만들 수 있음
• 메서드 작성시 매개변수를 TemporalAdjuster인터페이스를 구현한 클래스의 객체로 설정할 것
• TemporalAdjuster 인터페이스를 구현한 클래스의 객체를 매개변수로 제공해야함
• TemporalAdjuster인터페이스 구현히 adjustInto() 메서드 구현할 것
• 날짜와 시간에 관련된 대부분의 클래스는 Temporal인터페이스를 구현한것이므로 adjustInto()의 매개변수가 될 수 있음
• adjustInto()메서드만 구현하고 사용할때는 with() 메서드의 매개변수로 사용할 것
• import java.time.temporal.TemporalAdjuster; , import java.time.temporal.Temporal;  쓸 것

 

 

◎ DayOfWeek 클래스

• import java.time.DayOfWeek; 쓸 것

 

■ DayOfWeek 상수값

상수	설명
MONDAY	월요일
TUESDAY	화요일
WEDNESDAY	수요일
THURSDAY	목요일
FRIDAY	금요일
SATURDAY	토요일
SUNDAY	일요일

 

 

예제1

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

class DayAfterTomorrow implements TemporalAdjuster{  // 특정 날짜로부터 2일후의 날짜를 계산
	@Override
	public Temporal adjustInto(Temporal temporal) {
		return temporal.plus(2, ChronoUnit.DAYS);
	}
}

class prac{
    public static void main (String[] args) {
    	LocalDate today = LocalDate.now();
    	LocalDate date = today.with(new DayAfterTomorrow());  // TemporalAdjuster를 구현한 메서드를 with()의 매개변수로 사용할 것
    	
    	p(today);
    	p(date);
    	
    	p(today.with(TemporalAdjusters.firstDayOfNextMonth()));   // 다음 달의 첫 날
    	p(today.with(TemporalAdjusters.firstDayOfMonth()));  // 이달의 첫 날
    	p(today.with(TemporalAdjusters.lastDayOfMonth()));  // 이 달의 마지막 날
    	p(today.with(TemporalAdjusters.firstInMonth(DayOfWeek.TUESDAY)));  // 이 달의 첫번째 화요일
    	p(today.with(TemporalAdjusters.lastInMonth(DayOfWeek.TUESDAY)));  // 이 달의 마지막 화요일
    	p(today.with(TemporalAdjusters.previous(DayOfWeek.TUESDAY)));  // 지난 주 화요일
    	p(today.with(TemporalAdjusters.previousOrSame(DayOfWeek.TUESDAY)));  // 지난 주 화요일 (오늘 포함)
    	p(today.with(TemporalAdjusters.next(DayOfWeek.TUESDAY)));  // 다음 주 화요일
    	p(today.with(TemporalAdjusters.nextOrSame(DayOfWeek.TUESDAY)));  // 다음 주 화요일 (오늘 포함)
    	p(today.with(TemporalAdjusters.dayOfWeekInMonth(4, DayOfWeek.TUESDAY)));  // 이 달의 4번째 화요일
    	
    }
    static void p(Object obj) {  //라인의 길이를 줄이기 위한 새로 정의한 메서드
    	System.out.println(obj);
    }
    
}

/* 출력값
2021-11-12
2021-11-14
2021-12-01
2021-11-01
2021-11-30
2021-11-02
2021-11-30
2021-11-09
2021-11-09
2021-11-16
2021-11-16
2021-11-23
*/

 

 

 

 

◎ Period 클래스

• 날짜의 차이를 계산하기 위한 클래스
• import java.time.Period; 쓸 것

 

■ Period 메서드

제어자 반환타입	메서드	설명
static Period	between(LocalDate startDateInclusive, LocalDate endDateExclusive)	두 날짜의 차이 값을 가진 Period 인스턴스 생성
long	get(TemporalUnit unit)	unit 값 반환
int	getDays()	일
int	getMonths()	월
int	getYears()	년
List<temporalUnit>	getUnits()	해당 Period인스턴스가 가지고 있는 필드들을 리스트 형태로 반환
static Period	of(int years, int months, int days)	해당 매개변수를 갖는 Period 인스턴스 생성
static Period	ofDays(int days)	해당 매개변수를 갖는 Period 인스턴스 생성
static Period	ofMonths(int months)	해당 매개변수를 갖는 Period 인스턴스 생성
static Period	ofYears(int years)	해당 매개변수를 갖는 Period 인스턴스 생성
static Period	ofWeeks(int weeks)	해당 매개변수를 갖는 Period 인스턴스 생성
Period	withDays(int days)	해당 매개변수 값을 바꾼 Period 인스턴스 생성
Period	withMonths(int months)	해당 매개변수 값을 바꾼 Period 인스턴스 생성
Period	withYears(int years)	해당 매개변수 값을 바꾼 Period 인스턴스 생성
Period	plus(TemporalAmount amountToAdd)	매개변수 값을 추가한 Period인스턴스 생성
Period	plusDays(long daysToAdd)	매개변수 값을 추가한 Period인스턴스 생성
Period	plusMonths(long monthsToAdd)	매개변수 값을 추가한 Period인스턴스 생성
Period	plusYears(long yearsToAdd)	매개변수 값을 추가한 Period인스턴스 생성
Period	multipliedBy(int scalar)	날짜를 곱함
boolean	isZero()	0인지 아닌지 판단 0이면 true
boolean	isNegative()	음수면 true
Period	normalized()	월(month) 값을 12를 넘기 않게 바꿈. 12를 넘어갈 경우 년 값을 올림. 일(day) 값은 일정하지 않기 때문에 그대로 놔둠 ex) 1년 13개월 → 2년 1개월
long	toTotalMonths()	년월일을 월 단위로 변환해서 반환 (일 단위는 무시)

• Period클래스의 between() 메서드와 LocalDate클래스의 until()메서드는 같은 기능을 가짐. 단, between()은 static 메서드며 until()은 인스턴스 메서드라는 차이를 가짐
• Period 클래스는 년월일을 분리해서 저장하기 때문에 D-day를 구하려면 두 개의 매개변수를 받는 until(Temporal endExclusive, TemporalUnit unit) 을 사용할 것

 

 

예제1

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

class prac{
    public static void main (String[] args) {
    	LocalDate date1 = LocalDate.of(2014,1, 1);
    	LocalDate date2 = LocalDate.of(2015, 12, 31);
    	
    	Period pe = Period.between(date1, date2);
    	System.out.println(pe);  // P1Y11M30D
    	
    	System.out.println(pe.getUnits());  // [Years, Months, Days]
    }
}

between() 메서드를 통해 날짜차 구하기

 

 

 

 

◎ Duration 클래스

• 시간 차이 계산하기 위한 클래스
• import java.time.Duration; 쓸 것
• Duration 클래스의 메서드는 Chrono.SECONDS 와 Chrono.NANOS 타입만 반환 받을 수 있음. 시, 분, 초 값으로는 반환 받을 수 없음
• 그래서 Duration을 LocalTime으로 변환한 다음에 LocalTime의 메서드인 getHour(), getMinute(), getSecond(), getNano() 메서드를 통해서 여러 타입의 반환 값을 얻어올 것 

 

■ Duration 메서드

제어자 반환타입	메서드	설명
static Duration	between(Temporal startInclusive, Temporal endExclusive)	두 날짜의 차이 값을 가진 Period 인스턴스 생성
long	get(TemporalUnit unit)	unit 값 반환
long	getSeconds()	초
int	getNano()	나노 초
List<TemporalUnit>	getUnits()	해당 Duration인스턴스가 가지고 있는 필드들을 리스트 형태로 반환
static Duration	of(long amount, TemporalUnit unit)	해당 매개변수를 갖는 Period 인스턴스 생성
static Duration	ofDays(long days)	해당 매개변수를 갖는 Period 인스턴스 생성
static Duration	ofHours(long hours)	해당 매개변수를 갖는 Period 인스턴스 생성
static Duration	ofMinutes(long minutes)	해당 매개변수를 갖는 Period 인스턴스 생성
static Duration	ofSeconds(long seconds) ofSeconds(long seconds, long nanoAdjustment)	해당 매개변수를 갖는 Period 인스턴스 생성
static Duration	ofNanos(long minutes)	해당 매개변수를 갖는 Period 인스턴스 생성
static Duration	ofMillis(long millis)	해당 매개변수를 갖는 Period 인스턴스 생성
Duration	plus(Duration duration) plus(long amountToAdd, TemporalUnit unit)	매개변수 값을 추가한 Duration인스턴스 생성
Duration	plusDays(long daysToAdd)	매개변수 값을 추가한 Duration인스턴스 생성
Duration	plusHours(long hoursToAdd)	매개변수 값을 추가한 Duration인스턴스 생성
Duration	plusMinutes(long minutesToAdd)	매개변수 값을 추가한 Duration인스턴스 생성
Duration	plusSeconds(long secondsToAdd)	매개변수 값을 추가한 Duration인스턴스 생성
Duration	plusNanos(long nanosToAdd)	매개변수 값을 추가한 Duration인스턴스 생성
Duration	plusMillis(long millisToAdd)	매개변수 값을 추가한 Duration인스턴스 생성
Duration	plus(Duration duration) plus(long amountToAdd, TemporalUnit unit)	매개변수 값을 뺀 Duration인스턴스 생성
Duration	minusDays(long daysToSubtract)	매개변수 값을 뺀 Duration인스턴스 생성
Duration	minusHours(long hoursToSubtract)	매개변수 값을 뺀 Duration인스턴스 생성
Duration	minusMinutes(long minutesToSubtract)	매개변수 값을 뺀 Duration인스턴스 생성
Duration	minusSeconds(long secondsToSubtract)	매개변수 값을 뺀 Duration인스턴스 생성
Duration	minusNanos(long nanosToSubtract)	매개변수 값을 뺀 Duration인스턴스 생성
Duration	minusMillis(long millisToSubtract)	매개변수 값을 뺀 Duration인스턴스 생성
Duration	multipliedBy(long multiplicand)	시간을 곱한 값을 가진 Duration 인스턴스 생성
Duration	divideBy(long divisior)	시간을 나눈 값을 가진 Duration 인스턴스 생성
boolean	isZero()	값이 0이면 true
boolean	isNegative()	시간차이가 음수면 true
Duration	negated()	부호를 반대로 바꿈 음수 → 양수 양수 → 음수
Duration	abs()	시간차이 값을 양수로 바꿈
long	toDays()	일 단위로 변환
long	toHours()	시간 단위로 변환
long	toMinutes()	분 단위로 변환
long	toNanos()	나노초 단위로 변환
long	toMillis()	천분의 일초 단위로 변환

 

 

예제1 

import java.time.Duration;
import java.time.LocalTime;

class prac{
    public static void main (String[] args) {
    	LocalTime time1 = LocalTime.of(00, 00,00);
    	LocalTime time2 = LocalTime.of(12, 34,56);
    	
    	Duration du = Duration.between(time1, time2);
    	System.out.println(du);  // T12H34M56S
    	
    	System.out.println(du.getUnits());  // [Seconds, Nanos]

    }
}

between() 메서드를 통해 시간차 구하기

 

예제2

import java.time.Duration;
import java.time.LocalTime;

class prac{
    public static void main (String[] args) {
    	LocalTime time1 = LocalTime.of(0, 0, 0); 
    	LocalTime time2 = LocalTime.of(12, 34, 56); 
    	Duration du = Duration.between(time1, time2);
    	
    	LocalTime tmpTime = LocalTime.of(0, 0).plusSeconds(du.getSeconds());
    	
    	int hour = tmpTime.getHour();
    	int min = tmpTime.getMinute();
    	int sec = tmpTime.getSecond();
    	int nano = tmpTime.getNano();
    	int nano2 = du.getNano();
    	
    	System.out.println(tmpTime);  // 12:34:56
    	System.out.println(hour);  // 12
    	System.out.println(min);  // 34
    	System.out.println(sec);  // 56
    	System.out.println(nano);  // 0
    	System.out.println(nano2);  // 0
    	
    }
}

시, 분, 초 값을 얻기 위해 Duration을 LocalTime로 변환 후 LocalTime 클래스의 get 메서드들을 사용후 시, 분. 초값을 가져옴 

 

 

예제3

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

class prac{
    public static void main (String[] args) {
    	LocalDate day1 = LocalDate.of(2021, 11, 10);
    	LocalDate day2 = LocalDate.of(2021, 11, 13);
    	
    	Period pe = Period.between(day1, day2);
    
    	Period pe2 = day1.until(day2);
    	long d_day = day1.until(day2, ChronoUnit.DAYS);
    	
    	
    	System.out.println(pe);   // P3D
    	System.out.println(pe2);  // P3D
    	System.out.println(d_day);  // 3
    	
    	
    }
}

Period 클래스의 between() 메서드는 static 메서드이지만 LocalDate클래스의 until()메서드는 인스턴스 메서드

Period클래스는 년월일을 분리해서 저장하기 때문에 D-day를 구하려는 경우에는 두 개의 매개변수를 받는 until(Temporal endExclusive, TemporalUnit unit) 사용할 것

 

 

예제4

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;
import java.time.temporal.ChronoUnit;

class prac{
    public static void main (String[] args) {

    	Period pe = Period.of(1, 12, 31);
    	
    	Duration du = Duration.of(60, ChronoUnit.SECONDS);
    	Duration du2 = Duration.ofSeconds(60);
    	
    	System.out.println(pe);   // P1Y12M31D
    	System.out.println(du);   // PT1M 
    	System.out.println(du2);   // PT1M
    	
    	
    	// with() 함수로 필드값 변경
    	pe = pe.withYears(2);   // 1년 → 2년
    	du = du.withSeconds(120);  // 60초 → 120초
    	
    	System.out.println(pe);   // P2Y12M31D
    	System.out.println(du);  // PT2M
    	
    	
    	// 사칙연산
    	pe = pe.minusYears(1).multipliedBy(2);  // 1년 빼고 2년 곱함
    	du = du.plusHours(1).dividedBy(60);   // 1시간 더하고 60으로 나눔
    	
    	System.out.println(pe);   // P2Y24M62D
    	System.out.println(du);   // PT1M2S
    	
    	
    	// 비교연산
    	LocalDate date1 = LocalDate.of(2021, 10, 1);
    	LocalDate date2 = LocalDate.of(2021, 10, 1);
    	
    	LocalTime time1 = LocalTime.of(15, 15);
    	LocalTime time2 = LocalTime.of(17, 25);
    	
    	
    	boolean sameDate = Period.between(date1, date2).isZero();
    	boolean isBefore = Duration.between(time1, time2).isNegative();  // 음수일 경우 true
    	
    	System.out.println(sameDate);   // true
    	System.out.println(isBefore);  // false
    	
    	
    	// 부호 바꾸기
    	Duration du3 = Duration.ofDays(-5);
    	System.out.println(du3);  // PT-120H
    	
    	if(du3.isNegative()) {  // du3 값이 음수일경우
    		du3 = du3.negated();  // 부호변경  양수 → 음수   ,  음수 → 양수
    		System.out.println(du3);  // PT120H
    	}
    	
    	du3 = du3.abs();  // 부호를 무조건 양수로 바꿈 
    	System.out.println(du3);   // PT120H
    	
    	
    	Period pe2 = Period.ofDays(-4);
    	System.out.println(pe2);  // P-4D
    	
    	if(pe2.isNegative()) {   // 값이 음수일경우
    		pe2 = pe2.negated();  // 부호를 바꿈   양수 → 음수   ,  음수 → 양수
    	}
    	
    	System.out.println(pe2);  // P4D
    	
    	
    	// normalized()
    	Period pe3 = Period.of(1, 13, 33);
    	System.out.println(pe3);  // P1Y13M33D
    	
    	pe3 = pe3.normalized();
    	System.out.println(pe3);  // P2Y1M33D
    	
    }
}

Period클래스는 abs() 메서드가 없음

normalized()메서드는 월(month) 값을12를 넘지 않게 년도(year) 값을 올려서 값을 바꿔주지만 일(day)값을 달마다 바뀌기 때문에 일(day)값은 변경하지 않음

 

 

 

 

예제5

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

class prac{
    public static void main (String[] args) {

    	LocalDate date1 = LocalDate.of(2015, 11, 28);
    	LocalDate date2 = LocalDate.of(2015, 11, 29);
    	
    	long period = date2.toEpochDay() - date1.toEpochDay();
    	System.out.println(period);  // 1
    		
    	
    	LocalTime time1 = LocalTime.of(10, 50);
    	LocalTime time2 = LocalTime.of(11, 50);
    	
    	int duration = time1.toSecondOfDay() - time2.toSecondOfDay();
    	System.out.println(duration);  // -3600
    	
    	long duration2 = time1.toNanoOfDay() - time2.toNanoOfDay();
    	 System.out.println(duration2);  // -3600000000000
    	 
    }
}

Period 클래스와 Duration 클래스 없이 시간차, 날짜차이 구하기

 

 

예제6

import java.time.Duration;
import java.time.LocalDate;
import java.time.LocalTime;
import java.time.Period;
import java.time.temporal.ChronoUnit;

class prac{
    public static void main (String[] args) {
    	LocalDate date1 = LocalDate.of(2014, 1, 1);
    	LocalDate date2 = LocalDate.of(2015, 12, 31);
    	
    	Period pe = Period.between(date1, date2);
    	
    	System.out.println(date1);  // 2014-01-01
    	System.out.println(date2);  // 2015-12-31
    	System.out.println(pe);   // P1Y11M30D
    	
    	System.out.println(pe.get(ChronoUnit.YEARS));  // 1
    	System.out.println(pe.get(ChronoUnit.MONTHS));  // 11
    	System.out.println(pe.get(ChronoUnit.DAYS));  // 30
    	
    	LocalTime time1 = LocalTime.of(0, 0, 0);
    	LocalTime time2 = LocalTime.of(12, 34, 56);
    	
    	Duration du = Duration.between(time1, time2);
    	
    	System.out.println(time1);  // 00:00
    	System.out.println(time2);  // 12:34:56
    	System.out.println(du);  // PT12H34M56S
    	
    	LocalTime tmpTime = LocalTime.of(0, 0).plusSeconds(du.getSeconds());
    	
    	System.out.println(tmpTime.getHour());  // 12
    	System.out.println(tmpTime.getMinute());  // 34
    	System.out.println(tmpTime.getSecond());  // 56
    	System.out.println(tmpTime.getNano());  // 0
    	
    	 
    }
}

 

 

 

 

 

◎ 파싱과 포맷

• 형식화(formatting)와 관련된 클래스들은 java.time.format 패키지에 있음. 그 중 DateTimeFormatter 클래스가 핵심
• java.time.format 패키지 없이 LocalTime, LocalDate, LocalDateTime 클래스의 format() 메서드로도 파싱 가능
• 파싱(parsing) = 문자열 → 날짜와 시간을 생성
  • 문자열을 날짜 또는 시간으로 변환하려면 static 메서드인 parse() 메서드를 사용할 것
  • 날짜와 시간을 표현하는데 사용되는 클래스들은 거의 다 parse() 메서드를 가지고 있음 
  • DateTimeFormatter 클래스의 ofPattern()메서드를 통해서도 파싱 가능
• 포맷팅(Formatting) = 날짜와 시간 → 문자열로 변환 

 

예제

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

class prac{
    public static void main (String[] args) {
    	LocalDate date = LocalDate.of(2016, 1, 2);
    	String str1 = DateTimeFormatter.ISO_LOCAL_DATE.format(date);
    	
    	String str2 = date.format(DateTimeFormatter.ISO_LOCAL_DATE);
    	
    	System.out.println(str1);  // 2016-01-02
    	System.out.println(str2);  // 2016-01-02
    }
}

 

 

 

◎ DateTimeFormatter 클래스

• 날짜, 시간의 데이터를 지정된 형식에 맞춰 문자열로 반환 
• format() 메소드를 통해 날짜와 시간을 형식화
• import java.time.format.DateTimeFormatter; 쓸 것

 

 

 

■ DateTimeFormatter 클래스 상수

• 반환타입 전부 DateTimeFormatter 

 

 

 

■ DateTimeFormatter 클래스 메서드

제어자 반환타입	메서드	설명
String	format(TemporalAccessor temporal)	형식에 맞는 데이터를 문자열로 반환
static DateTimeFormatter	ofLocalizedDate(FormatStyle dateStyle)	로케일(locale)에 종석적이 포맷터 생성
static DateTimeFormatter	ofLocalizedTime(FormatStyle timeStyle)	로케일(locale)에 종석적이 포맷터 생성
static DateTimeFormatter	ofLocalizedDateTime(FormatStyle dateTimeStyle) ofLocalizedDateTime(FormatStyle dateStyle, FormatStyle timeStyle)	로케일(locale)에 종석적이 포맷터 생성
static DateTimeFormatter	ofPattern(String pattern)	pattern을 지정하여 원하는 출력형식을 직접 작성

 

 

■ FormatStyle 클래스 상수

• import java.time.format.FormatStyle; 쓸 것

 

 

예제1

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

class prac{
    public static void main (String[] args) {
    	DateTimeFormatter formatter = DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT);
    	String shortFormat = formatter.format(LocalDate.of(2021, 10, 5));
    	System.out.println(shortFormat);  // 21. 10. 5
    }
}

 

 

 

■ 출력형식 직접 정의

• DateTimeFormatter 클래스의 ofPattern() 메서드를 통해 출력형식 직접 정의 가능

 

DateTimeFormatter의 패턴에 사용되는 기호

기호	의미	보기
G	연대(BC, AD)	서기 또는 AD
y u	년도	2015
M L	월(1~12 또는 1월~12월)	11 또는 11월
Q q	분기(quarter)	4
w	년의 몇 번째 주 (1~53)	48
W	월의 몇 번째 주 (1~5)	4
D	년의 몇 번째 일 (1~366)	332
d	월의 몇 번째 일 (1~31)	28
F	월의 몇 번째 요일 (1~5)	4
E e	요일	토 7
a	오전/오후 (AM/PM)	오후
H	시간 (0~23)	22
h	시간 (1~12)	10
K	시간 (0~11)	10
k	시간 (1~24)	22
m	분 (0~59)	12
s	초 (0~59)	35
S	천분의 일초 (0~999)	7
A	천분의 일초 (그 날의 0시 0분 0초 부터의 시간)	80263808
n	나노초 (0~999999999)	475000000
N	나노초 (그 날의 0시 0분 0초 부터의 시간)	81069992000000
V	시간대 ID (VV)	Asia/Seoul
z	시간대 (time-zone) 이름	KST
O	지역화된 zone-offset	GMT+9
Z	zone-offset	+0900
X x	zone-offset (Z는 +00:00 의미)	+09
'	escape문자 (특수문자를 표현하는데 사용)	없음

 

 

예제1

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

class prac{
    public static void main (String[] args) {
    	LocalDateTime now = LocalDateTime.now();
    	DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy년 MMM d일 a h시 m분");
    	
    	String nowString = now.format(formatter);
    	System.out.println(nowString);  //2021년 11월 14일 오후 1시 41분
    	
    }
}

ofPattern() 메서드를 이용하여 원하는 출력방식을 포맷팅하여 문자열로 출력

 

 

예제2

import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;

class prac{
    public static void main (String[] args) {
    	ZonedDateTime zdateTime = ZonedDateTime.now();
    	
    	String[] patternArr = {
    			"yyyy-MM-dd HH:MM:ss",
    			"''yy년 MMM dd일 E요일",
    			"yyyy년 MMM dd일 HH:mm:ss.SSS z VV",
    			"yyyy-MM-dd hh:mm:ss a",
    			"오늘은 올 해의 D번째 날",
    			"오늘은 이 달의 d번째 날",
    			"오늘은 올 해의 w번째 주",
    			"오늘은 이 달의 W번째 주 ",
    			"오늘은 이 달의 w번째 E요일"
    	};
    	
    	for(String p : patternArr) {
    		DateTimeFormatter formatter = DateTimeFormatter.ofPattern(p);  // 원하는 출력 형식 설정
    		System.out.println(zdateTime.format(formatter));
    	}
    	
    }
}
/* 출력값
2021-11-14 14:11:35
'21년 11월 14일 일요일
2021년 11월 14일 14:02:35.651 KST Asia/Seoul
2021-11-14 02:02:35 오후
오늘은 올 해의 318번째 날
오늘은 이 달의 14번째 날
오늘은 올 해의 47번째 주
오늘은 이 달의 3번째 주 
오늘은 이 달의 47번째 일요일
*/

ofPattern() 메서드를 이용하여 원하는 출력방식을 포맷팅하여 문자열로 출력

 

 

예제3

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

class prac{
    public static void main (String[] args) {
    	LocalDate newYear = LocalDate.parse("2016-01-01", DateTimeFormatter.ISO_LOCAL_DATE);  // 날짜 객체 생성
    	
    	LocalDate date = LocalDate.parse("2001-01-01");  // 날짜 객체 생성
    	LocalTime time = LocalTime.parse("23:59:59"); // 시간 객체 생성
    	LocalDateTime dateTime = LocalDateTime.parse("2005-05-05T23:59:59");
    	
    	
    	DateTimeFormatter pattern = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");  // 패턴 생성
    	
    	LocalDateTime endOfYear = LocalDateTime.parse("2015-12-31 23:59:59", pattern);  // 패턴에 맞는 날짜,시간 객체 생성
    	
    	
    	System.out.println(newYear);   // 2016-01-01
    	System.out.println(date);  // 2001-01-01
    	System.out.println(time);  // 23:59:59
    	System.out.println(dateTime);  // 2005-05-05T23:59:59
    	System.out.println(endOfYear);  // 2015-12-31T23:59:59
    }
}

파싱하기