자바의 정석 10장 : 날짜와 시간 & 형식화

Back-End/Java

자바의 정석 10장 : 날짜와 시간 & 형식화

챔🐻 2024. 1. 23. 18:38

[ 출처 ]
자바의 정석:
https://product.kyobobook.co.kr/detail/S000001550352
자바의 정석 유튜브:
https://www.youtube.com/playlist?list=PLW2UjW795-f6xWA2_MUhEVgPauhGl3xIp

10-1 날짜와 시간

`java.util.Date`

날짜와 시간을 다룰 목적으로 만들어진 클래스(JDK1.0). - 1995년말

Date의 메서드는 거의 deprecated되었지만, 여전히 쓰이고 있다.

`java.util.Calendar`

Date 클래스를 개선한 새로운 클래스(JDK1.1). 여전히 단점이 존재 - 1997년

`java.time` 패키지

Date와 Calendar의 단점을 개선한 새로운 클래스들을 제공(JDK1.8) - 2017년

Date와 Calendar의 단점은 날짜와 시간을 같이 다룬다는 것이다.

time패키지에서는 날짜와 시간을 따로 다룰 수 있게 LocalDate와 LocalTime, 합쳐서 다룰 때는 LocalDateTime으로 클래스를 나눠두었다.

프로그래밍에서 날짜와 시간을 다루는 것은 매우 중요하다.

10-2 Calendar 클래스

추상 클래스이므로 getInstance()를 통해 구현된 객체를 얻어야 한다.

Calendar cal = new Calendar(); // 에러!!! 추상클래스는 인스턴스를 생성할 수 없다.

// OK, getInstance() 메서드는 Calendar 클래스를 구현한 클래스의 인스턴스를 반환한다.
Calendar cal = Calendar.getInstance();

class MyApplication {
	public static void main(String args[]) {
		// 달력의 종류는 서양력, 불교력, 일본력 등 많은 역법이 있기 때문에 인스턴스를 직접생성해 얻으면
		Calendar cal = new GregorianCalendar(); // 경우에 따라 이 부분을 변경해야한다
	}
}

10-3 Calendar 클래스 - 예제1

Calendar cal = Calendar.getInstance(); // 현재 날짜와 시간으로 셋팅됨
int thisYear = cal.get(Calendar.YEAR); // 올해가 몇년인지 알아낸다.
int lastDayOfMonth = cal.getActualMaximum(Calendar.DATE); // 이 달의 마지막날

`get()` : 날짜와 시간 필드 가져오기 - int get(int field)

Calendard에 정의된 필드

필드명	설명
YEAR	년
MONTH	월(0부터 시작)
WEEK_OF_YEAR	그 해의 몇 번째 주
WEEK_OF_MONTH	그 달의 몇 번째 주(일~토)
DATE	일
DAY_OF_MONTH	그 달의 몇번째 일
DAY_OF_YEAR	그 해의 몇 번째일
DAY_OF_WEEK	요일(1~7) 1: 일요일
DAY_OF_WEEK_IN_MONTH	그 달의 몇 번째 요일
HOUR	시간(0~11)
HOUR_OF_DAY	시간(0~23)
MINUTE	분
SECOND	초
MILLISECOND	천분의 일초
ZONE_OFFSET	GMT 기준 시차(천분의 일초 단위)
AM_PM	오전/오후

10-4,5 Calendar 클래스 - 예제2, 3

`set()` : 날짜와 시간 지정하기

void set(int field, int value)
void set(int field, 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)

날짜 지정하는 방법. 월(MONTH)이 0부터 시작한다는 점에 주의

Calendar date1 = Calendar.getInstance();
date1.set(2022, 6, 31); // 2022년 7월 31일(6월 아님)
// date1.set(Calendar.YEAR, 2002);
// date1.set(Calendar.MONTH, 0); 
// date1.set(Calendar.DATE, 15);

+) 배열을 이용하기 때문에 0부터 시작한다. {”JAN”, “FEB”,…}

시간 지정하는 방법

Calendar time1 = Calendar.getInstance();
time1.set(Calendar.HOUR_OF_DAY, 10); // time1을 10시 20분 30초로 설정
time1.set(Calendar.MINUTE, 20);
time1.set(Calendar.SECOND, 30);

