Bibliothek

○ 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




	}
}

○ String 클래스는 내부 문자열 데이터에 대한 수정이 불가능하다.
   (즉, 내용 불변 : Immutable)
   문자열의 내용이 변경되면 새로운 객체를 생성하며 참조 대상을 잃어버린 객체는 가비지 컬렉션의 대상이 되고,
   새로운 객체에 새 주소를 할당하게 되므로 해시코드도 변하게 된다.

○ String 객체의 생성 및 특징

   String 객체를 생성하는 방법은
   ① 문자열 상수를 지정하는 방법과
   ② String 클래스의 생성자를 이용하는 방법 이렇게 두 가지 방법이 있다

   String str1 = "Java";
   String str2 = new String("Java");

   하지만, 『문자열 상수』를 대입 연산자를 사용하여 지정하는 방법을 통해 객체를 생성하는 경우와 『new』 연산자를 이용하여 객체를 생성하는 것은 처리 과정과 의미가 다르다.

equals() - 문자열 비교 

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

		String s1 = "seoul";
		String s2 = "seoul";
		String s3 = new String("seoul");
		String s4 = new String("seoul");
		//-- s1 과 s2 객체가 참조하는 문자열 상수가 동일한 경우
		//   문자열이 저장된 기억장소의 영역이 동일하기 때문에
		//   s1 객체와 s2 객체는 동일한 기억 장소를 참조하게 된다.
		//   하지만,
		//   s3 와 s4 객체는 동일한 영역이 아닌 다른 기억 공간을
		//   새롭게(new) 확보하여 문자열 상수를 그 공간에
		//   대입한 상황이기 때문에
		//   두 인스턴스는 같은 영역을 참조하는 것이 아니다.
		//   따라서 『s3 == s4』는 거짓이 되며,
		//   만약 같은 문자열 상수인지의 여부를
		//   비교해야 하는 상황이면 『equals()』메소드를 이용해야 한다.

		System.out.println(s1 == s2);
		System.out.println(s1 == s3);
		System.out.println(s1 == s4);
		//--==>> true
		//	 false
		//	 false

		System.out.println(s1.equals(s2));
		System.out.println(s2.equals(s3));
		System.out.println(s3.equals(s4));
		System.out.println(s4.equals(s1));		
		//--==>>true
		//	true
		//	true
		//	true
		
		System.out.println("s1 : " + s1);
		System.out.println("s2 : " + s2);
		System.out.println("s3 : " + s3);
		System.out.println("s4 : " + s4);
		//--==>>s1 : seoul
		//	s2 : seoul
		//	s3 : seoul
		//	s4 : seoul

		System.out.println("s1 : " + s1.hashCode());
		System.out.println("s2 : " + s2.hashCode());
		System.out.println("s3 : " + s3.hashCode());
		System.out.println("s4 : " + s4.hashCode());
		//--==>> s1 : 109324212
		//	 s2 : 109324212
		//	 s3 : 109324212
		//	 s4 : 109324212

		// ※ 객체가 같으면 hashCode 가 같지만
		//    hashCode 가 같다고 해서 같은 객체는 아니다.

equalsIgnoreCase() - 문자열 비교, 문자열 비교시 대소문자 구분 안함

		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea
    	
        	// 문자열의 데이터(값) 비교
		System.out.println(s.equals("seoul korea"));
		System.out.println(s.equals("Seoul Korea"));
		//--==>> true
		//	 false
		//-- 대소문자 구분
        
        	System.out.println(s.equalsIgnoreCase("Seoul Korea"));
		//--==>> true
		//-- 대소문자 구분 안함

 『+』 - 문자열 결합 연산자

		s2 += " korea";
		System.out.println(s2);
		//--==>> seoul korea

		s2 = "korea";
		System.out.println(s2);
		//--==>> korea

		//-- 이와 같은 경우
		//   s2 가 참조한 "seoul"이 저장된 영역은
		//   『s2 += "korea";』가 수행되는 시점에서
		//   가비지 컬렉션의 대상이 되며
		//	 "seoul korea" 상수가 저장된 영역을
		//	 s2 가 참조하게 되었다가
		//   다시 s2가 참조한 "seoul korea" 가 저장된 영역은
		//   『s2 = "korea";』가 수행되는 시점에서
		//   가비지 컬렉션의 대상이 되며
		//   

concat() - 문자열 결합

		String s1 = "seoul";
		String s2 = "korea";
		
		System.out.println(s1.concat(s2));
		//--==>> seoulkorea

