java.lang패키지와 유용한 클래스(2)

얕은 복사와 깊은 복사

clone()은 단순히 객체에 저장된 값을 그대로 복제할 뿐, 객체가 참조하고 있는 객체까지 복제하지 않는다. 예제 9-8에서처럼 기본형 배열인 경우에는 아무런 문제가 없지만 ,객체 배열을 clone()으로 복제하는 경우 원본과 복제본이 같은 객체를 공유하므로 완전 한 복제라고 보기 어렵다. 이러한 복제(복사)를 얕은복사(shallow copy)라고 한다. 얕은 복사에서는 원본을 변경하면 복사본도 영향을 받는다.

반면에 원본이 참조하고 있는 객체까지 복제하는 것을 깊은복사(deep copy)라고 한다. 깊은 복사에서는 원본과 복사본이 서로 다른 객체를 참조하기 때문에 원본의 변경이 복사본에 영향을 미치지 않는다.

예를 들어 Circle클래스가 아래와 같이 Point타입의 참조변수를 포함하고 있고, clone()은 단순히 Object클래스의 clone()을 호출하도록 정의되어 있을 때

class Circle implements Cloneables{
	Point p;  //원점 -참조변수
	double r; //반지름

	Circle(Point p, double r) {
		this.p = p;
		this.r = r;
	}
	public Circle clone() { //얕은 복사
		Object obj = null;
		try{
			obj = super.clone();  //조상인 Object의 clone()을 호출한다.
		}catch(CloneNotSupportedException e){ }
		return (Circle)obj;
	}
}

