[Java 중급] String 클래스 내부 구조와 메서드들 / StringBuilder / 메서드 체이닝

<목차>
1. 기본
2. 비교
3. 불변 객체
4. 주요 메서드 1
5. 주요 메서드 2
6. 가변 String
7. 최적화
8. 메서드 체이닝 - Method Chaining

 

1. String 클래스 - 기본

자바에서 문자를 다루는 대표적 타입은 char, String이다.

char은 문자 하나를 다룰 때 사용

char를 사용해서 여러 문자를 나열하려면 char[]을 사용해야 한다. 

그러나 char을 배열로 만드는것 보다 String을 사용하면 편리하다.

 

String은 클래스이다. 

클래스의 특징은 참조형이다. 그래서 String으로 만든 변수는 String 인스턴스의 참조값만 들어갈 수 있다.

하지만 String은 두가지 형태로 만들수 있는 특별함이 있다.

public class StringBasicMain {

  public static void main(String[] args) {
     String str1 = "hello";
     String str2 = new String("hello");
  }
}

문자열은 자주 사용되기 때문에 편의상 쌍따옴표로 문자열을 감싸면 자동으로 new String() 형식으로 변경해준다. 

 

String은 클래스인데 클래스 내부에는 어떻게 생겼을까?

 public final class String {

//문자열 보관
private final char[] value;// 자바 9 이전 
private final byte[] value;// 자바 9 이후

//여러 메서드
public String concat(String str) {...}
public int length() {...}
...
}

클래스이므로 속성과 기능을 가진다. 

 

속성(필드)

private final char[] value;

String의 실제 문자열 값이 보관된다. 문자 데이터 자체는 char[]에 보관된다.

즉, 우리는 String 변수이름 = "내용";으로 간단하게 내용을 넣지만, 클래스 내부에서 '내용'은 결국 chr[]형태로 저장된다는 뜻이다. 

자바 9 이후로는 char[]이 아니라 byte[]로 저장되는 것으로 바뀌기는 하였다.

 

 

기능(메서드)

String 클래스는 문자열로 처리할 수 있는 다양한 기능(메서드)도 숨겨져 있다.

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

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

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

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

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

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

- concat(String str) : 문자열을 더한다.

 

 

String클래스와 참조형

참조형은 변수에 계산할 수 있는 값이 들어있는 것이 아니라 x001과 같이 계산할 수 없는 참조값이 들어있다.

따라서 원칙적으로는 +와 같은 연산을 사용할 수 없다.

package lang.string;

public class StringConcatMain {
 
  public static void main(String[] args) {
      String a = "hello";
      String b = " java";
      
      String result1 = a.concat(b);
      String result2 = a + b;
    
  }
}

원칙적으로는 문자열을 더할때 String이 제공하는 concat()과 같은 메서드를 사용해야 하지만

편의상 +연산도 제공한다. 

 

---

2. String클래스 - 비교

String 클래스 비교할 때는 == 비교가 아니라 항상 equals() 비교를 해야 한다.

동일성(identity) : == 연산자를 사용해서 두 객체가 참조가 동일한 객체인지를 확인
동등성(Equality) : equals() 메서드를 사용하여 두 객체가 논리적으로 같은지 확인

 

문자열 리터럴은 Java에서 문자열을 "(쌍따옴표)로 감싸서 직접 정의한 형태를 말하는데

`String str3 = "hello"` 와 같이 문자열 리터럴을 사용하는 경우 자바는 메모리 효율성과 성능 최적화를 위 해 문자열 풀을 사용한다.

자바가 실행되는 시점에 클래스에 문자열 리터럴이 있으면 문자열 풀에 `String` 인스턴스를 미리 만들어둔다. 이때 같은 문자열이 있으면 만들지 않는다.

`String str3 = "hello"` 와 같이 문자열 리터럴을 사용하면 문자열 풀에서 `"hello"` 라는 문자를 가진 `String` 인스턴스를 찾는다. 그리고 찾은 인스턴스의 참조( `x003` )를 반환한다.
`String str4 = "hello"` 의 경우 `"hello"` 문자열 리터럴을 사용하므로 문자열 풀에서 `str3` 과 같은 `x003` 참조를 사용한다.

