[JAVA] String

- String을 통해 객체를 생성하는 방법에는 두가지가 있다.

String str1 = "hello"; //쌍따옴표 사용
String str2 = new String("hello"); //객체사용

- String은 클래스다. int, boolean과 같은 기본형이 아닌 참조형이다.

- 문자열은 자주 사용되기 때문에 쌍따옴표로 문자열을 감싸면 저절로 new String()으로 변경해준다.

1. String 클래스 구조

public final class String {
    //속성(필드)
    private final char[] value;  //문자 데이터 자체는 char[]에 보관된다.
    
    //기능(메서드)
    public String concat(String str) {...}
    public int length() {...}
}

- 클래스이므로 속성과 기능을 가짐

- 자바 9 이후부터는 char이 아닌 byte 배열을 사용

   why? char은 2byte를 차지하지만, 영어, 숫자는 1byte를 사용하기 때문에 메모리를 효율적으로 사용하기 위해

1) String 주요 메서드

- length() : 문자열 길이 반환

- charAt(int index) : 특정 인덱스의 문자를 반환

- subString(int beginIndex, int endIndex) : 문자열의 부분 문자열을 반환

- indexOf(String str) : 특정 문자열이 시작되는 인덱스를 반환

- toLowerCase(), toUpperCase() : 문자열을 소문자 또는 대문자로 반환

- trim() : 문자열 양 끝의 공백을 제거

- concat(String str) : 문자열을 더함

-  이외에는 공식 문서 참고

2) String 클래스와 참조형

- String은 참조형이지만 너무 자주사용되기 때문에 + 연산이 사용 가능하다.

2. String 클래스 - 비교

- String 클래스를 비교할 때에는 equals()비교를 사용해야 한다.

 - 자바에서 기본적으로 제공해주는 equals(), toString()은 오버라이딩이 기본적으로 되어있다.

1) 문자열 리터럴, 문자열 풀

String class StringPrc{
	public static main(String[] args){
    
        String str1 = "hello";
    	String str2 = "hello";
    
    	System.out.println(str1 == str2); //true
    	System.out.println(str1.equals(str2)); //true
	}
}

 

- String str1 = "hello"와 같이 문자열 리터럴을 사용하는 경우 성능 최적화를 위해 문자열 풀을 사용한다.

- 자바가 실행되는 시점에 문자열 리터럴이 있으면 문자열 풀에 String 인스턴스를 미리 만들어두고, 같은 문자열이 있으면 만들지 않는다.

- String str1 = "hello"와 같이 문자열 리터럴을 사용하면 문자열 풀에서 "hello"를 찾고 인스턴스 참조(x003)을 반환한다.

- String str2 = "hello"도 "hello를 사용하므로 그 인스턴스 참조인 x003을 반환한다.

- 때문에 str1 == str2가 true가 된다.

- 그러나 넘어오는 문자열이 리터럴일지, 객체를 사용인지 모르기 때문에 필수적으로 equals()로 비교를 해야한다.

3. String 클래스 - 불변 객체

- String은 불변 객체임.

 - 변경이 필요한 경우 반환값을 만들어 반환해야 한다.

- String이 불변이 아니면 String pool의 내용이 변경될 수 도 있고, 이는 이전에 문제가 되었던 사이드 이펙트 문제가 발생할 수 있다.

4. StringBuilder - 가변 String

1)  불변인 String 클래스의 단점

- 문자를 더하거나 변경할 때 마다 계속해서 새로운 객체를 생성해야한다

String str = "A" + "B" + "C"; //목표 : ABC
String str = String("A") + String("B") + String("C"); 
String str =  String("AB") + String("C"); // 사용하지 않는 AB 생성
String str = String("ABC"); //원하는 값

2) StringBuilder

- 자바는 StringBuilder라는 가변 String을 제공해 위와 같은 문제를 해결할 수 있게 해줌 (사용시 사이드 이펙트 주의해야함)

- StringBuilder 내부에는 final이 없다.

public class StringBuilderMAin {
	public static void main(String[] args) {
    	StringBuilder sb = new String Builder();
        
        sb.append("A");
        sb.append("B");
        sb.append("C");
        
        System.out.println(sb); //ABC
        
        sb.insert(3, "Java");
        System.out.println(sb); //ABCJava
        
        sb.delete(3, 7);
        System.out.println(sb); //ABC
        
        sb.reverse();
        System.out.println(sb); //ABC
        
        //StringBuilder -> String
        String string = sb.toString();
        System.out.println(string); //결과를 기반으로 String으로 반환가능, 불변
	}
}

 - String은 불변하기 때문에 변화를 주기 위해서는 새로운 String 객체가 생성되어야 하고 기존 객체는 버려지기 때문에 메모리와 처리 시간이 더 많이 소모된다.

- StringBuilder는 가변적이기 때문에 객체안에서 추가, 삭제 등의 작업을 할 수 있으며, 이때마다 새로운 객체르르 생성하지 않아 성능을 향상시킬 수 있다.

- 단 StringBuilder를 사용할 때는 사이드 이팩트를 주의해야한다.

5. String 최적화

1) 문자열 리터럴 최적화