예제 10-2

// 예제 10-2
import java.util.Calendar;

public class Main {
	public static void main(String[] args) {
        // 요일은 1부터 시작하기 때문에, DAY_OF_WEEK[0]은 비워두었다.
        final String[] DAY_OF_WEEK = {"", "일", "월", "화", "수", "목", "금", "토", "일"};

        Calendar date1 = Calendar.getInstance();
        Calendar date2 = Calendar.getInstance();

        // month에 경우 0부터 시작하기 때문에 4월인 경우, 3으로 지정해야한다.
        // date1.set(2022, Calendar.JANUARY, 15); 와 같이 할 수도 있다.
        date1.set(2002, 0, 15); // 2022년 1월 15일로 날짜를 설정한다.
        System.out.println("date1은" + toString(date1)
                    + DAY_OF_WEEK[date1.get(Calendar.DAY_OF_WEEK)] + "요일이고,");
        System.out.println("오늘(date2)은" + toString(date2)
                    + DAY_OF_WEEK[date2.get(Calendar.DAY_OF_WEEK)]);
			
				// 두 날짜간의 차이를 얻으려면, getTimeInMillis() 천분의 일초 단위로 변환해야한다.
        long difference = (date2.getTimeInMillis() - date1.getTimeInMillis()) / 1000;

        System.out.println("그 날(date1)부터 지금(date2)까지 "
                    + difference + "초가 지났습니다.");

        System.out.println("일(day)로 계산하면 " + difference/(24 * 60 * 60) + "일입니다.");
        System.out.println((difference/(24 * 60 * 60))/365.0);
	}

    public static String toString(Calendar date) {
		return date.get(Calendar.YEAR)+"년 "+ (date.get(Calendar.MONTH)+1) 
                            +"월 " + date.get(Calendar.DATE) + "일 ";
	}

}

예제 10-3

import java.util.Calendar;
import java.util.concurrent.TimeUnit;

public class Main {
	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.set(Calendar.HOUR_OF_DAY, 10); // time1을 10시 20분 30초로 설정
        time1.set(Calendar.MINUTE, 20);
        time1.set(Calendar.SECOND, 30);

        time2.set(Calendar.HOUR_OF_DAY, 20); //time2를 20시 30분 10초로 설정
        time2.set(Calendar.MINUTE, 30);
        time2.set(Calendar.SECOND, 10);

        System.out.println("time1 : " + time1.get(Calendar.HOUR_OF_DAY) + "시 "
                                      + time1.get(Calendar.MINUTE) + "분 "
                                      + time1.get(Calendar.DATE) + "초");

        System.out.println("time2 : " + time2.get(Calendar.HOUR_OF_DAY) + "시 "
                                      + time2.get(Calendar.MINUTE) + "분 "
                                      + time2.get(Calendar.DATE) + "초");

        long difference = Math.abs(time2.getTimeInMillis() - time1.getTimeInMillis())/1000;
        System.out.println("time1과 time2의 차이는 " + difference + "초 입니다.");

        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 + "입니다.");

        // System.out.println("시분초로 변환하면 " + (difference / 3600) + "시간 "
        //                                           + (difference % 3600 / 60) + "분 "
        //                                           + (difference % 3600 % 60) + "초 ");
	}

    public static String toString(Calendar date) {
		return date.get(Calendar.YEAR)+"년 "+ (date.get(Calendar.MONTH)+1) 
                            +"월 " + date.get(Calendar.DATE) + "일 ";
	}

}

`clear()` : Calendar 객체의 모든 필드 초기화

Calendar dt = Calendar.getInstance();
// Sun Jul 31 11:40:01 KST 2022
System.out.println(new Date(dt.getTimeInMillis())); 

dt.clear();
// Thu Jan 01 00:00:00 KST 1970 : 컴퓨터가 나온 시점쯤을 기준으로 삼음(EPHCH TIME)
System.out.println(new Date(dt.getTimeInMillis()));

`clear(int filed)` : Calendar 객체의 특정 필드 초기화

Calendar dt = Calendar.getInstance();