문자열 풀 덕분에 같은 문자를 사용하는 경우 메모리 사용을 줄이고 문자를 만드는 시간도 줄어들기 때문에 성능 도 최적화 할 수 있다.

따라서 문자열 리터럴을 사용하는 경우 같은 참조값을 가지므로 `==` 비교에 성공한다.

하지만 메서드의 매개변수로 넘어오는 String 인스턴스가 new String()로 만들어진건지 문자열 리터럴로 만들어진건지 여부를 확인할 수 없어서 문자열 풀로 저장되는지도 알수가 없다.

따라서 참조값 일치를 확인하는 동일성(==)연산자를 사용하지 말고

문자열 비교는 항상 equals()를 사용해서 동등성 비교를 해야 한다. 

 

---

3. String 클래스 - 불변 객체

String은 불변 객체이다. 따라서 생성 이후에 절대로 내부의 문자열 값을 변경할 수 없다. 

그래서 기존 문자열에 새로운 내용을 덧붙일 수 없는 특성을 가졌다. 

package lang.string.immutable;
 public class StringImmutable1 {
     public static void main(String[] args) {
         String str = "hello";
         str.concat(" java");
         System.out.println("str = " + str);
} }

 

실행결과

str = hello

 

이렇게 기존값에 str.concat("java");를 선언한다고 문자가 합쳐지지 않는다. 

 

이것은 불변 객체의 특성이 있기 때문이다.

package lang.string.immutable;
 public class StringImmutable2 {
     public static void main(String[] args) {
         String str1 = "hello";
         String str2 = str1.concat(" java");
         System.out.println("str1 = " + str1);
         System.out.println("str2 = " + str2);
} }

 

 

<실행 결과>

str1 = hello
 str2 = hello java

변경이 필요한 경우 기존 값을 변경하지 않고, 대신에 새로운 결과를 만들어서 반환한다.

 

 

그럼 왜 String이 불변으로 설계되었을까?

 

문자열 풀에 있는 `String` 인스턴스의 값이 중간에 변경되면 같은 문자열을 참고하는 다른 변수의 값도 함께 변경된다.

String은 자바 내부에 문자열 풀을 통해 최적화를 하도록 만들어졌다.

만약 String 내부의 값을 변경할 수 있다면, 기존의 문자열 풀에서 같은 문자를 참조하는 변수들도 함께 바뀐다.

그러면 사이드 이펙트 문제가 발생하기 때문에

변경된 내용은 새로운 참조값에 저장하도록 설계되었다. 

 

---

4. String 클래스 - 주요 메서드 1

주요 메서드 목록

 

4.1 문자열 정보 조회

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

- isEmpty() : 문자열이 비어있는지 확인

- isBlank() : 문자열이 비어있는지 확인 

- charAt(int index) : 지정된 인덱스에 있는 문자를 반환

 

4.2 문자열 비교

- equals(Object anObject) : 두 문자열이 동일한지 비교.

- equalsIgnoreCase(String anotherString) : 두 문자열을 대소문자 구분 없이 비교.

- compareTo(String anotherString) : 두 문자열을 사전 순으로 비교.

- compareToIgnoreCase(String str) : 두 문자열을 대소문자 구분 없이 사전적으로 비교.

- startsWith(String prefix) : 문자열이 특정 접두사로 시작하는지 확인

- endsWith(String suffix) : 문자열이 특정 접미사로 끝나는지 확인.

 

 

4.3 문자열 검색

- contains(CharSequence s) : 문자열이 특정 문자열을 포함하고 있는지 확인.

- indexOf(String ch)` / `indexOf(String ch, int fromIndex) : 문자열이 처음 등장하는 위치를 반환.

- lastIndexOf(String ch) : 문자열이 마지막으로 등장하는 위치를 반환

 

4.4 문자열 조작 및 반환

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

- concat(String str) : 문자열의 끝에 다른 문자열을 붙인다.

- replace(CharSequence target, CharSequence replacement) : 특정 문자열을 새 문자열로 대체.

- replaceAll(String regex, String replacement) : 문자열에서 정규 표현식과 일치하는 부분을 새 문자열로 대체.

