String, StringBuffer, StringBuilder 문자열을 다루는 자료형 비교 분석 총정리

문자열을 다루는 자료형에 대해서 알아보도록 하자.

 

📌 가변 vs 불변

String은 불변 객체이다.

기본적으로 String은 자바에서 값을 변경할 수 없다.

즉, 한번 생성되면 할당된 메모리 공간이 변하지 않는 불변 객체(Immutable)라는 것이다.

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence,
               Constable, ConstantDesc {

    private final byte[] value;
}

실제 자바에서 String 내부 구현 코드를 봐도 알 수 있다.

인스턴스 생성 시 생성자의 매개변수로 입력받는 문자열은 value라는 인스턴스 변수에 문자열 배열로 저장된다.

value 변수는 코드에서 알 수 있듯이 final. 즉, 상수형으로 선언되어있으니 값을 바꾸지 못한다.

 

💡 Tip

Java 9 부터 char[] 형이 아닌 byte[] 형으로 바뀌었다.
문자열은 Latin-1(1byte)으로 표현되는 경우와 그렇지 않은 경우 UTF-16(2byte)로 나누어진다.
자바의 문자열은 기본적으로 유니코드를 지원하기 때문에 영어를 쓰면 1byte로 표현이 가능하다.
근데 char[]형은 기본 2byte이기 때문에, 쓸데없는 메모리 낭비가 있었다.
이를 char[](2byte) -> byte[](1byte) 로 바꾸는 Compact Strings라는 옵션으로 공간 효율을 높였다.

 

String 값 조작

String str = "hello";
str = str + " world";

System.out.println(str); // hello world

concat 메서드 혹은 + 연산자를 통해 기존 문자열("hello")에 새로운 문자열(" world")을 붙인다고 가정하자.

이 코드는 내부적으로 새로운 String 객체를 생성해서 새로운 문자열을 저장하고, 이 새로 생성된 객체를 참조하도록 구현된다.

위의 그림처럼 코드상으로는 마치 문자열을 편집한 듯 보이지만, 내부 동작상으로는 전혀 아니다.

즉, 문자열을 조작(추가,수정,삭제)하는 일이 많으면 Heap 메모리를 낭비하게되고, GC의 작업을 추가시켜 앱의 성능을 하락시키는 일이 된다.

 

 

String이 불변이어서 좋은 점 3가지

1. 캐싱 : String literal로 생성한 객체의 "값"은 String pool이라는 곳으로 들어가게 된다. (객체는 stack영역에 존재) String literal로 생성한 객체가 이미 String pool에 존재 한다면, 이 값을 reference하기 때문에 힙 메모리 영역을 절약할 수 있다. 다만, new 연산자로 생성하면 힙 메모리에 인스턴스를 무조건 생성하게 되므로 주의한다.
2. 보안 : 데이터베이스의 사용자 이름이나 암호 등을 파라미터로 주고 받을 때 문자열 값이 변경가능하면 중간에 해커가 참조값을 변경해서 보안 문제를 일으킬 수 있다.
3. 동기화 : 불변하기 때문에 동시에 실행되는 여러 스레드에서 안정적이게 공유가 가능하다. (Thread-Safe)

 

StringBuffer / StringBuilder는 가변 객체이다.

StringBuffer와 StringBuilder의 공통적인 부분을 먼저 알아보고 차이는 뒤에 알아보도록 하겠다.

별도의 설명이 없다면 공통적인 부분이다.

문자열 데이터를 다룬다는 점에서 String 객체와 비슷하지만, 내부적으로 버퍼라는 독립적인 공간을 두고 객체의 공간이 부족해지는 경우 버퍼의 크기를 유연하게 늘려준다. 즉, 가변(Mutable)적이다.

public final class StringBuffer
    extends AbstractStringBuilder
    implements Serializable, Comparable<StringBuffer>, CharSequence

StringBuffer는 AbstractStringBuilder라는 것을 상속 받고 있다. 

abstract class AbstractStringBuilder implements Appendable, CharSequence {
    byte[] value;

    byte coder;
}

여기서 보면 final로 선언되지 않은 것을 볼 수 있다. -> 값을 변경할 수 있다.

