Bibliothek

※ 사용자로부터 연, 월을 입력받아 달력을 그려주는(출력하는) 프로그램을 구현한다.
 단, 만년달력이 아니라 Calendar 클래스를 활용하여 작성할 수 있도록 한다.
 (API Document 적극 참조~!!!)

 실행 예)
 연도 입력 : 0
 연도 입력 : 2020
 월   입력 : -2
 월   입력 : 16
 월   입력 : 8

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Calendar;

public class Test148
{
	public static void main(String[] args) throws IOException
	{
		//BufferedReader 클래스 기반 인스턴스 생성
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		// Calendar 클래스 기반 인스턴스 생성
		Calendar cal = Calendar.getInstance();

		// 주요 변수 선언
		int y,m;		//-- 년, 월
		int w;			//-- 요일
		int i;			//-- 루프, 변수

		do
		{
			System.out.print("연도 입력 : ");
			y = Integer.parseInt(br.readLine());
		}
		while (y<1);

		do
		{
			System.out.print("월    입력 : ");
			m = Integer.parseInt(br.readLine());
		}
		while (m < 1 || m > 12);
		
		// 사용자로부터 입력받은 연(y), 월(m)을 이용하여
		// 달력 객체의 날짜 세팅
		cal.set(y,m-1,1);
		//-- 월 구성 시 입력값(m)을 그대로 사용하는 것이 아니라
		//   입력값에서 1을 뺀 값으로 월을 설정해야 한다.
		
		// 세팅된 달력 객체로부터 요일 가져오기
        w = cal.get(Calendar.DAY_OF_WEEK);

		// 테스트(확인)
		//System.out.println(w);
		//--==>> 연도 입력 : 2020
		//       월   입력 : 8
		//        7 → 2020년 8월 기준 → 토요일 → 2020년 8월 1일 → 토요일
		
		// Calendar 클래스의 『getActualMaximum()』 메소드 check~!!!
		// 테스트(확인)
		System.out.println(cal.getActualMaximum(Calendar.DATE));
		//--==>> 31


		// 결과 출력 → 달력 그리기
		System.out.println();
		System.out.println("\t[ " + y + "년 " + m + "월 ]\n");
		System.out.println("  일  월  화  수  목  금  토");
		System.out.println("============================");

		// 공백 발생
		for (i = 1; i < w; i++)
		{
			System.out.print("    ");
		}

		// 테스트(확인)
		//System.out.printf("%4d",1);

		// Calendar 클래스의 『getActualMaximum()』 메소드 활용
		for (i=1; i <= cal.getActualMaximum(Calendar.DATE); i++)
		{
			System.out.printf("%4d",i);
			w++;		//-- 반복문을 수행하며 날짜가 증가할 때 마다
						//   요일도 함께 증가해 나갈 수 있도록 처리

			if (w%7==1) //-- 증가한 요일이 일요일이 될 때 마다... 개행 후 출력
				System.out.println();		//-- 개행
		}
		if(w%7!=1)
			System.out.println();			//-- 개행

		System.out.println("=============================");

	}
}

실행 결과

// 실행 결과
/*
연도 입력 : 2020
월    입력 : 2
29

        [ 2020년 2월 ]

  일  월  화  수  목  금  토
============================
                           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
=============================
계속하려면 아무 키나 누르십시오 . . .
*/

java.util.Calendar 클래스

java.util.Calendar 클래스는 날짜와 시간을 객체 모델링화 한 클래스로 연, 월, 일, 요일, 시, 분, 초 까지의 시간 및 날짜와 관련된 정보를 제공한다. 그리고, Calendar 클래스는 추상 클래스이므로 직접 객체를 생성할 수 없으며 실제적인 메소드 구현은 Calendar 클래스의 서브 클래스인  GregorianCalendar 클래스에 정의되어 있다.

시스템으로부터 현재 시스템 시간 정보를 얻어올 때 getInstance() 라는 정적(static) 메소드를 이용하여 객체를 생성할 수 있다. 생성된 Calendar 클래스 객체는 시스템의 현재 날짜와 시간 정보를 가지며, 이 객체가 생성되면 갖고 있는 시간 정보들은 get() 메소드를 이용하여 쉽게 가져올(사용할)수 있다.

getInstance() 메소드는 내부적으로 GregorianCalendar 객체를 생성하여 돌려주기 때문에 GregorianCalendar 객체를 직접 생성하여 시간 정보를 구할 수도 있다.