// Sun Jul 31 11:46:41 KST 2022
System.out.println(new Date(dt.getTimeInMillis()));

dt.clear(Calendar.SECOND);      // 초를 초기화
dt.clear(Calendar.MINUTE);      // 분을 초기화
dt.clear(Calendar.HOUR_OF_DAY); // 시간을 초기화
dt.clear(Calendar.HOUR);        // 시간을 초기화
// Sun Jul 31 00:00:00 KST 2022
System.out.println(new Date(dt.getTimeInMillis()));

+) Calendar 객체를 생성한 후에는 꼭 clear()를 해줘야한다.

import java.util.Calendar;

public class Main {
    static int getDayDiff(String yyyymmdd1, String yyyymmdd2) {
        int diff = 0;
        
        int year1 = Integer.parseInt(yyyymmdd1.substring(0, 4));
        int month1 = Integer.parseInt(yyyymmdd1.substring(4, 6)) - 1;
        int day1 = Integer.parseInt(yyyymmdd1.substring(6, 8));
        
        int year2 = Integer.parseInt(yyyymmdd2.substring(0, 4));
        int month2 = Integer.parseInt(yyyymmdd2.substring(4, 6)) - 1;
        int day2 = Integer.parseInt(yyyymmdd2.substring(6, 8));

        Calendar date1 = Calendar.getInstance();
        Calendar date2 = Calendar.getInstance();
        
        System.out.println("date1 = " + date1);
        System.out.println();
        System.out.println("date2 = " + date2);
        System.out.println();

        date1.clear();
        date2.clear();

        System.out.println("date1 = " + date1);
        System.out.println();
        System.out.println("date2 = " + date2);

        date1.set(year1, month1, day1);
        date2.set(year2, month2, day2);

        System.out.println((date1.getTimeInMillis() - date2.getTimeInMillis()) / (24f * 60f * 60f * 1000f));
        diff = (int) ((date1.getTimeInMillis() - date2.getTimeInMillis()) / (24 * 60 * 60 * 1000));

        return diff;
    }

	public static void main(String[] args) {
        System.out.println(getDayDiff("20010103", "20010101")); // 2
	}
}

clear()를 해주지 않을 경우 date1과 date2의 ms차이가 발생하기 때문에 2나 나오지 않고 1이 나오게됨

clear()를 해주면 ms차이가 똑같아지기 때문

10-6,7 Calendar 클래스 - 예제4, 5

`add()` : 특정 필드의 값을 증가 또는 감소(다른 필드에 영향O)

Calendar date = Calendar.getInstance();
date.clear();          // 모든 필드를 초기화
date.set(2020, 7, 31); // 2020년 8월 31일로 설정

date.add(Calendar.DATE, 1);   // 날짜(DATE)에 1을 더한다.
date.add(Calendar.MONTH, -8); // 월(MONTH)에서 8을 뺀다.

`roll()` : 특정 필드의 값을 증가 또는 감소(다른 필드에 영향X)

date.set(2020, 7, 31); // 2020년 8월 31일로 설정

date.add(Calendar.DATE, 1);   // -> 2020년 9월 1일 / 날짜(DATE)에 1을 더한다.
date.add(Calendar.MONTH, -8); // -> 2020년 12월 31일 / 월(MONTH)에서 8을 뺀다.

+) 일 필드가 말일일 때 roll 메서드로 월 필드를 변경하면 일 필드에 영향을 미친다.

ex) 2023년 1월 31일 roll()을 호출해서 월 필드를 1증가시켰을 때 2023년 2월 28일이된다.

예제 10-4

// 예제 10-4
import java.util.Calendar;

public class Main {
    public static void main(String[] args) {
        Calendar date = Calendar.getInstance();
        date.set(2019, 7, 31); // 2019 8 31

        System.out.println("== 1일 후 ==");
        date.add(Calendar.DATE, 1); // 2019 9 1
        System.out.println(toString(date));

        System.out.println("== 6달 전 ==");
        date.add(Calendar.MONTH, -6); // 2019 3 1
        System.out.println(toString(date));

        System.out.println("== 31일 후(roll) ==");
        date.roll(Calendar.DATE, 31); // 2019 3 1
        System.out.println(toString(date));

        System.out.println("== 31일 후(add) ==");
        date.add(Calendar.DATE, 31); // 2019 4 1
        System.out.println(toString(date));
    }