내부적으로 capacity(버퍼의 크기)를 16으로 두고, 공간이 부족할 경우 이 버퍼의 크기를 늘린다.

StringBuffer stringBuffer = new StringBuffer();
System.out.println(stringBuffer.capacity()); // 16


stringBuffer.append("cat11111111111111");
System.out.println(stringBuffer.capacity()); // 34

 

StringBuffer / StringBuilder의 값 조작

StringBuffer sb= new StringBuffer("hello");
sb.append(" world");

 

StringBuffer와 StringBuilder는 append()나 delete()와 같은 메서드를 통해 동일 객체 내에서 문자열을 변경하는 것이 가능하다.

위의 그림과 같이 메모리에 따로 인스턴스를 생성하는 것이 아니라 그 인스턴스의 값을 변경하기 때문에 문자열의 조작(추가, 수정, 삭제) 시에 새로운 객체를 매번 생성해내는 String보다 빠를 수 있게 되는 것이다.

다만, 조작할 필요가 없는 모든 String을 StringBuffer로 처리하는 것은 성능에 좋지 않다.

String은 단순히 상수문자열만 갖고 있으면 되는 반면에, StringBuffer/StringBuilder는 버퍼의 크기를 조작하고, 다양한 추가 메서드를 제공하는 만큼 내부 동작이 더 복잡하기 때문이다.

 

 

📌  StringBuffer vs StringBuilder

StringBuffer와 StringBuilder는 제공하는 메서드, 사용법도 동일하고 크긱가 유연하게 변한다는 가변적 특징도 동일하다.

이 둘의 차이는 동기화의 유무이다. 즉, 멀티 쓰레드 환경에서 안전하냐 아니냐가 그 근간이다. ( Thread-Safe or Not )

StringBuffer는 Thread-Safe하다.

// StringBuffer.append()
@Override
public synchronized StringBuffer append(String str) {
  toStringCache = null;
  super.append(str);
  return this;
}

StringBuffer의 내부 코드를 보면 자바의 synchronized 키워드를 이용해 멀티스레드의 동기화. 즉, thread-safe를 보장한다.

 

💡 Tip

Java에서 synchronized 키워드는 여러개의 스레드가 한 개의 자원에 접근하려고 할 때, 현재 데이터를 사용하고 있는 스레드를 제외하고 나머지 스레드들이 데이터에 접근할 수 없도록 막는 역할을 한다.

 

StringBuilder는 Thread Unsafe 하다.

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

 

StringBuilder의 내부 코드를 보면 알 수 있듯이 동기화 관련 키워드가 없다.

 

이처럼 쓰레드 안정성을 보장하지 않을 경우, [쓰레드1]이 문자열 값을 변경하는 도중에 [쓰레드2]가 접근하여 이상한 값을 가져간다든가, 동시에 접근해서 [쓰레드1]이 수정한 값은 무시하고 값을 덮어씌우는 등 심각한 오류가 발생할 수 있다.

 

멀티 쓰레드 환경에서 연산 결과 확인

두 개의 쓰레드에서 각각 1만번 더하는 로직을 수행해보자.

StringBuffer stringBuffer = new StringBuffer();
StringBuilder stringBuilder = new StringBuilder();

new Thread(() -> {
    for(int i=0; i<10000; i++) {
        stringBuffer.append(1);
        stringBuilder.append(1);
    }
}).start();

new Thread(() -> {
    for(int i=0; i<10000; i++) {
        stringBuffer.append(1);
        stringBuilder.append(1);
    }
}).start();