- replaceFirst(String regex, String replacement) : 문자열에서 정규 표현식과 일치하는 첫 번째 부분을 새 문자열로 대체.

- toLowerCase() / toUpperCase() : 문자열을 소문자나 대문자로 반환.

- trim() : 문자열 양쪽 끝의 공백을 제거한다. 단순 Whitespace만 제거할 수 있다.

- strip() : Whitespace와 유니코드 공백을 포함해서 제거한다. 

 

4.5 문자열 분할 및 조합

- split(String regex) : 문자열을 정규 표현식을 기준으로 분할한다.

- join(CharSequence delimiter, CharSequence... elements)` : 주어진 구분자로 여러 문자열을

결합한다.

 

4.6 기타 유틸리티

- valueOf(Object obj): 다양한 타입을 문자열로 변환.

- toCharArray() : 문자열을 문자 배열로 반환.

- format(String format, Object... args)` : 형식 문자열과 인자를 사용하여 새로운 문자열을 생성한

다.

- matches(String regex)` : 문자열이 주어진 정규 표현식과 일치하는지 확인한다.

---

 

6. StringBuilder - 가변 String

불변인 String클래스의 단점. 

불변인 `String` 의 내부 값은 변경할 수 없다. 따라서 변경된 값을 기반으로 새로운 `String` 객체를 생성한다.

문자를 자주 더하거나 변경해야 하는 상황이라면 더 많은 `String` 객체를 만들고, GC해야 한다. 결과적으로 컴퓨터의 CPU, 메모리를 자원을 더 많이 사용하게 된다. 그리고 문자열의 크기가 클수록, 문자열을 더 자주 변경할수록 시스템의 자원을 더 많이 소모한다.

 

StringBuilder

자바는 `StringBuilder` 라는 가변 `String` 을 제공한다. 물론 가변의 경우 사이드 이펙 트에 주의해서 사용해야 한다.

 

StringBuilder 클래스 내부를 살펴볼까?

public final class StringBuilder { 

char[] value;// 자바 9 이전 
byte[] value;// 자바 9 이후

//여러 메서드
public StringBuilder append(String str) {...} 
public int length() {...}
...
}

`StringBuilder` 는 내부에 `final` 이 아닌 변경할 수 있는 `byte[]` 을 가지고 있다.

 

StringBuilder 사용 예

package lang.string.builder;
 public class StringBuilderMain1_1 {
     public static void main(String[] args) {
         StringBuilder sb = new StringBuilder();
         sb.append("A");
         sb.append("B");
         sb.append("C");
         sb.append("D");
         System.out.println("sb = " + sb);
         sb.insert(4, "Java");
         System.out.println("insert = " + sb);
         sb.delete(4, 8);
         
        System.out.println("delete = " + sb);
        sb.reverse();
        System.out.println("reverse = " + sb);
        
        //StringBuilder -> String
        String string = sb.toString();
        System.out.println("string = " + string);
    }
}

`StringBuilder` 객체를 생성한다.
`append()` 메서드를 사용해 여러 문자열을 추가한다. 

`insert()` 메서드로 특정 위치에 문자열을 삽입한다. 

`delete` () 메서드로 특정 범위의 문자열을 삭제한다. 

`reverse()` 메서드로 문자열을 뒤집는다.

마지막으로 `toString` 메소드를 사용해 `StringBuilder` 의 결과를 기반으로 `String` 을 생성해서 반환한다.

 

실행 결과

sb = ABCD
 insert = ABCDJava
delete = ABCD
 reverse = DCBA
string = DCBA
```

 

< StringBuilder를 직접 사용하는 것이 더 좋은 경우 >
- 반복문에서 반복해서 문자를 연결할 때
- 조건문을 통해 동적으로 문자열을 조합할 때
- 복잡한 문자열의 특정 부분을 변경해야 할 때
- 매우 긴 대용량 문자열을 다룰 때

 

---

7. 메서드 체인닝 - Method Chaining

 

package lang.string.chaining;
 public class ValueAdder {
 
    private int value;
    
    public ValueAdder add(int addValue) {
        value += addValue;
        return this;
}
    public int getValue() {
        return value;
} }