Circle인스턴스 c1을 생성하고 clone(0으로 복제해서 c2를 생성하면 ,

Circle c1 = new Circle(new Point(1,1),2.0);
Circle c2 = c1.clone();  //얕은 복사

c1와 c2는 같은 Point인스턴스를 가리키게 되므로 완전한 복제라고 할 수 없다.

그렇면 어떻게 해야 c1과 c2가 각각의 Point인스턴스를 가리키도록 할까?

class Circle implements Cloneable{
	Point3 p;  //원점
	double r; //반지름
	
	Circle(Point3 p, double r){
		this.p = p;
		this.r = r;
	}
	
	public Circle shallowCopy(){ //얕은 복사
		Object obj = null;
		
		try{
			obj = super.clone();
		}catch(CloneNotSupportedException e){}
		
		return (Circle)obj;
	}
	
	public Circle deepCopy(){ //기픙ㄴ 복사
		Object obj = null;
		
		try{
			obj = super.clone();
		}catch(CloneNotSupportedException e){}
		
		Circle c =(Circle)obj;
		c.p =new Point3(this.p.x, this.p.y);
		return c;
	}
	public String toString(){
		return "[p="+p+", r="+r+"]";
	}
}

class Point3{
	int x,y;
	
	Point3 (int x, int y){
		this.x = x;
		this.y = y;
	}
	
	public String toString(){
		return "("+x+", "+y+")";
	}
}

public class ShallowDeepCopy {

	public static void main(String[] args) {
		
		Circle c1 =new Circle(new Point3(1,1),2.0);
		Circle c2 = c1.shallowCopy();
		Circle c3 = c1.deepCopy();
		
		System.out.println("c1="+c1);
		System.out.println("c2="+c2);
		System.out.println("c3="+c3);
		
		c1.p.x = 9;
		c1.p.y = 9;
		
		System.out.println("= c1의 변경 후 =");
		System.out.println("c1="+c1);
		System.out.println("c2="+c2);
		System.out.println("c3="+c3);
		
	}

}
===================================
c1=[p=(1, 1), r=2.0]
c2=[p=(1, 1), r=2.0]
c3=[p=(1, 1), r=2.0]
= c1의 변경 후 =
c1=[p=(9, 9), r=2.0]
c2=[p=(9, 9), r=2.0]
c3=[p=(1, 1), r=2.0]

인스턴스 c1을 생성한 후에 얕은 복사로 c2를 생성하고, 깊은 복사로 c3를 생성하였다.

Circle c1 =new Circle(new Point(1,1), 2.0);
Circle c2 = c1.shallowCopy();
Circle c3 = c1.deepCopy();

위 상황은 c1,c2는 같은 Point인스턴스를 가리키고 있는 상황이고, c3은 새로운 Point인스턴스를 가리키는 상황이다.

그다음에 c1이 가리키고 있는 Point인스턴스의 x와 y의 값을 9로 변경한다.

c1.p.x = 9;
c1.p.y = 9;

c1을 변경하면 , c2도 영향을 받는다. 그러나 c3는 전혀 영향을 받지 않는다.

shallowCopy()의 내용을 보면, 단순히 Object클래스의 clone()을 호출할 뿐이다.

public Circle shallowCopy(){ //얕은 복사
		Object obj= null;

		try{ 
			obj = super.clone();
		}catch(CloneNotSupportedException e) { }
		return (Circle) obj;
}

앞서 설명한 것과 같이 Object클래스의 clone()은 원본 객체가 가지고 있는 값만 그대로 복사한다. 즉 얕은 복사를 한다.

Circle c =(Circle) obj;
c.p = new Point(this.p.x, this.p.y);

deepCopy()는 shallowCopy()에 위의 두 줄을 추가하여, 복제된 객체가 새로운 Point인스턴스를 참조하도록 하였다. 원본이 참조하고 있는 객체까지 복사한 것이다.

getClass()

이 메서드는 자신이 속한 클래스의 Class개겣를 반환하는 메서드인데, Class객체는 이름이 Class인 클래스의 객체이다. Class클래스는 아래와 같이 정의되어 있다.

public final class Class implements...{ //Class 클래스
	...
}

Class객체는 클래스의 모든 정보를 담고 있으며, 클래스 당 1개만 존재한다. 그리고 클래스 파일이 '클래스 로더(ClassLoader)'에 의해서 메모리에 올라갈 때, 자동으로 생성된다.

클래스 로더는 실행 시에 필요한 클래스를 동적으로 메모리에 로드하는 역할을 한다. 먼저 기존에 생성된 클래스 객체가 메모리에 존재하는지 확인하고, 있으면 객체의 참조를 반환하고 없으면 클래스 패스(classpath)에 지정된 경로를 따라서 클래스 파일을 찾느다.

못 찾으면 ClassNotFoundException이 발생하고, 찾으면 해당 클래스 파일을 읽어서 Class객체로 변환한다.

그러니까 파일 형태로 저장되어 있는 클래스를 읽어서 Class클래스에 정의된 형식으로 변환하는 것이다. 즉, 클래스 파일을 읽어서 사용하기 편한 형태로 저장해 놓은 것이 클래스 객체이다.

• 클래스 파일을 메모리에 로드하고 변환하는 일은 클래스 로더가 한다.\

Class 객체를 얻는 방법

클래스의 정보가 필요할 때, 먼저 Class객체에 대한 참조를 얻어 와야하는데, 해당 Class객체에 대한 참조를 얻는 방법은 여러가지가 있다.

Class cObj = new Card().getClass(); //생성된 객체로부터 얻는 방법
Class cObj = Card.class;  //클래스 리터럴(*.calss)로 부터 얻는 방법
Class cObj = Class.forNmae("Card"); //클래스 이름으로부터 얻는 방법

특히 forName()은 특정 클래스 파일, 예를 들어 데이터베이스 드라이버를 메모리에 올릴때 주로 사용한다.

Class객체를 이용하면 클래스에 정의된 멤버의 이름이나 개수 등 , 클래스에 대한 모든 정보를 얻을 수 있기 때문에 Class객체를 통해서 객체를 생성하고 메서드를 호출하는 등 보다 동적인 코드를 작성할 수 있다.

Card c =new Card();  //new 연산자를 이용해서 객체를 생성
Card c =Card.class.newInstance(); //Class객체를 이용해서 객체를 생성

• newInstance()는 InstantiationException이 발생할 수 있으므로 예외처리가 필요하다.

동적으로 객체를 생성하고 메서드를 호출 하는 방법에 대해 더알고싶다면 리플렉션API(reflection API)로 검색하면 된다.

final class Card2{
	String kind;
	int num;
	
	Card2() {
		this("SPADE", 1);
	}
	Card2(String kind, int num){
		this.kind =kind;
		this.num = num;
	}
	
	public String toString(){
		return kind+":"+num;
	}
}

public class ClassEx1 {

	public static void main(String[] args) {
		try {
			Card2 c =new Card2("HEART", 3);  //new연산자로 객체 생성
			Card2 c2 =Card2.class.newInstance();//Class객체를 통해서 객체 생성
			Class cObj = c.getClass();
			
			System.out.println(c);
			System.out.println(c2);
			System.out.println(cObj.getName());
			System.out.println(cObj.toGenericString());
			System.out.println(cObj.toString());
		} catch (InstantiationException | IllegalAccessException e) {
			e.printStackTrace();
		} 
	
		
	}

}
======================
HEART:3
SPADE:1
Card2
final class Card2
class Card2

Class객체를 이용해서 동적으로 객체를 생성하는 예제이다. Java API문서에서 Class클래스를 찾아보면 클래스의 정보를 얻을 수 있는 많은 수의 메서드가 정의되어 있는 것을 확인할 수 있다.

String 클래스

기존의 다른 언어에서는 문자열을 char형의 배열로 다루었으나 자바에서는 문자열을 위한 클래스를 제공한다. 그것이 바로 String클래스인데, String클래스는 문자열을 저장하고 이를 다루는데 필요한 메서드를 함께 제공한다.

지금까지 String클래스의 기본적인 몇 가지 기능만 사용해 왔지만 String클래스는 아주 중요하므로 자세히 공부해야 한다.

변경 불가능한(immutable 클래스)

String클래스에는 문자열을 저장하기 위해서 문자형 배열 참조변수(char[]) value를 인스턴스 변수로 정의해놓고 있다. 인스턴스 생성 시 생성자의 매개변수로 입력받는 문자열은 이 인스턴스변수(value)에 문자형 배열(char[])로 저장되는 것이다.

• String클래스는 앞에 final이 붙어 있으므로 다른 클래스의 조상이 될 수 없다.

public final class String implements java.io.Serializable, Comparable{
		private char[] value;
	...
}

한번 생성된 String인스턴스가 갖고 있는 문자열은 읽어 올 수만 있고, 변경할 수는 없다.

예를 들어 아래의 코드와 같이 '+'연산자를 이용해서 문자열을 결합하는 경우 인스턴스내의 문자열이 바뀌는 것이 아니라 새로운 문자열("ab")이 담긴 String인스턴스가 생성되는 것이다.

String a = "a";
String b = "b"; 
String a = a + b; //새로운 문자열 참조 

이처럼 덧셈연산자 +를 사용해서 문자열을 결합하는 것은 매 연산 시 마다 새로운 문자열을 가진 String인스턴스가 생성되어 메모리공간을 차지하게 되므로 가능한 한 결합횟수를 줄이는 것이 좋다.

문자열간의 결합이나 추출 등 문자열을 다루는 작업이 많이 필요한 경우에는 String클래스 대신 StringBuffer클래스를 사용하는 것이 좋다. STringBuffer인스턴스에 저장된 문자열은 변경이 가능하므로 하나의 StringBuffer인스턴스만으로도 문자열을 다루는 것이 가능하다.

문자열의 비교

문자열을 만들 때는 두 가지 방법, 문자열 리터럴을 지정하는 방법과 String클래스의 생성자를 사용해서 만드는 방법이 있다.

String str1 = "abc";  //문자열 리터럴 "abc"의 주소가 str1에 저장됨
String str2 = "abc";  //문자열 리터럴 "abc"의 주소가 str2에 저장됨
String str3 = new String("abc"); //새로운 String인스턴스를 생성
String str4 = new String("abc"); //새로운 String 인스턴스를 생성

String클래스의 생성자를 이용한 경우에는 new 연산자에 의해서 메모리할당이 이루어지기 때문에 항상 새로운 String인스턴스가 생성된다. 그러나 문자열 리터럴은 이미 존재하는 것을 재사용하는 것이다.

• 문자열 리터럴은 클래스가 메모리에 로드될때 자동적으로 미리 생성된다.

즉 str1과 str2는 같은 문자열 리터럴"abc"를 가리키고 있고,

str3와 str4는 각각의 인스턴스를 가리키고 있는 것이다 .

str1 == str2 → true

str3 == str4 → false

equlas()를 사용했을 때는 두 문자열의 내용("abc")을 비교하기 때문에 두 경우 모두 true를 결과로 얻는다. 하지만, 각 String인스턴스의 주소를 등가비교연산자 ==로 비교했을 때는 결과가 다르다.

public class StringEx1 {

	public static void main(String[] args) {
		String str1 = "abc";
		String str2 = "abc";
		System.out.println("String str1 = \"abc\";");
		System.out.println("String str2 = \"abc\";");
		
		System.out.println("str1 == str2 ? "+(str1 == str2));
		System.out.println("str1.equals(str2) ? "+ str1.equals(str2));
		
		String str3 = new String("\"abc\"");
		String str4 = new String("\"abc\"");
		
		System.out.println("String str3 = new String(\"abc\");");
		System.out.println("String str4 = new String(\"abc\");");
		
		System.out.println("str3 == str4 ? "+(str3 == str4));
		System.out.println("str3.equals(str4) ? "+ str3.equals(str4));
		
	}

}
=========================
String str1 = "abc";
String str2 = "abc";
str1 == str2 ? true
str1.equals(str2) ? true
String str3 = new String("abc");
String str4 = new String("abc");
str3 == str4 ? false
str3.equals(str4) ? true

문자열 리터럴

자바소스파일에 포함된 모든 문자열 리터럴은 컴파일 시에 클래스 파일에 저장된다. 이 떄 같은 내용의 문자열 리터럴은 한번만 저장된다. 문자열 리터럴도 String인스턴스이고, 한번 생성하면 내용을 변경할 수 없으니 하나의 인스턴스를 공유하면 되기 때문이다.

public class StringEx2 {

	public static void main(String[] args) {
		String s1 = "AAA";
		String s2 = "AAA";
		String s3 = "AAA";
		String s4 = "BBB";
		

	}

}

위 예제를 컴파일 하면 StringEx.class파일이 생성된다. 이 파일의 내용을 16진 코드 에디터로 바꿔서 보면

"AAA"와 "BBB"가 있는 것을 발견할 수 있다. 이와 같이 String리터럴들은 컴파일시에 클래스 파일에 저장된다.

그래서 위의 예제를 실행하면 "AAA"를 담고 있는 String인스턴스가 하나 생성된 후, 참조변수 s1,s2,s3는 모두 이 String인스턴스를 참조하게 된다.

클래스 파일에는 소스파일에 포함된 모든 리터럴의 목록이 있다. 해당 클래스 파일이 클래스 로더에 의해 메모리에 올라갈 때, 이 리터럴의 목록에 있는 리터럴들이 JVM내에 있는 상수 저장소(constant pool)에 저장된다. 이 때 , 이곳에 "AAA"와 같은 문자열 리터럴이 자동적으로 생성되어 저장되는 것이다.

빈 문자열(empty string)

길이가 0인 배열이 존재할 수 있을까? 답은 Yes이다. char형 배열도 길이가 0인 배열을 생성할 수 있고, 이 배열을 내부적으로 가지고 있는 문자열이 바로 빈 문자열이다.

String s = "";와 같은 문장이 있을 때, 참조변수 s가 참조하고 있는 String인스턴스는 내부에 new Char[0]과 같이 길이가 0인 char형 배열을 저장하고 있는 것이다.

• C언어에서는 길이가 0인 배열을 선언할 수 없다.

char[] chArr = new char[0];  //길이가 0인 char배열
int [] iArr ={};  //길이가 0인 int 배열

길이가 0이기 때문에 아무런 문자도 저장할 수 없는 배열이라 무의미하게 느껴지겠지만 어쨋든 이러한 표현이 가능하다.

그러나 String s = "";과 같은 표현이 가능하다고 해서 char c= "";와 같은 표현도 가능한것은 아니다. char형 변수에는 반드시 하나의 문자를 지정해야 한다.

• C언어에서는 문자열의 끝에 널 문자가 항상 붙지만 , 자바에서는 널문자를 사용하지않는다. 대신 문자열의 길이정보를 따로 저장한다.

String s = null;  ->  ""   빈 문자열로 초기화
String c ='\u0000'; -> ' ' 공백으로 초기화

일반적으로 변수로 선언할 때, 각 타입의 기본값으로 초기화 하지만 String은 참조형 타입의 기본값인 null보다는 빈 문자열로, char형은 기본값인 '\u0000'대신 공백으로 초기화 하는 것이 보통이다.

• '\u0000'은 유니코드의 첫 번쨰 문자로써 아무런 문자도 지정되지 않은 빈 문자이다.

public class StringEx3 {

	public static void main(String[] args) {
		//길이가 0인 char배열을 생성한다.
		char[] cArr = new char[0];  //char[] cArr = {};와 같다.
		String s = new String(cArr);  //String s= new String("");와 같다.
		
		System.out.println("cArr.length="+cArr.length);
		System.out.println("@@@"+s+"@@@");
		
	}

}
==============================
cArr.length=0
@@@@@@

길이가 0인 배열을 생성해서 char형 배열 참조변수 cArr를 초기화 해주었다. 길이가 0이긴 해도 배열이 생성되어 생성된 배열의 주소값이 참조변수 cArr에 저장된다.

String클래스의 생성자와 메서드

아래의 표는 String클래스 내에 정의된 생성자와 메서드의 목록이다. 전체 목록은 아니고, 자주 사용될만한 것들만 뽑았는데도 거의다 포함되었다.

메서드	설명	예제	결과
String(String a)	주어진 문자열(s)를 갖는 Stirng 인스턴스를 생성한다.	String s = new String("Hello");	s ="Hello"
String(char[] value)	주어진 문자열(value)를 갖는 String 인스턴스를 생성한다.	char[ ] c = {'H','e','l','l','o'}; String s =new String(c);	s= "Hello"
String(StringBuffer buf)	StringBuffer인스턴스가 갖고 있는 문자열과 같은 내용의 String인스턴스를 생성한다.	StringBuffer sb = new StringBuffer("Hello"); String s = new String(sb);	s = "Hello"
char charAt(int index)	지정된 위치(index)에 있는 문자를 알려준다. (index는 0부터 시작)	String s = "Hello"; String n = "0123456"; char c = s.charAt(1); char c2 = n.charAt(1);	c = 'e' c2 ='1'
int compareTo(string str)	문자열(str)과 사전순서로 비교한다. 같으면 0을 , 사전순으로 이전이면 음수를, 이후면 양수를 반환한다.	int i = "aaa".compareTo("aaa"); int i2 = "aaa".compareTo("bbb"); int i3 = "bbb".compareTo("aaa")	i = 0 i2 = -1 i3 =1
String concat(String str)	문자열(str)을 뒤에 덧붙인다.	String s ="Hello"; String s2 = s.concat(" World");	s2 ="Hello World"
boolean contains(CharSequence s)	지정된 문자열(s)가 포함되어 있는지 검사한다.	String s ="abcdefg"; boolean b = s.concat("bc");	b= true
boolean endsWith(String suffix)	지정된 문자열 (suffix)로 끝나지는 검사한다.	String file = "Hello.text"; boolean b = file.endWith("txt");	b =true
boolean equals(Object obj)	매개변수로 받은 문자열(obj)과 String인스턴스의 문자열을 비교한다. obj가 String이 아니거나 문자열이 다르면 false를 반환한다.	String s ="Hello"; boolean b = s.equals("Hello"); boolean b2 =s.equals("hello");	b= true b2 = false
boolean equalsIgnoreCase(String str)	문자열과 String인스턴스의 문자열을 대소문자 구분없이 비교한다.	String s ="Hello"; boolean b = s.equalsIgnoreCase("Hello"); boolean b2 =s.equalsIgnoreCase("hello");	b= true b2 =true
int indexOf(int ch)	주어진 문자(ch)가 문자열에 존재하는지 확인하여 위치(index)를 알려준다. 못찾으면 -1을 반환한다(index는 0부터 시작)	String s = "Hello"; int idx1 = s.indexOf('o'); int idx2 = s.indexOf('k');	idx1 =4 idx2 =-1
int indexOf(int ch, int pos)	주어진 문자(ch)가 문자열에 존재하는지 지정된 위치(pos)부터 확인하여 위치(index)를 알려준다. 못찾으면 -1을 반환한다.(index는 0부터 시작)	String s = "Hello"; int idx1 = s.indexOf('e', 0); int idx2 = s.indexOf('e',2);	idx1 = 1 idx2 = -1
int indexOf(String str)	주어진 문자열이 존재하는지 확인하여 그 위치(index)를 알려준다. 없으면 -1을 반환한다.(index는 0부터 시작)	String s = "ABCDEFG"; int idx = s.indexOf("CD");	idx=2
String intern()	문자열을 상수풀(constant pool)에 등록한다. 이미 상수풀에 같은 내용의 문자열이 있을 경우 그 문자열의 주소값을 반환한다.	String s = new String("abc"); String s2 =new String("abc"); boolean b = (s == s2); boolean b2 =s.equals(s2); boolean b3 = (s.intern() == s2.intern() );	b =false b2 =true b3 =true
int lastIndexOf(int ch)	지정된 문자 또는 문자코드를 문자열의 오른쪽 끝에서부터 찾아서 위치(index)를 알려준다. 못 찾으면 -1을 반환한다.	String s = "java.lang.Object"; int idx1 = s.lastIndexOf('.'); int idx2 = s.indexOf('.');	idx1 = 9  idx2 = 4
int lastIndexOf(String str)	지정된 문자열을 인스턴스의 문자열 끝에서부터 찾아서 위치(index)를 알려준다. 못찾으면 -1을 반환한다.	String s = "java.lang.java"; int idx1 = s.lastIndexOf("java"); int idx2 = s.indexOf("java");	idx1 = 10 idx = 0
int length()	문자열의 길이를 알려준다	String s ="Hello" int length = s.length();	length =5
String replace(char old, char nw)	문자열 중의 문자(old)를 새로운 문자열(nw)로 모두 바꾼 문자열을 반환한다.	String s = "Hello"; String s1 = s.replace('H','C');	s1 ="Cello"
String replace(CharSequence old , CharSequence nw)	문자열 중의 문자열(old)을 새로운 문자열(nw)로 모두 바꾼 문자열을 반환한다.	String s = "Hellollo"; String s1 = s.replace("ll", "LL");	s1 = "HeLLoLLo"
String replaceAll(String regex, String replacement)	문자열 중 지정된 문자열 (regex)과 일치하는 것을 새로운 문자열(replacement)로 모두 변경한다	String ab = "AABBAABB"; String r = ab.replaceAll("BB", "bb");	r = "AAbbAAbb"
String replaceFirst(String regex, String replacement)	문자열 중에서 지정된 문자열(regex)과 일치하는 것 중, 첫번째 것만 새로운 문자열(replacement)로 변경한다.	String ab ="AABBAABB"; String r =ab.replaceFirst("BB", "bb");	r ="AAbbAABB"
String[] split(String regex)	문자열을 지정된 분리자(regex)로 나누어 문자열 배열에 담아 반환한다.	String animals = "dog,cat,bear"; String[] arr =aniamls.split(",");	arr[0] = "dog" arr[1] ="cat" arr[2] ="bear"
String[] split(String regex, int limit)	문자열을 지정된 분리자(regex)로 나누어 문자열배열에 담아 반환한다. 단, 문자열 전체를 지정된 수(limit)로 자른다.	String animals = "dog,cat,bear"; String[] arr =animal.split(",", 2);	arr[0] = "dog" arr[1] ="cat,bear"
boolean startsWith(String prefix)	주어진 문자열(prefix)로 시작하는지 검사한다.	String s = "java.lang.Object"; boolean b = s.startWith("java"); boolean b2 =s.startsWith("lang"):	b =true b2 =false
String substring(int begin) String substring(int begin, int end)	주어진 시작위치(begin)부터 끝 위치(end)범위에 포함된 문자열을 얻는다. 이 떄 시작위치의 문자는 범위에 포함되지만, 끝 위치의 문자는 포함되지 않는다. (begin ≤ x <end)	String s ="java.lang.Object"; String c = s.substring(10); String p = s.substring(5, 9);	c ="Object" p ="lang"
String toLowerCase()	String인스턴스에 저장되어있는 모든 문자열을 소문자로 변환하여 반환한다.	String s= "Hello"; String s1 = s.toLowerCase();	s1 = "hello"
String toString()	String인스턴스에 저장되어 있는 문자열을 반환한다.	String s = "Hello"; String s1 = s.toString();	s1 ="Hello"
String toUpperCase()	String인스턴스에 저장되어 있는 모든 문자열을 대문자로 변환하여 반환한다.	String s ="Hello"; String s1 = s.toUpperCase();	s1 = "HELLO"
String trim()	문자열의 왼쪽 끝과 오른쪽 끝에 있는 공백을 없앤 결과를 반환한다. 이 때 문자열 중간에 있는 공백은 제거되지 않는다.	String s = " Hello World "; String s1 = s.trim();	s1="Hello World"
static String valueOf(boolean b) static String valueOf(char c) static String valueOf(int i) static String valueOf(long i) static String valueOf(float f) static String valueOf(double d) static String valueOf(Object o)	지정된 값을 문자열로 변환하여 반환한다. 참조변수의 경우 toString()을 호출한 결과를 반환한다.	String b = String.valueOf(true); String c = String.valueOf('a'); String i = String.valueOf(100); String l = String.valueOf(100L); String f = String.valueOf(10f); String d =String.valueOf(10.0); java.util.Date dd = new java.util.Data(); String date = String.valueOf(dd);	b="true" c="a" i="100" l="100" f = "10.0" d="10.0" date ="Wed Jan 27 21:26:29 KST 2016"

• CharSequence는 JDK1.4부터 추가된 인터페이스로 String, StringBuffer등의 클래스가 구현하였다.
• contains(CharSequence s), replace(CharSequence old, CharSequence nw)는 JDK 1.5부터 추가되었다.
• java.util.Date dd =new java.util.Date(); 에서 생성된 Date인스턴스는 현재 시간을 갖는다.