    public static String toString(Calendar date) {
        return date.get(Calendar.YEAR) + "년" 
        + (date.get(Calendar.MONTH) + 1) + "월"
        + (date.get(Calendar.DATE)) + "일";
    }
}

✅ Check Point

월의 마지막 날을 알고 싶다면 다음 달에서 하루를 빼면된다.

ex) day.add(Calendar.DATE, -1)

예제 10-6 : 년과 월 입력 시 달력을 출력하는 예제

// 예제 10-5
import java.util.Calendar;

public class Main {
    public static void main(String[] args) {
        int year = 2022;
        int month = 7;
        int START_DAY_OF_WEEK = 0; // 1일의 요일
        int END_DAY = 0; // 마지막 날

        Calendar sDay = Calendar.getInstance(); // 시작일
        Calendar eDay = Calendar.getInstance(); // 끝일

        // 월의 경우 0부터 11까지의 값을 가지므로 1을 빼주어야 한다.
        // 예를 들어, 2022 6월 1일은 sDay.set(2022, 5, 1);과 같이 해줘야 한다.
        sDay.set(year, month-1, 1); // 2022.07.01
        eDay.set(year, month, 1); // 2022.08.01

        // 다음 달의 첫날(8월 1일)에서 하루를 빼면 현재달의 마지막 날(7월 31일)이 된다.
        eDay.add(Calendar.DATE, -1); // 2022.07.31.

        // 첫 번째 요일이 무슨 요일인지 알아낸다.
        START_DAY_OF_WEEK = sDay.get(Calendar.DAY_OF_WEEK);

        // eDay에 지정된 날짜를 얻어온다.
        END_DAY = eDay.get(Calendar.DATE);

        System.out.println("      " + year + "년" + month + "월");
        System.out.println(" SU MO TH WE TH FR SA");

        // START_DAY_OF_WEEK = 6(금요일)
        // 해당 월의 1일이 어느 요일인지에 따라 서 공백을 출력한다.
        // 만일 1일이 수요일이라면 공백을 세 번 찍는다. (일요일부터 시작)
        for(int i = 1; i < START_DAY_OF_WEEK; i++) {
            System.out.print("   ");
        }

        // i는 날짜를 찍는 변수
        // n은 토요일마다 줄바꿈을 하기 위한 변수
        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();
        }
    }
}

// 1. 말일 구하기 (다음달 1일에서 -1)
// 2. 1일의 요일 구하기

예제 10-7 : 6번의 달력 예제에서 첫 주와 마지막 주가 이전 달, 이후 달과 연결되도록 변경한 것

package ch10;

import java.util.*;

class CalendarEx7 {
    public static void main(String[] args) {
//        if(args.length !=2) {
//            System.out.println("Usage : java CalendarEx7 2015 11");
//            return;
//        }

//        int year  = Integer.parseInt(args[0]);
//        int month = Integer.parseInt(args[1]);
        int year  = 2023;
        int month = 01;

        Calendar sDay = Calendar.getInstance();       // 시작일
        Calendar eDay = Calendar.getInstance();       // 끝일

        // 월의 경우 0 부터 11까지의 값을 가지므로 1을 빼줘야한다.
        // 예를 들어, 2004년 11월 1일은 sDay.set(2004, 10, 1);과 같이 해줘야 한다.
        sDay.set(year, month-1, 1);     // 입력월의 1일로 설정한다.
        // 입력월의 말일로 설정한다.
        eDay.set(year, month-1,  sDay.getActualMaximum(Calendar.DATE));
        // 1일이 속한 주의 일요일로 날짜설정.
        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");

        //시작 일부터 마지막 일까지(sDay <= eDay) 1일씩 증가시키면서 일(Calendar.DATE)을 출력
        for(int n=1; sDay.before(eDay) || sDay.equals(eDay); sDay.add(Calendar.DATE, 1)) {
            int day = sDay.get(Calendar.DATE);
            System.out.print((day < 10)? "  "+day : " "+day );

            if(n++%7==0) System.out.println();	// 7일치를 찍고 나서 줄을 바꾼다.
        }
    } // main
}