※ Calendar 클래스는 추상 클래스이기 때문에 객체를 생성할 수 없다.
   (추상 클래스 : 미완성된 클래스)

   Calendar cal = new Calendar();
   → 이와 같은 구문을 통해 인스턴스 생성이 불가.

○ Calendar 클래스 객체(인스턴스)를 생성할 수 있는 방법

   1. Calendar cal = Calendar.getInstance();

   2. Calendar cal = new GregorianCalendar();

   3. GregorianCalendar cal = new GregorianCalendar();

   (※ GregorianCalendar : Calendar 클래스의 하위 클래스)

import java.util.Calendar;
import java.util.GregorianCalendar;

public class Test147
{
	public static void main(String[] args)
	{
		// Calendar 클래스 기반 인스턴스 생성
		//Calendar rightNow = new Calendar();	// 인스턴스 생성 불가
		Calendar rightNow = Calendar.getInstance();
		
		// 생성된 달력(Calendar) 인스턴스를 통해
		// 날짜 관련 정보를 얻어낼 수 있는 메소드 → 『get()』
		int y = rightNow.get(Calendar.YEAR);
		System.out.println(y);
		//--==>> 2020

		int m = rightNow.get(Calendar.MONTH)+1;		//-- check~!!!
													//   가져올 때는 『+1』
													//	 설정할 때는 『-1』
	
		System.out.println(m);
		//--==>> 8 

		int d = rightNow.get(Calendar.DATE);
		System.out.println(d);
		//--==>> 27

		int w = rightNow.get(Calendar.DAY_OF_WEEK);
		System.out.println(w);

		
		/*
		// 테스트(확인)
		System.out.println(Calendar.SUNDAY);	//--==>>  1 → 일요일
		System.out.println(Calendar.MONDAY);	//--==>>  2 → 월요일
		System.out.println(Calendar.TUESDAY);	//--==>>  3 → 화요일
		System.out.println(Calendar.WEDNESDAY);	//--==>>  4 → 수요일
		System.out.println(Calendar.THURSDAY);	//--==>>  5 → 목요일
		System.out.println(Calendar.FRIDAY);	//--==>>  6 → 금요일
		System.out.println(Calendar.SATURDAY);	//--==>>  7 → 토요일
		*/

		System.out.println(y + "-" + m + "-" + d + " " + w);
		//--==>> 2020-8-27 5

		String week = "";
		switch (w)
		{
			//case 1: week = "일요일"; break
			case Calendar.SUNDAY: week = "일요일"; break;

			//case 2: week = "월요일"; break
			case Calendar.MONDAY: week = "월요일"; break;
		
			//case 3: week = "화요일"; break
			case Calendar.TUESDAY: week = "화요일"; break;

			//case 4: week = "수요일"; break
			case Calendar.WEDNESDAY: week = "수요일"; break;

			//case 5: week = "목요일"; break
			case Calendar.THURSDAY: week = "목요일"; break;

			//case 6: week = "금요일"; break
			case Calendar.FRIDAY: week = "금요일"; break;

			//case 7: week = "토요일"; break
			case Calendar.SATURDAY: week = "토요일"; break;
		}

		System.out.println(y + "-" + m + "-" + d + " " + week);
		//--==>> 2020-8-27 목요일
		
		///////////////////////////////////////////////////////////////////////////

		//Calendar 클래스 인스턴스 생성
		Calendar rightNow2 = new GregorianCalendar();

		String[] week2 = {"일요일","월요일","화요일","수요일","목요일","금요일","토요일"};

		
		// 달력의 날짜 세팅 → 『set()』 메소드 활용
		rightNow2.set(2020,9,20); // 10월      -- check~!!!

		System.out.println(rightNow2.get(Calendar.DAY_OF_WEEK));
		//--==>> 3  → 화요일
		//-- 2020년 10월 20일은 화요일~!!!

		System.out.println(week2[rightNow2.get(Calendar.DAY_OF_WEEK)-1]);
		//--==>> 화요일


		// 달력의 날짜 세팅
		rightNow2.set(1994,5,3);	// 1994-06-03

		System.out.println(week2[rightNow2.get(Calendar.DAY_OF_WEEK)-1]);
		//--==>> 금요일

	}
}

