성능 벤치마킹: 문자열 및 문자열 빌더

이 기사에서는 Java에서 String 및 StringBuilder 클래스의 성능 벤치마킹을 수행하고 문자열을 효율적으로 수정하는 방법에 대해 설명합니다.

Java의 문자열은 변경할 수 없습니다. 문자열을 수정하면 최신 콘텐츠로 힙 메모리에 새 문자열 개체가 생성되며 원래 문자열은 절대 변경되지 않습니다.

불변성

  String str = "You cannot modify "
  str = str + "me"

str 변수에 "me"값을 추가하면 새 값You cannot modify me으로 새 String 객체가 생성되고 str에 할당됩니다. 원래 문자열You cannot modify은 변경되지 않습니다.

성능

+ 연산자를 사용하는 것과 같이 문자열을 자주 수정하면 상당한 성능 문제가 발생합니다. + 추가가 사용될 때마다 새 문자열 객체가 생성되고 재할당됩니다.

문자열을 효율적으로 수정하려면 문자열을 변경하고 힙 메모리에 추가 객체를 생성하지 않는 StringBuilder를 고려해야 합니다.

문자열 수정

문자열을 수정하려면 StringBuilder 클래스를 사용하십시오. 이것은 새로운 String 객체를 생성하는 것이 아니라 기존 객체를 변경합니다.

  StringBuilder str = new StringBuilder("You can modify.");
  str.append("me");

성능 벤치마킹

String 및 StringBuilder를 사용하여 concatenation 작업 성능 벤치마크를 고려하십시오. 다음을 고려하세요.

데이터 포인트 10개 고려

입력 샘플 =
[100k, 200k, 300k, 400k, 500k, 600k, 700k, 800k, 900k, 1m].

빈 문자열로 시작하여 문자열 "a"를 n번 연결합니다. 여기서 n = inputSample[i], 즉 n = 700k입니다.

String 및 StringBuilder를 사용하여 inputSample에 대해 문자열 "a"n 시간을 연결하는 데 걸리는 시간을 알고 싶습니다.

문자열 클래스

public class StringBenchmark {
    public static void main(String[] args) {
        String appendCharacter = "a";

        int inputSample[] = new int[]{
                100000, 200000, 300000, 400000,
                500000, 600000, 700000, 800000,
                900000, 1000000};

        for (int n : inputSample) {
            double startTime = System.nanoTime();
            testStringAppend(n, "", appendCharacter);
            double endTime = System.nanoTime();
            double duration = (endTime - startTime) / 1000000000;
            String seconds = String.format("%.2f", duration);
            System.out.println("n = " + n + ": seconds: " + seconds);
        }
    }

    static void testStringAppend(int n, String str, String appendCharacter) {
        for (int i = 1; i <= n; i++) {
            str += appendCharacter;
        }
    }
}

문자열 클래스 결과

n = 100000: seconds: 0.38
n = 200000: seconds: 0.99
n = 300000: seconds: 2.14
n = 400000: seconds: 3.74
n = 500000: seconds: 5.79
n = 600000: seconds: 8.28
n = 700000: seconds: 11.16
n = 800000: seconds: 14.65
n = 900000: seconds: 18.29
n = 1000000: seconds: 22.43

StringBuilder 클래스

public class StringBuilderBenchmark {
    public static void main(String[] args) {
        String appendCharacter = "a";

        int inputSample[] = new int[]{
                100000, 200000, 300000, 400000,
                500000, 600000, 700000, 800000,
                900000, 1000000};

        for(int n: inputSample){
            double startTime = System.nanoTime();
            testStringAppend(n, new StringBuilder(""), appendCharacter);
            double endTime = System.nanoTime();
            double duration = (endTime - startTime)/1000000000;
            String seconds = String.format("%.7f", duration);
            System.out.println("n = "+n+": seconds: "+seconds);
        }
    }
    static void testStringAppend(int n, StringBuilder str, String appendCharacter){
        for(int i = 1; i <= n; i++){
            str.append(appendCharacter);
        }
    }
}

n = 100000: seconds: 0.0027
n = 200000: seconds: 0.0013
n = 300000: seconds: 0.0015
n = 400000: seconds: 0.0015
n = 500000: seconds: 0.0018
n = 600000: seconds: 0.0022
n = 700000: seconds: 0.0026
n = 800000: seconds: 0.0029
n = 900000: seconds: 0.0032
n = 1000000: seconds: 0.0036

실행 시간: 추가

입력(n)
스트링(S)
문자열 작성기(S)


10만
0.38
0.0027

20만
0.99
0.0013

30만
2.14
0.0015

40만
3.74
0.0015

50만
5.79
0.0018

60만
8.28
0.0022

70만
11.16
0.0026

80만
14.65
0.0029

90만
18.29
0.0032

1m
22시 43분
0.0036

결론

StringBuilder는 concatenation 또는 modification 작업을 수행할 때 String 클래스보다 훨씬 빠르게 실행됩니다.

문자열을 수정하면 힙 메모리에 새 문자열이 생성됩니다. 문자열의 내용을 변경하려면 StringBuilder 클래스를 고려해야 합니다.

String 클래스를 수정하려고 하면 힙 메모리에 새 객체가 생성되어 성능이 크게 저하됩니다.

StringBuilder는 문자열 내용을 수정하는 데 적합합니다. 메모리에 추가 객체를 생성하지 않고 그렇게 합니다.