new Thread(() -> {
    try {
        Thread.sleep(2000);

        System.out.println("StringBuffer.length: "+ stringBuffer.length()); // thread safe 함
        System.out.println("StringBuilder.length: "+ stringBuilder.length()); // thread unsafe 함
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}).start();

쓰레드 안정성이 보장된 StringBuffer는 예상대로 20000이 된 걸 확인할 수 있다.

반면에 StringBuilder는 약 800개의 연산이 수행되지 않음을 확인할 수 있다.

 

 

📌 순수 성능 비교

 

String, StringBuffer, StringBuilder의 순수한 성능 비교를 해보도록 하겠다.

50만번을 루프해서 '*'문자열을 추가하는 로직을 테스트 해보겠다.

final int lengths = 500000;

// ------------- (1) String의 +연산을 이용해서 500,000개의 *를 이어 붙인다.
long startTime1 = System.currentTimeMillis(); // 시작시간을 기록 (millisecond단위)

String str="";
for(int i=0;i<lengths;i++){
    str=str+"*";
}

long endTime1 = System.currentTimeMillis(); // 종료시간을 기록(millisecond단위)


// ------------- (2) StringBuffer를 이용해서 500,000개의 *를 이어붙인다.
long startTime2 = System.currentTimeMillis();

StringBuffer sb = new StringBuffer();
for(int i=0;i<lengths;i++){
    sb.append("*");
}

long endTime2 = System.currentTimeMillis();


// ------------- (3) StringBuilder를 이용해서 500,000개의 *를 이어붙인다.
long startTime3 = System.currentTimeMillis();

StringBuilder sb2 = new StringBuilder();
for(int i=0;i<lengths;i++){
    sb2.append("*");
}

long endTime3 = System.currentTimeMillis();


// ------------- 방법(1), 방법(2), 방법(3)가 걸린 시간을 비교
long duration1 = endTime1 - startTime1;
long duration2 = endTime2 - startTime2;
long duration3 = endTime3 - startTime3;

System.out.println("String의 +연산을 이용한 경우 : "+ duration1); // 6309
System.out.println("StringBuffer의 append()을 이용한 경우 : "+ duration2); // 9
System.out.println("StringBuilder의 append()을 이용한 경우 : "+ duration3); // 4

String의 +연산을 이용한 경우 : 6309
StringBuffer의 append()을 이용한 경우 : 9
StringBuilder의 append()을 이용한 경우 : 4

결과를 보면 StringBuilder가 기본 성능은 좋다는 것을 알 수 있다.

StringBuffer는 동기화를 위해 추가적인 작업이 들어가기 때문에 아무래도 시간이 더 걸리는 것이다.

이런 이유로 String에서는 컴파일 시점에 '+'연산이 StringBuilder로 자동 치환된다.

 

💡 Tip

Java 1.5 이후의 String 덧셈 연산은 컴파일 시 전부 StringBuilder 치환된다는 얘기다.

String a = "hello" + "world";
/* 는 아래와 같다. */
String a = new StringBuilder("hello").append("world").toString(); 
// StringBuilder를 통해 "hello" 문자열을 생성하고 "world"를 추가하고 toString()을 통해 String 객체로 변환하여 반환

즉 이런 식으로 바뀐다는 것이다.

따라서 많은 덧셈 연산을 해야할 경우에 +를 계속 쓰는 경우, 어차피 StringBuilder로 바꿔주고, 객체 생성하고 등등 불필요한 작업이 생기므로, 애초에 StringBuilder로 생성해서 append()하는 게 낫다.

 

📌  최종 정리

	String	StringBuffer	StringBuilder
스토리지 위치	Constant String Pool	Heap	Heap
가변 여부	불변	가변	가변
쓰레드 안정성	O	O	X
연산 속도	느림	빠른	매우 빠름
사용 시점	문자열 연산이 적고, 멀티스레드 환경일 경우	문자열 조작(추가,수정,삭제)이 빈번할 경우, 멀티 스레드 환경에서 스레드 세이프가 필요할 경우	문자열 조작(추가,수정,삭제)이 빈번할 경우, 단일 쓰레드일 경우, 빠른 연산이 필요할 경우

 

 

 

📌 Ref

https://inpa.tistory.com/entry/JAVA-%E2%98%95-String-StringBuffer-StringBuilder-%EC%B0%A8%EC%9D%B4%EC%A0%90-%EC%84%B1%EB%8A%A5-%EB%B9%84%EA%B5%90

https://starkying.tistory.com/entry/what-is-java-string-pool

https://medium.com/@vivekbansal1011/whats-synchronization-in-java-how-does-it-work-9a86db65f702

https://stackoverflow.com/questions/32714194/where-is-implemented-for-strings-in-the-java-source-code

https://jiwondev.tistory.com/116