■ 캐릭터 셋(Character Set)
   
   ○ 유니코드(unicode)
      
  국제 표준으로 제정된 2바이트계의 만국 공통의 국제 문자부호 체계(UCS: Universal Code System)를 말한다.

애플컴퓨터, IBM, 마이크로소프트 등이 컨소시엄으로 설립한 유니코드가 1990년에 첫 버전을 발표하였고, ISO/IEC JTC1에서 1995년 9월 국제표준으로 제정하였다.

  데이터의 교환을 원활하게 하기 위해 문자 1개에 부여되는 값을 16비트로 통일하였다.

코드의 1문자 당 영어는 7비트, 비영어는 8비트, 한글이나 일본어는 16비트의 값을 가지게 되는데 이들을 모두 16비트로 통일한 것이다.

   ○ UTF-8 과 UTF-16
  
  UTF-8 과 UTF-16 의 차이를 한 마디로 말하면 문자를 표현할 때의 단위가 다르다는 것이다. UTF-8 은 8비트 가변장 멀티바이트에서 문자를 표현하고 UTF-16 은 16비트 가변장 멀티바이트에서 문자를 표현한다.

  - UTF-8(8Bit UCS Transformation Format)
    

  웹에서 기본적으로 사용하는 코드 UCS-2 로 정의되는 문자 집합을 이용하여 기술된 문자열을 바이트 열로 변환하는 방식의 1개 1문자를 1~6바이트 가변장 멀티바이트로 변환한다.

      - UTF-16(16Bit UCS Transformation Format)

  자바의 기본 코드이다.
자바에서는 문자 하나를 저장하면 바이트 수는 영문자이든, 한글문자이든 2바이트를 차지하게 된다.
UCS-2로 정의되는 문자 집합을 이용하여 기술된 문자열에 UCS-4의 일부 문자를 채워넣기 위한 인코딩 방식.
UTF-8과 병용할 수 있다. UCS-2로 이용할 수 있는 문자수를 대폭 늘릴 수 있다.
   ※ 자바단에서는 UTF-16을 사용하고 웹에서는 UTF-8을 사용하기 때문에 경우에 따라 변환해야 하는 상황이 발생할 수 있다.


■ 문자 코드의 종류

   ○ KSC5601
      한글 완성형 표준(한글 2,350자 표현).
  한국공업표준 정보처리분야(C)의 5601번 표준안.

   ○ KSC5636
      영문자에 대한 표준.
  한국공업표준 정보처리분야(C)의 5636번 표쥰안.
  기존 ASCII Code 에서 역슬래스(\)를 원(￦) 표시로 대체.

   ○ EUC-KR(MS949)
      Bell-Laboratories 에서 유닉스 상에서 영문자 이외의 문자를
  지원하기 위해 제안한 확장 유니코드(Extend Unix Code) 중 한글 인코딩 방식.
  영문은 KSC5636으로 처리하고, 한글은 KSC5601로 처리.
  즉, EUC-KR(MS949) = KSC5636 + KSC5601

   ○ UTF-8
      영문과 숫자는 1바이트, 한글은 3바이트로 표현.
  (웹에서 많이 사용. UTF-8 형식으로 JSP를 작성할 때에는 파일도 UTF-8 형식으로 저장해야 한다.)

   ○ UTF-16
      자바 기본 문자 코드
  영문과 숫자는 1바이트, 한글은 2바이트로 표현

   ○ ISO-8859-1
      서유럽 언어 표기에 필요한 US-ASCII 에 없는 94개의 글자의 순차적 나열.

import java.io.UnsupportedEncodingException;