10-8 Date와 Calendar간의 변환

Date의 메서드는 대부분 deprecated 되었지만 여전히 사용
deprecated : 사용사지 않을 것을 권장

Calendar → Date

Calendar cal = Calendar.getInstance();
  ...
Date d = new Date(cal.getTimeInMillis()); // Date(long date)

Date → Calendar

Date d = new Date();
  ...
Calendar cal = Calendar.getInstance();
cal.setTime(d);

10-9 형식화 클래스

java.text 패키지의 DecimalFormat(숫자), SimpleDateFormat(날짜)

숫자와 날짜를 원하는 형식으로 쉽게 출력 가능(숫자, 날짜 → 형식 문자열)

double number = 1234567.89;
DecimalFormat df = new DecimalFormat("#.#E0");
String result = df.format(number); // result = "1.2E6" (지수표현)

형식 문자열에서 숫자와 날짜를 뽑아내는 기능(형식 문자열 → 숫자, 날짜)

DecimalFormat df2 = new DecimalFormat("#,###.##");
Number num = df2.parse("1,234,567.89");
double d = num.doubleValue();

10-10 DecimalFormat

`format()` : 숫자를 형식화할 때 사용(숫자 → 형식 문자열)

double number = 1234567.89;
DecimalFormat df = new DecimalFormat("#.#E0"); // 지수형식
String result = df.format(number); // result = "1.2E6"

`parse()` : 특정 형식의 문자열을 숫자로 변환할 때도 사용(형식 문자열 → 숫자)

DecimalFormat df = new DecimalFormat("#,###.##");
Number num = df.parse("1,234,567.89");
double d = num.doubleValue(); // 1234567.89

[참고] Integer.parseInt()는 콤마(,)가 포함된 문자열을 숫자로 변환 못함

기호	의미	패턴	결과(1234567.89)
0	10진수(값이 없을 때는 0)	0 0.0 0000000000.0000	1234568 1234567.9 0001234567.8900
#	10진수	# #.# ##########.####	1234568 1234567.9 1234567.89
E	지수기호	#.#E0 0.0E0 0.000000000E0 00.00000000E0 #.########E0 ##.#######E0	1.2E6 1.2E6 1.234567890E6 12.34567890E5 1.23456789E6 1.23456789E6

예제 10-10

package ch10;

import java.text.*;

class DecimalFormatEx1 {
    public static void main(String[] args) throws Exception {
        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));
        }
    } // main
}

10-13~16 SimpleDateFormat

`format()` : 날짜와 시간을 다양한 형식으로 출력

Date today = new Date();
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");

// 오늘 날짜를 yyyy-MM-dd 형태로 변환하여 반환한다.
String result = df.format(today);

날짜와 관련된 기호들

기호	의미	보기
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	요일	월

`parse()` : 특정 형식으로 되어있는 문자열에서 날짜와 시간을 뽑아낼 수 있다.

DateFormat df = new SimpleDateFormat("yyyy년 MM월 dd일");
DateFormat df2 = new SimpleDateFormat("yyyy/MM/dd");

Date d = df.parse("2015년 11월 23일"); // 문자열을 Date로 변환
String result = df2.format(d);

예제 10-8

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

class Ex10_8 {
	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:mm:ss.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));	// format(Date d)
		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));
	}
}

예제 10-9

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

public class Main {
	public static void main(String[] args) throws ParseException {
        DateFormat df = new SimpleDateFormat("yyyy년 MM월 dd일");
        DateFormat df2 = new SimpleDateFormat("yyyy/MM/dd");

        Date d = df.parse("2019년 12월 23일");
        System.out.println(df2.format(d));
	}
}

시간과 관련된 기호들

기호	의미	보기
a	오전/오후(AM, PM)	PM
H	시간(0~23)	20
k	시간(1~24)	13
K	시간(0~11)	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 문자(특수문자를 표현하는데 사용)	없음

예제 10-10