Concat과 『+』 연산자는 같은 문자열을 합치는 기능을 한다. 하지만 동작하는 방식이 다른다. Concat은 합친 문자열을 String으로 생성한다. 하지만 『+』 연산자는 문자열을 먼저 StringBuilder로 변환시킨뒤, Append로 문자열을 더하고 다시 toString함수로 문자열로 반환해주는 방식이다.

   ※ check~!!!
  따라서, 동적인 문자열을 많이 사용하는 Servlet 등에서는 되도록이면 String을 사용하는 것 StringBuffer나 char[] 을 사용하는 것이 효율적일 수 있다.

즉, 정적인 문자열을 처리하는 경우에는 주로 String 클래스를 사용

동적인 문자열을 처리하는 경우에는 런 타임 시 동적으로 처리해주는 StringBuffer 클래스를 사용하는 것이 효율적이다.

substring() - 문자열 추출

		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea


		// 문자열 추출
		System.out.println(s.substring(6,9));
		//-- 『String객체.subString(s, e)』
		//    String객체 문자열을 대상으로
		//    s 번째에서... e-1 번째까지 추출
		//    (단, 인덱스는 0부터 시작)
		//    seoul   kor  ea
		//    012345  678  9
		//			  ---
		//--==>> kor

		System.out.println(s.substring(7));
		//-- 『String객체.subString(s)』
		//	  String객체 문자열을 대상으로
		//    s 번째에서 끝까지... (즉, 문자열이 가진 길이만큼...)
		//	  seoul k  orea
		//    0123456  789
		//             ---
		//--==>>  orea

split() - 자바에서는 특정문자를 기준으로 문자열을 잘라서 배열에 넣어준다. 데이터베이스에 +#이런식으로 문장끝에 특수기호를 넣어주고 나중에 데이터베이스에서 값을 꺼낼때는 #으로 Split 해서 사용하는 등 아주 활용도가 높음.

       		// 1. 쉼표(,)로 문자열 잘라서 배열에 넣기
		String str = "A,B,C,D";
		String[] array = str.split(",");
				    
		//출력				
		for(int i=0;i<array.length;i++)
			System.out.println("array[" + i + "]" +array[i]);
				  
		//--==>> array[0] = A
		//	 array[1] = B
		//	 array[2] = C
		//	 array[3] = D

		//2. 공백(" ")으로 문자열 잘라서 배열에 넣기
		String str = "동해물과 백두산이 마르고 닳도록 하나님이 보우하사 우리나라 만세";
		String[] array = str.split(" ");
				    
		//출력			
		for(int i=0;i<array.length;i++)
			System.out.println("array[" + i + "]" + array[i]);
		//--==>>array[0]동해물과
		//		array[1]백두산이
		//		array[2]마르고
		//		array[3]닳도록
		//		array[4]하나님이
		//		array[5]보우하사
		//		array[6]우리나라
		//		array[7]만세
		

indexOf() - 문자열(s)에 찾고자하는 어떤 문자열이 존재하면 그 index값을 반환 / 존재하지 않으면 -1 을 반환

		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea

		// ○ 찾고자 하는 대상 문자열(s)에 
		//    『kor』 문자열이 존재할까?
		//    존재한다면... 그 위치는 어떻게 될까?

		// "seoul korea"
		System.out.println(s.indexOf("kor"));
		//--==>> 6

		System.out.println(s.indexOf("ea"));
		//--==>> 9

		System.out.println(s.indexOf("e"));
		//--==>> 1

		System.out.println(s.indexOf("tt"));
		//-- 찾고자 하는 문자열이 대상 문자열에 존재할 경우
		//   그 문자열의 인덱스를 반환하지만(0부터 시작)
		//   존재하지 않을 경우 음수를 반환하게 된다. (-1)

lastIndexOf() - 문자열(s)에 찾고자하는 어떤 문자열이 존재하면 그 index값을 반환 / 존재하지 않으면 -1 을 반환

                    단, 뒤에서 부터 검사

		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea

		// ○ 찾고자 하는 대상 문자열(s)에
		//    『e』 문자열이 존재할까?
		//    존재한다면 그 위치는 어떻게 될까?
		//	  (단, 뒤에서 부터 검사)

		// seoul korea
		System.out.println(s.indexOf("e"));
		//--==>> 1
		
		System.out.println(s.indexOf("o"));
		//--==>> 2

		System.out.println(s.lastIndexOf("e"));
		//--==>> 9

		System.out.println(s.lastIndexOf("o"));
		//--==>> 7

		// ○ 대상 문자열(s) 중
		//	  『6』번째 인덱스 위치의 문자는?