public class Test146
{
	public static void main(String[] args) //throws UnsupportedEncodingException
	{
		byte[] buf;
		String name = new String("윤홍준");

		System.out.println("디폴트 캐릭터셋 : " + System.getProperty("file.encoding"));
		//--==>> 디폴트 캐릭터셋 : MS949
		
		
		// 『String객체.getBytes()』
		//  : 디폴트 캐릭터셋으로 바이트 배열을 반환하는 메소드
		buf = name.getBytes();
		
		System.out.println("Length : " + buf.length);
		//--==>> Length : 6


		for (byte b : buf)
			System.out.println("[" + b + "]");
		System.out.println();
		//--==>> [-64]
		//		 [-79]
		//		 [-56]
		//		 [-85]
		//		 [-63]
		//		 [-40]


		try
		{
			// "utf-8"로 바이트 배열을 반환하는 메소드 호출
			buf = name.getBytes("utf-8");
			
			System.out.println("Length : " + buf.length);
			//--==>> Length : 9
			
			for (byte b : buf)
				System.out.println("[" + b + "]");
			System.out.println();
			//--==>> Length : 9
			//		 [-20]
			//		 [-100]
			//		 [-92]
			//		 [-19]
			//		 [-103]
			//		 [-115]
			//		 [-20]
			//		 [-92]
			//		 [-128]

			//new String("김승범");

			//new String(바이트배열, 인코딩방식);

			//new String(buf, "utf-8");
			
			// utf-8 형태로 저장된 바이트 배열
			// String 객체로 파라미터값 『utf-8』을 부여하여 생성
			// → utf-8 기반으로 buf 바이트 배열을 조립하여
			//    문자열 객체 생성한 후 이를 출력
			System.out.println("Value : " + new String(buf, "utf-8"));
			//--==>> Value : 윤홍준

			// utf-8 형태로 저장된 바이트 배열(→ buf)을
			// String 객체로 파라미터값 없이(→ 디폴트 캐릭터 셋)을 부여하여 생성
			System.out.println("Value2 : " + new String(buf));
			//								 ---------------
			//								 new String(buf, MS949);
			//                                               -----
			//                                               시스템이 사용중인 default character set
			

			System.out.println();
			String convert = new String(name.getBytes("euc-kr"), "utf-8");


			System.out.println("Value3 : " + convert);
			//--==>> Value3 : ????

			buf = convert.getBytes();
			System.out.println("Length : " + buf.length);
			//--==>> Length : 5

			buf = convert.getBytes("utf-8");
			System.out.println("Length : " + buf.length);
			//--==>> Length : 14

			/*
			※ check~!!!
			   
			   euc-kr을 utf-8로 변환하겠다는 의도로
			   위와 같이 코딩을 해버리면...
			   (→ 『new String(name.getBytes("euc-kr), "utf-8");』)
			   이러한 변환으로 인해 바이트 배열이 깨져서
			   euc-kr 이든... utf-8이든...
			   어떠한 바이트 배열로 읽어오든
			   깨져있는 것을 확인할 수 있다.
			
			*/
			

		}
		catch (UnsupportedEncodingException e)
		{
			System.out.println(e.toString());
		}

	}
}

○ StringTokenizer 클래스는 문자열 파싱(parsing)을 위한 정보를 제공하는 클래스로 파싱(parsing)하고자 하는 문자열을 인자로 받아 생성하는데, 여기에서 파싱(parsing)이란 하나의 문자열을 여러 문자열로 나누는 작업을 의미하게 되며, 이 때 나누는 단위가 되는 문자열을 토큰(token)이라고 한다.

StringTokenizer 클래스를 사용하기 위해서는 java.util 패키지의  StringTokenizer 를 import 해야 한다.

StringTokenizer 클래스는 호환성을 유지하는 목적으로 보관 유지되고 있으며, 문자열을 파싱(parsing)하기 위해서는
String 클래스의 split() 메소드나 java.util.regex 패키지를 사용할 것을 권장하고 있다.


○ 생성자
   - 원형
     StringTokenizer(String str)
     StringTokenizer(String str, String delim)
     StringTokenizer(String str, String delim, boolean returnDelims)
     → 주어진 문자열 str을 단어로 분리하는 객체를 생성하며
    공백(구분)문자는 delim에 포함된 문자로 처리하게 된다.

    만약 returnDelims 가 true 이면 구분 문자도 분리된 데이터로 처리하게 된다.

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
  - StringTokenizer 클래스
==========================================*/

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.util.StringTokenizer;