- 자바 컴파일러는 문자열 리터럴을 더하는 부분을 자동으로 합쳐준다.

String s1 = "Hello"+" World"; //Hello World!

2) String 변수 최적화

- String 변수의 경우 안에 값을 확인할 수 없어 단순하게 합칠 수 없다.

String result = str1 + str2;
//컴파일 (Example)
String result = new StringBuilder().append(str1).append(str2).toString();

3) String 최적화가 어려운 경우

1- 루프안에서 문자열을 더하는 경우

String class LoopString {
	public Static main(String[] args){
    	
        long startTime = System.currenTimeMillis();
        String result = "";
        
        for(int i = 0; i<10000; i++){
        	result += "Hello Java";
		}
        long endTime = System.currenTimeMillis();
        
        System.out.println(result); //Hello Java X 100000
        System.out.println(endTime - startTime) //오래걸림

//최적화 (Example)
String result = "";
for(int i = 0; i < 100000; i++) {
	result = new StringBuilder().append(result).append("Hello JAVA").toString();
} // 반복 횟수만큼 객체가 생성됨

- 반복문의 루프 내부에서는 반복 횟수만큼 객체를 생성한다.

- 반복문 내에서 문자열 연결은 런타임에 연결할 문자열의 개수와 내용에 따라 내용이 결정되는데,

   이런 경우 컴파일러는 얼마나 많은 반복이 일어날지 문자열이 어떻게 변할지 예측할 수 없기 때문에 최적화가 어렵다.

//StringBuilder를 사용해 해결가능
String class LoopStringBuilder {
	public Static main(String[] args){
    	
        long startTime = System.currenTimeMillis();
        StringBuilder sb = new StringBuilder();
        
        for(int i = 0; i<10000; i++){
        	sb.append("Hello Java");
		}
        String result = sb.toString();
        long endTime = System.currenTimeMillis();
        
        System.out.println(result); //Hello Java X 100000
        System.out.println(endTime - startTime) //거의 즉시 이루어짐

- 문자열을 합칠 때 대부분 경우 최적화가 되므로 +를 사용하면 되지만, 아래와 같은 경우는 StringBuilder가 더 좋다.

    - 반복문 안에서 반복해서 문자를 연결할 때

    - 조건문을 통해 문자열을 동적으로 조합할 때

    - 복잡한 문자열의 특정 부분을 변경할 때

    - 매우 긴 대용량 문자열을 다룰 때

5. Method Chaining

public class ValueAdder{
	
    private int value;
    
    public ValueAdder add(int addValue) {
    	value += addValue; //add()를 호출하면 value에 값을 누적한다.
        return this; //자기 자신의 참조값을 반환한다.
	}
    
    public int getValue() {
    	return value;
	}
}

public class MethodChainingMain {
	public static void main(String args[]){
    	
        ValueAdder adder = new ValueAdder();
        adder.append(1);
        adder.append(2);
        adder.append(3); 
        //add()메서드를 여러번 호출해서 값을 누적하고 더함
        // add()메서드의 반환값은 사용 X
        
        int result = add.getValue();
        System.out.println(result); // 6
	}
}

- add() 매서드 반환값 사용

public class MethodChainingMain {
	public static void main(String args[]){
    	
        ValueAdder adder = new ValueAdder(); //x001
        ValueAdder adder1 = adder.add(1); //x001
        ValueAdder adder2 = adder.add(2); //x001
        ValueAdder adder3 = adder.add(3); //x001
        
        int result = adder3.getValue();
        System.out.println(result); // 6
	}
}

- add() 메서드는 자기 자신의 참조값을 반환하고 이를 adder1, adder2,  adder3에 보관

- 따라서 adder1,2,3는 모두 같은 참조값을 사용한다.

 

- 더 복잡해보이는 add()메서드 반환값을 사용하는 이유(메서드 체이닝)

.. 생략
public static void main(String[] args) {
	
    ValueAdder adder = new ValueAdder();
    int result = adder.adder(1).adder(2).adder(3).getValue();
    //int result = x001.adder(1).adder(2).adder(3).getValue();
    //int result = x001.adder(2).adder(3).getValue();
    //...
    //int result = x001.getValue();
    
    System.out.println(result); //6
}

- .을 찍고 메서드를 계속 연결해서 사용할 수 있다.

- 마치 체인으로 연결된 것 처럼 보이는데 이런 기법을 메서드 체이닝이라 한다.

- 메서드 체이닝은 자기 자신의 참조값을 반환하기 때문에 사용할 수 있다. 

1)String Builder와 Method Chain

- StringBuilder는 Method Chaining 기법을 제공한다.

- StringBuilder에서 문자열을 변경하는 대부분의 메서드도 메서드 체이닝 기법을 제공하기 위해 자기 자신을 반환한다.

 

- 앞서 작성한 코드 줄이기

public class StringBuilderMAin {
	public static void main(String[] args) {
    	
        StringBuilder sb = new String Builder();
        String result = sb.append("A").append("B").append("C").toString();
        
        System.out.println(result); //ABC

	}
}

 

 

- 참고 : 김영한의 실전 자바 - 중급 1편