charAt() - 대상 문자열(s) 에서 n번째 인덱스 위치의 문자를 반환

		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea
        
        	// ○ 대상 문자열(s) 중
		//	  『6』번째 인덱스 위치의 문자는?

		// seoul korea
		System.out.println(s.charAt(6));
		//--==>> k

		//System.out.println(s.charAt(52));
		//--==>> 에러 발생(런타임 에러)
		//		 StringIndexOutOfBoundsException

contains() - 대상 문자열(s)에서 찾고자 하는 문자열이 존재하면 true 아니면 false를 반환

 		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea
        
		System.out.println(s.contains("seoul"));
		//--==>> true
		System.out.println(s.contains("Seoul"));
		//--==>> false
		System.out.println(s.contains("incheon"));
		//--==>> false
		

startWith() - 문자열이 지정한 문자로 시작하는지 판단 같으면 true반환 아니면 false를 반환.(대소문자구별)

		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea
        
        
        	// ○ 대상 문자열(s)이 『』로 시작하는지의 여부 확인
		//    (true / false)
		System.out.println(s.startsWith("seo"));
		//--==>> true
		System.out.println(s.startsWith("kore"));
		//--==>> false

endsWith() - 문자열 마지막에 지정한 문자가 있는지를 판단후 있으면 true, 없으면 false를 반환.(대소문자구별)

 		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea   


		// ○ 대상 문자열(s)이 『rea』로 끝나는지의 여부 확인
		//	  (true / false)
		System.out.println(s.endsWith("rea"));
		//--==>> true
		System.out.println(s.endsWith("oul"));
		//--==>> false

compareTo() - 두 문자열을 비교

• 인수 문자열이 문자열이 동일한 경우, 0이 반환;
• 이 문자열이 문자열 파라미터 미만인 경우에는 값이 0보다 작은을 반환
• 이 문자열이 문자열 파라미터보다 큰 경우, 0보다 큰 값이 반환된다.

		// ○ 대상 문자열(s)과 비교 문자열 『seoul korea』 중 어떤 문자열이 더 큰가?
		//    두 문자열이 다르다면 차이를 확인(사전식 배열)
		
		String s1 = "Strings";
		String s2 = "Strings";
		String s3 = "Strings123";

		int result = s1.compareTo(2);
		System.out.println(result);
	  
		result = s2.compareTo(s3);
		System.out.println(result);
	 
		result = s3.compareTo(s1);
		System.out.println(result);
        
        	//실행결과
        	//0
		//-3
		//3

replace() / replaceAll() - 자신이 바꾸고싶은 문자로 문자열을 치환함.

둘의 차이는 replace() 메소드는 정규식 사용불가, replaceAll() 메소드는 정규식 사용가능

		// ○ 대상 문자열(s) 중
		//    해당 문자열을 찾아서 원하는 형태로 수정
		s = "우리나라 대한민국 대한독립 만세";
		s = s.replaceAll("대한", "자주");	//-- 정규식 사용 가능
		System.out.println(s);
		//--==>> 우리나라 자주민국 자주독립 만세

		s = "abcabcabcabscssasbcabc";
		s = s.replace("abc", "T");			//-- 정규식 사용 불가
		System.out.println(s);
		//--==>> TTTabscssasbcT
		
		
		s = "abcabcabcabscssasbcabc";
		System.out.println(s.replace("abc", "T"));
		System.out.println(s.replaceAll("[abc]", "T"));		// [] ←a, b or c
		//--==>> TTTabscssasbcT
		//		 TTTTTTTTTTTsTssTsTTTTT

trim() - 문자열을 입력받거나 문자열을 합칠경우 가끔 쓸데없는 공백이 따라 들어오곤 한다. 그럴때 유용하게 사용되는 Trim메소드이다. 사용법도 매우 간단하다.

하지만 보는바와 같이 가운데 있는 공백은 제거해주지는 않는다. 가운데 있는 공백은 replace함수를 써서 제거해야함.

		// ○ 공백 제거
		s = "                 사              랑             ";
		System.out.println("|" + s + "|");
		//--==>> |                 사              랑             |

		System.out.println("|" + s.trim() + "|");
		//--==>> |사              랑|
		//--> 양쪽 가장자리 공백 제거

		System.out.println("|" + s.replaceAll(" ","") + "|");
		//--==>> |사랑|