public class Test145
{
	public static void main(String[] args) throws IOException
	{
		String strTemp;
		String[] strArr;
		int n;

		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

		System.out.print("파싱할 문자열 입력(컴마구분) : ");
		strTemp = br.readLine();	//-- "사과,딸기,바나나"

		// 테스트 확인
		//System.out.println(strTemp);
		//--==>> 사과,딸기,바나나

		//StringTokenizer 클래스 인스턴스 생성
		StringTokenizer st = new StringTokenizer(strTemp,",");
		//-- strTemp 를 대상 문자열로...
		// 『,』를 구분자로...

 		strArr = new String[st.countTokens()];	// 3
		// 『int countTokens()』
		// : 파싱된 문자열의 갯수를 리턴(반환)한다.
		//-- 『String[] strArr = new String[3];』 와 동일한 구문

		n = 0;
		while (st.hasMoreTokens())	// true / false
		{
			strArr[n++] = st.nextToken();
		}

		//-- 『hasMoreTokens()』
		//   : 사용할 수 이쓴 토큰이 남아있는 경우 true 를 반환
		//     더 이상 사용할 토큰이 남아있지 않은 경우 false 를 반환
		//	   확인 결과에 대한 반환만 할 뿐...
		//     실제 내용을 읽어들이는 헤드를 이동시키지 않는다.
		//    『nextToken()』
		//    : 다음 토큰을 얻어온다.
		//      다음 토큰을 얻어오며 헤드를 이동시키게 된다.
		//      구분자를 바꾸었을 경우 다음 호출에도
		//      바뀐 구분자를 이용하여 토큰을 분리한다.
		
		System.out.println();
		System.out.println("파싱된 토큰(문자열) : ");
		for (String str : strArr)
			System.out.print(str + " ");
		System.out.println();

	}
}

○ StringBuffer 클래스는 문자열을 처리하는 클래스로 String 클래스와의 차이점은 String 클래스는 내부 문자열 데이터의 수정이 불가능하지만 StringBuffer 클래스는 문자열을 사용할 때 내부 문자열을 실행 단계에서 변경할 수 있다는 것이다. 즉, StringBuffer 객체는 가변적인 길이를 가지므로 객체를 생성하는 시점에서 미리 그 크기나 값을 지정하거나 실행 시점에 버퍼의 크기를 바꿀 수 있는 기능을 제공한다.

또한, JDK 1.5 이후부터는 문자열을 처리하는 StringBuilder 라는 클래스도 제공한다. StringBuilder 클래스의 기능은 StringBuffer 클래스와 동일하지만 가장 큰 차이점은 multi-thread unsafe 라는 점이다. 즉, Syncronization 보다 빠르며 동시성(동기화) 문제가 없다면 StringBuilder 를 사용하는 것이 성능을 향상시킬 수 있다.

/*========================================
  ■■■ 자바의 주요(중요) 클래스 ■■■
  - StringBuffer 클래스
==========================================*/