단순히 값을 누적해서 더하는 기능을 제공하는 클래스다.
`add()` 메서드를 호출할 때 마다 내부의 `value` 에 값을 누적한다.
`add()` 메서드를 보면 자기 자신( `this` )의 참조값을 반환한다. 이 부분을 유의해서 보자.

 

 package lang.string.chaining;
 public class MethodChainingMain1 {
     public static void main(String[] args) {
         ValueAdder adder = new ValueAdder();
         adder.add(1);
         adder.add(2);
         adder.add(3);
         int result = adder.getValue();
         System.out.println("result = " + result);
} }

 

실행 결과

result = 6

add()` 메서드를 여러번 호출해서 값을 누적해서 더하고 출력한다. 

여기서는 `add()` 메서드의 반환값은 사용하지 않았다.

 

 

이번에는 `add()` 메서드의 반환값을 사용해보자.

 package lang.string.chaining;
 
 public class MethodChainingMain2 {
     public static void main(String[] args) {
         ValueAdder adder = new ValueAdder();
         ValueAdder adder1 = adder.add(1);
         ValueAdder adder2 = adder1.add(2);
         ValueAdder adder3 = adder2.add(3);
         int result = adder3.getValue();
         System.out.println("result = " + result);
} }

 

실행 결과

result = 6

dder` , `adder1` , `adder2` , `adder3` 은 모두 같은 참조값을 사용한다. 

왜냐하면 `add()` 메서드가 자 기 자신( `this` )의 참조값을 반환했기 때문이다.

 

 

 

이번에는 방금 사용했던 방식에서 반환된 참조값을 새로운 변수에 담아서 보관하지 않고, 

대신에 바로 메서드 호출에 사용해보자.

 package lang.string.chaining;
 public class MethodChainingMain3 {
     public static void main(String[] args) {
         ValueAdder adder = new ValueAdder();
         int result = adder.add(1).add(2).add(3).getValue();
         System.out.println("result = " + result);
     }
}

 

실행 결과

result = 6

실행 순서

`add()` 메서드를 호출하면 `ValueAdder` 인스턴스 자신의 참조값( `x001` )이 반환된다.

 이 반환된 참조값을 변수에 담아두지 않아도 된다. 대신에 반환된 참조값을 즉시 사용해서 바로 메서드를 호출할 수 있다.

 

adder.add(1).add(2).add(3).getValue() //value=0
x001.add(1).add(2).add(3).getValue() //value=0, x001.add(1)을 호출하면 그 결과로 x001
을 반환한다.
x001.add(2).add(3).getValue() //value=1, x001.add(2)을 호출하면 그 결과로 x001을 반환한
다.
x001.add(3).getValue() //value=3, x001.add(3)을 호출하면 그 결과로 x001을 반환한다.
 x001.getValue() //value=6
6
```

메서드 호출의 결과로 자기 자신의 참조값을 반환하면, 반환된 참조값을 사용해서 메서드 호출을 계속 이어갈 수 있다. 

코드를보면 `.` 을 찍고 메서드를 계속 연결해서 사용한다.

마치 메서드가 체인으로 연결된 것 처럼 보인다.

이러한기법 을 메서드 체이닝이라 한다.
물론 실행 결과도 기존과 동일하다.

 

StringBuilder와 메서드 체인(Chain)

 

`StringBuilder` 의 `append()` 메서드를 보면 자기 자신의 참조값을 반환한다.

public StringBuilder append(String str) {
     super.append(str);
     return this;
}

 

StringBuilder` 에서 문자열을 변경하는 대부분의 메서드도 메서드 체이닝 기법을 제공하기 위해 자기 자신을 반환 한다.
예) `insert()` , `delete()` , `reverse()`

앞서 `StringBuilder` 를 사용한 코드는 다음과 같이 개선할 수 있다.

package lang.string.builder;
 public class StringBuilderMain1_2 {
     public static void main(String[] args) {
         StringBuilder sb = new StringBuilder();
         String string = sb.append("A").append("B").append("C").append("D")
                 .insert(4, "Java")
                 .delete(4, 8)
                 .reverse()
                 .toString();
         System.out.println("string = " + string);
     }
}

실행 결과

string = DCBA