toLowerCase() / toUpperCase() - 문자열의 대/소문자를 소/대문자로 바꿈

 		String s = "seoul korea";
		System.out.println(s);
		//--==>> seoul korea  

		System.out.println(s.toUpperCase());
		//--==>> SEOUL KOREA
		System.out.println(s.toLowerCase());
		//--==>> seoul korea

toString() - String 인스턴스에 저장되어 있는 문자열을 반환 한다.

		str = "1234";
		String toString = str.toString();			
		System.out.println("toString: " + toString);

valueOf() - 다른 자료형의 변수를 문자열로 변환

static String valueOf(boolean b)
static String valueOf(char c) 
static String valueOf(int i) 
static String valueOf(long l) 
static String valueOf(float  f) 
static String valueOf(double d) 
static String valueOf(Object o) 
지정된 값을 문자열로 변환하여 반환 한다.
참조변수의 경우, toString()을 호출한 결과를 반환 한다

		int i = 12345;
		long l = 1L;
		char c = '1';
		System.out.println("valueOf: " + String.valueOf (i));
		System.out.println("valueOf: " + String.valueOf (l));
		System.out.println("valueOf: " + String.valueOf (c));
		//--==>> valueOf: 12345
		//	 valueOf: 1
		//	 valueOf: 1        
        

Wrapper 클래스의 여러 상수들과 isInfinity()메소드 활용

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


public class Test140
{
	public static void main(String[] args)
	{
		System.out.println(Integer.MAX_VALUE);
		System.out.println(Integer.MIN_VALUE);
		//--==>> 2147483647
		//		 -2147483648

		System.out.println(Long.MAX_VALUE);
		System.out.println(Long.MIN_VALUE);
		//--==>> 9223372036854775807
		//		 -9223372036854775808
		
		System.out.println(Double.MAX_VALUE);
		System.out.println(Double.MIN_VALUE);
		//--==>> 1.7976931348623157E308
		//		 4.9E-324

		System.out.println();
		
		// 실수 기반 연산
		System.out.println("1 : " + 3.0/0);
		System.out.println("2 : " + -3.0/0);
		//--==>> 1 : Infinity
		//		 2 : -Infinity

		System.out.println("3 : " + (3.0/0 == 3.0/0));
		System.out.println("4 : " + (3.0/0 == -3.0/0));
		//--==>> 3 : true
		//		 4 : false

		// 『Double.isInfinite()』 is..같은 메소드들을 대부분 반환형이 boolean이다.
		System.out.println("5 : " + Double.isInfinite(3.0/0));
		System.out.println("6 : " + Double.isInfinite(-3.0/0));
		//--==>> 5 : true
		//		 6 : true
		
		System.out.println("7 : " + (3.0/0 + -3.0/0));
		System.out.println("8 : " + 0.0/0);
		//--==>> 7 : NaN (Not a Number)
		//		 8 : NaN

		System.out.println("9  : " + (0.0/0 == 0.0/0));
		System.out.println("10 : " + (0.0/0 != 0.0/0));
		//--==>> 9  : false
		//		 10 : true

		// ※ NaN(Not a Number) 값과 임의의 수를
		//     『==』연산자를 통해 비교 연산을 수행하게 되면
		//		결과는 언제나 『false』를 반환한다.

		System.out.println("11 : " + Double.isNaN(0.0/0));
		System.out.println("12 : " + Double.isNaN(1.1+2.2));
		//--==>>11 : true
		//		12 : false


	}
}

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


public class Test139
{
	public static void main(String[] args)
	{
		byte b = 3;
		int i = 256;

		Byte b2 = new Byte(b);
		Integer i2 = new Integer(i);

		System.out.println("b2 : " + b2);
		System.out.println("i2 : " + i2);
		

		print(b2);
		print(i2);

		// Byte 클래스의 byteValue() 메소드 호출
		byte b3 = b2.byteValue();
		
		// Integer 클래스의 intValue() 메소드 호출
		int i3 = i2.intValue();


		// check~!!!
		int i4 = b2.byteValue();
		byte b4 = i2.byteValue();
		//byte b5 = i2.intValue();	//--==>> 에러 발생
		


	}

	// 『java.lang.Number』 클래스(추상 클래스)
	// Number nb = new Number();	// 불가능
	// 모든 Wrapper 클래스의 부모 클래스
	// (슈퍼 클래스, 상위 클래스)이다.
	// b2, i2 자료형이 Number n 에 넘어오면서
	// 업 캐스팅이 일어나게 된다.
	static void print(Number n)	// ← 3 (Auto-Boxing)
	{
		System.out.println(n);
	}

}