public class Test143
{
	public static void main(String[] args)
	{
		StringBuffer sb1 = new StringBuffer("korea");
		StringBuffer sb2 = new StringBuffer("korea");
	
		System.out.println(sb1 == sb2);			// 주소값 비교
		System.out.println(sb1.equals(sb2));
		//--==>> false
		//		 false

		System.out.println(sb1);
		System.out.println(sb1.toString());		// String타입으로 변환
		//--==>> korea
		//		 korea

		System.out.println(sb1.toString().equals(sb2.toString()));	// equals()는 sb1.toString()으로 인해 사용할 수 있음
		//--==>> true


		StringBuffer sb3 = new StringBuffer();
		//-- StringBuffer 기본 생성자 호출(인스턴스 생성 과정)
		//   기본적으로 생성되는 버퍼 크기는 『16』

		
		System.out.println("버퍼 크기 : " + sb3.capacity());
		//--==>> 버퍼 크기 : 16


		//////////////////////////////////////////////////////////////////


		System.out.println(sb3);
		//--==>> 無

		/*
		String name = "홍길동";
		name += "이순신";
		name += "강감찬";
		System.out.println(name);
		*/


		sb3.append("seoul");	// sb3 += "seoul";
		sb3.append("korea");	//
		sb3.append("우리나라");
		sb3.append("대한민국");

		System.out.println(sb3);
		System.out.println(sb3.toString());
		//--==>>seoulkorea우리나라대한민국
		//		seoulkorea우리나라대한민국


		System.out.println("버퍼 크기 : " + sb3.capacity());
		//--==>> 버퍼 크기 : 34


		/////////////////////////////////////////////////////////////////


		String temp1 = "java and oracle";
		System.out.println(temp1.toUpperCase());
		//--==>> JAVA AND ORACLE

		String temp2 = "JAVA AND ORACLE";
		System.out.println(temp1.toLowerCase());
		//--==>> java and oracle


		//System.out.println(sb3.toUpperCase());
		//System.out.println(sb3.toLowerCase());
		//--==>> 에러 발생(컴파일 에러)

		String temp3 = sb3.toString();
		System.out.println(temp3.toUpperCase());
		//--==>> SEOULKOREA우리나라대한민국


		System.out.println(sb3.toString());
		//--==>> seoulkorea우리나라대한민국


		// ○ 대상 문자열(sb3) 중 seoul 앞에
		//     『"한국"』이라는 문자열 추가
		sb3.insert(0, "한국");
		System.out.println("seoul 앞에 『한국』 추가 : " + sb3.toString());
		//--==>> seoul 앞에 『한국』 추가 : 한국seoulkorea우리나라대한민국

		// ○ 대상 문자열(sb3) 중 korea 문자열 뒤에
		//    『"사랑"』이라는 문자열 추가
		//    단, 대상 문자열의 인덱스를 직접 확인하지 말고...
		
		/*
		int n = sb3.toString().indexOf("korea") + "korea".length();
		sb3.insert(n, "사랑");
		System.out.println("korea 뒤에 『사랑』 추가 : " + sb3.toString());		
		*/
		
		/*
		sb3.insert(sb3.toString().lastIndexOf("korea") +"korea".length(), "사랑");
		System.out.println("korea 뒤에 『사랑』 추가 : " + sb3.toString());
		*/
		System.out.println();

		// 테스트 ①
		System.out.println(sb3.toString());
		//--==>> 한국seoulkorea우리나라대한민국

		// 테스트 ②
		/*
		sb3.insert(12, "사랑");
		System.out.println("korea 뒤에 『사랑』 추가 : " + sb3.toString());
		*/

		// 테스트 ③
		/*
		System.out.println(sb3.indexOf("korea"));
		//--==>> 7
		*/

		// 테스트 ④ → 인덱스 7
		/*
		System.out.println(sb3.insert(sb3.indexOf("korea"), "사랑"));
		//--==>> 한국seoul사랑korea우리나라대한민국
		*/

		// 테스트 ⑤ → 인덱스 12 (인덱스 7 + 5)
		/*
		System.out.println(sb3.insert(sb3.indexOf("korea") + 5, "사랑"));
		//--==>> 한국seoulkorea사랑우리나라대한민국
		*/

		// sb3.insert("korea"문자열 인덱스 + "korea"문자열의길이, "사랑");
		sb3.insert(sb3.indexOf("korea") + "korea".length(), "사랑");
		//         --------------------    --------------
		//                   7                    5

		System.out.println(sb3);
		//--==>> 한국seoulkorea사랑우리나라대한민국


		// ○ 대상 문자열(sb3)에서
		//    『우리나라』 문자열 삭제

		// 한국seoulkorea사랑우리나라대한민국
		/*
		sb3.delete(14, 18);
		System.out.println(sb3);
		*/
		//--==>> 한국seoulkorea사랑대한민국
		
		/*
		sb3.delete(sb3.indexOf("우"), sb3.indexOf("대"));
		*/
		
		
		sb3.delete(sb3.toString().indexOf("우리나라"), sb3.toString().indexOf("우리나라") + "우리나라".length());	
		System.out.println("우리나라 문자열 삭제 : " + sb3.toString());
		
		
		/*
		int n1 = sb3.toString().indexOf("우리나라");
		int n2 = n1 + "우리나라".length();
		sb3.delete(n1,n2);
		System.out.println("우리나라 문자열 삭제 : " + sb3.toString());
		*/
		
		// ○ 대상 문자열(sb3)에서
		//	  『korea』 이후 문자열 삭제(korea 포함)

		// 한국seoulkorea사랑대한민국

		sb3.delete(sb3.indexOf("korea"), sb3.capacity());
		System.out.println(sb3);
		//--==>> 한국seoul


		////////////////////////////////////////////////////////////////////////

		// 버퍼 크기 확인
		System.out.println("버퍼 크기 : " + sb3.capacity());
		//--==>> 버퍼 크기 : 34

		// 문자열(sb3)의 길이 확인
		System.out.println("문자열의 길이 : " + sb3.length());
		//--==>> 문자열의 길이 : 7


		// 버퍼 크기 조절
		// → 현재 문자열을 담아둘 수 있는 버퍼의 크기로...
		sb3.trimToSize();


		// 버퍼 크기 조절 이후 버퍼의 크기 확인
		System.out.println("버퍼 크기 : " + sb3.capacity());
		//--==>> 버퍼 크기 : 7




	}
}