화면으로부터 날짜를 입력받아 계산결과를 출력하는 예제이다. while과 try-catch문을 이용해서 사용자가 올바른 형식으로 날짜를 입력할 때까지 반복해서 입력받도록 한다.

지정된 패턴으로 입력되지 않은 경우, parse 메서드를 호출하는 부분에서 예외(ParseException)가 발생하기 때문에 while문을 벗어나지 못한다.

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		String pattern = "yyyy/MM/dd";
		DateFormat df = new SimpleDateFormat(pattern);

		Date inDate = null;

		System.out.println("날짜를 " + pattern
										+ "의 형태로 입력해주세요. (입력 예 : 2019/12/31)");

		while(s.hasNext()) {
			try {
				inDate = df.parse(s.nextLine());
				break;
			} catch (Exception e) {
				System.out.println("날짜를 " + pattern
									+ "의 형태로 다시 입력해주세요.(입력예 : 2022/08/07)");
			}
		} // while

		Calendar cal = Calendar.getInstance();
		cal.setTime(inDate); // Date -> Calendar 변환

		Calendar today = Calendar.getInstance();
		long day = (cal.getTimeInMillis() - today.getTimeInMillis()) / (1000 * 60 * 60);

		System.out.println("입력하신 날짜는 현재와 " + day + "시간 차이가 있습니다.");
		
	}	
}

2.3 ChoiceFormat

특정 범위에 속하는 값을 문자열로 반환해준다.

double[] limits = {60, 70, 80, 90};     // 낮은 값부터 큰 값의 순서로 적어야한다.
String[] grades = {"D", "C", "B", "A"}; // limits, grades간의 순서와 개수를 맞추어야 한다.

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]));
}

limits : 범위의 경계값 저장

grades : 범위에 포함된 값을 치환할 문자열

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

예제에서는 4개의 경계값에 의해 ‘60~69’, ‘70~79’, ‘80~89’, ‘90~’의 범위가 정의되었다.

배열 대신 패턴을 사용해서 간결하게 처리할 수 있다.

String pattern = "60#D|70#C|80<B|90#A";
int[] scores = { 91, 90, 80, 88, 70, 52, 60};
ChoiceFormat form = new ChoiceFormat(pattern);

패턴 구분자 : ‘#’와 ‘<’ ‘limit#value’의 형태로 사용한다.

‘#’는 경계값에 범위를 포함시키지만, ‘<’는 포함시키지 않는다.

예제 10-17

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]));
}

2.4 MessageForamt

데이터를 정해진 양식에 맞게 출력할 수 있도록 도와준다.
```
String msg = "Name : {0} \nTel : {1} \nAge : {2} \nBirthday : {3}";
Object[] arguments = {"이자바", "02-123-1234", "27", "07-09"};
String result = MessageFormat.format(msg, arguments);
```
‘{숫자}’로 표시된 부분이 데이터가 출력될 자리이다. 순차적일 필요는 없고 여러 번 반복해서 사용할 수 있다.

예제 10-19 - DB에 저장하기 위한 Insert문

String tableName = "CUST_INFO";
String msg = "INSERT INTO "+ tableName +" 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);
}

parse()로 데이터 뽑아내기

아래 예제 활용해 어려운 작업을 쉽게 처리할 수 있으니 잘 기억해두었다가 요긴하게 쓸 것!

String[] data = {
        "INSERT INTO CUST_INFO VALUES ('이자바','02-123-1234',27,'07-09');",
        "INSERT INTO CUST_INFO VALUES ('김프로','032-333-1234',33,'10-07');"
};

String pattern = "INSERT INTO CUST_INFO VALUES ({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();
}

예제 10-21 - DB INSERT DATE 생성

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

class MessageFormatEx4 {
	public static void main(String[] args) throws Exception {
		String tableName = "CUST_INFO";
		String fileName  = "data4.txt";
		String msg = "INSERT INTO "+ tableName + " VALUES ({0},{1},{2},{3});";
		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);
			System.out.println(MessageFormat.format(msg, objs));
		}

        s.close();	// 작업이 끝났으니 Scanner에서 사용한 파일을 닫아 준다.
	} // main
}

10챕터 연습문제

🏅10챕터 연습문제 (1)

Uploaded by N2T