String Builder와 String Buffer의 차이점

String Builder와 String Buffer의 차이점

의 주요 차이점은 무엇입니까?StringBuffer ★★★★★★★★★★★★★★★★★」StringBuilder이 중 하나를 결정할 때 성능 문제가 있습니까?

StringBuffer 동기화되어 있지 않습니다.

StringBuilder 그렇지 않기 때문에 보다 빠르다synchronized.

다음은 간단한 벤치마크 테스트입니다.

public class Main {
    public static void main(String[] args) {
        int N = 77777777;
        long t;

        {
            StringBuffer sb = new StringBuffer();
            t = System.currentTimeMillis();
            for (int i = N; i --> 0 ;) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }

        {
            StringBuilder sb = new StringBuilder();
            t = System.currentTimeMillis();
            for (int i = N; i > 0 ; i--) {
                sb.append("");
            }
            System.out.println(System.currentTimeMillis() - t);
        }
    }
}

테스트 실행은 다음 수를 제공합니다.2241 ms★★★★★★에StringBuffer »753 ms★★★★★★에StringBuilder.

으로는 ★★★★★★★★★★★★★★★★★」StringBuffer되어 있습니다.StringBuilder렇지않않 않않않다다

조작은 거의 동일하지만 단일 스레드에서 동기화된 메서드를 사용하는 것은 과잉입니다.

거의 다 됐습니다.

String Builder API에서 인용:

이 클래스 [StringBuilder]는 StringBuffer와 호환되는 API를 제공하지만 동기화를 보장하지는 않습니다.이 클래스는 스트링 버퍼가 단일 스레드에 의해 사용되고 있던 장소에서 StringBuffer 드롭인 대체로 사용하도록 설계되어 있습니다(일반적으로 그렇습니다).가능한 경우 이 클래스는 대부분의 구현에서 더 빠르기 때문에 StringBuffer보다 우선적으로 사용할 것을 권장합니다.

그래서 그것을 대체하기 위해 만들어졌다.

일이 Vector ★★★★★★★★★★★★★★★★★」ArrayList.

하지만 예를 들어 명확한 차이를 알아내야 할까요?

String Buffer 또는 String Builder

'만들기'를 사용하세요.StringBuilder스레드 간에 버퍼를 공유하려는 경우를 제외하고요. StringBuilder 、 （ overhead더더더=더더더더더낮더더더더더더더더더더더더 is is is is is is is is is is is is is is is)의 비동기(낮은 효율)입니다.StringBuffer를 누릅니다

StringBuffer은 모든위해 했습니다.Sun은 모든 조건에서 정확성을 고려했기 때문에, 만약을 위해 스레드 세이프가 되도록 동기화했습니다.

StringBuilder나중에 왔어요.는 「 」입니다.StringBuffer단일 패킷으로 동기화 비용을 불필요하게 지불하고 있습니다.

★★StringBuilder의 드롭인 대체품입니다.StringBuffer동기화가 이루어지지 않으면 예시와 차이가 없습니다.

스레드 간에 공유하려고 할 수 있습니다.StringBuffer StringBuilder를

먼저 유사점을 살펴보겠습니다.String Builder와 String Buffer는 모두 가변입니다.즉, 같은 위치에 있는 로 이러한 컨텐츠의 내용을 변경할 수 있습니다.

차이점:StringBuffer는 가변 및 동기화도 가능합니다.여기서 String Builder는 변경 가능하지만 기본적으로는 동기화되지 않습니다.

동기화(동기화)의 의미:어떤 것이 동기화되면 여러 스레드가 액세스하여 문제나 부작용 없이 수정할 수 있습니다.StringBuffer는 동기화되어 있기 때문에 문제가 없는 여러 스레드와 함께 사용할 수 있습니다.

어떤 걸 언제 쓸까요?String Builder : 변경이 가능한 문자열이 필요한 경우, 1개의 스레드만 액세스하여 변경할 수 있습니다.StringBuffer : 문자열이 필요한 경우.이 문자열은 변경할 수 있으며 여러 스레드가 액세스하여 변경할 수 있습니다.

주의: String Buffer는 불필요하게 사용하지 마십시오.즉, 1개의 스레드만 변경 및 액세스 하고 있는 경우는 사용하지 마십시오.동기용 잠금/잠금 해제 코드가 많아 CPU 시간이 불필요하게 소요되기 때문입니다.필요한 경우가 아니면 자물쇠를 사용하지 마십시오.

단일 스레드에서 StringBuffer는 JVM 최적화 덕분에 StringBuilder보다 크게 느리지 않습니다.또한 멀티스레딩에서는 String Builder를 안전하게 사용할 수 없습니다.

다음은 테스트(벤치마크가 아닌 단순한 테스트)입니다.

public static void main(String[] args) {

    String withString ="";
    long t0 = System.currentTimeMillis();
    for (int i = 0 ; i < 100000; i++){
        withString+="some string";
    }
    System.out.println("strings:" + (System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuffer buf = new StringBuffer();
    for (int i = 0 ; i < 100000; i++){
        buf.append("some string");
    }
    System.out.println("Buffers : "+(System.currentTimeMillis() - t0));

    t0 = System.currentTimeMillis();
    StringBuilder building = new StringBuilder();
    for (int i = 0 ; i < 100000; i++){
        building.append("some string");
    }
    System.out.println("Builder : "+(System.currentTimeMillis() - t0));
}

★★★★★★★★★★★★★★
319740 (: 319740)
버퍼: 23
7!

따라서 빌더는 버퍼보다 빠르고 WAY는 문자열 연결보다 빠릅니다.이제 여러 스레드에 대해 실행자를 사용합니다.

public class StringsPerf {

    public static void main(String[] args) {

        ThreadPoolExecutor executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        //With Buffer
        StringBuffer buffer = new StringBuffer();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(buffer));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Buffer : "+ AppendableRunnable.time);

        //With Builder
        AppendableRunnable.time = 0;
        executorService = (ThreadPoolExecutor) Executors.newFixedThreadPool(10);
        StringBuilder builder = new StringBuilder();
        for (int i = 0 ; i < 10; i++){
            executorService.execute(new AppendableRunnable(builder));
        }
        shutdownAndAwaitTermination(executorService);
        System.out.println(" Thread Builder: "+ AppendableRunnable.time);

    }

   static void shutdownAndAwaitTermination(ExecutorService pool) {
        pool.shutdown(); // code reduced from Official Javadoc for Executors
        try {
            if (!pool.awaitTermination(60, TimeUnit.SECONDS)) {
                pool.shutdownNow();
                if (!pool.awaitTermination(60, TimeUnit.SECONDS))
                    System.err.println("Pool did not terminate");
            }
        } catch (Exception e) {}
    }
}

class AppendableRunnable<T extends Appendable> implements Runnable {

    static long time = 0;
    T appendable;
    public AppendableRunnable(T appendable){
        this.appendable = appendable;
    }

    @Override
    public void run(){
        long t0 = System.currentTimeMillis();
        for (int j = 0 ; j < 10000 ; j++){
            try {
                appendable.append("some string");
            } catch (IOException e) {}
        }
        time+=(System.currentTimeMillis() - t0);
    }
}

현재 String Buffer는 100000 adpends에 157 ms가 소요됩니다.같은 테스트는 아니지만, 이전 37밀리초와 비교하면 StringBuffers 추가 속도가 멀티스레딩 사용 시 느리다고 가정할 수 있습니다.그 이유는 JIT/hotspot/compiler/something이 잠금을 확인할 필요가 없음을 검출하면 최적화를 하기 때문입니다.

그러나 String Builder에서는 java.lang이 있습니다.ArrayIndexOutOfBoundsException.동시 스레드는 추가하지 말아야 할 곳에 추가하려고 하기 때문입니다.

결론은 String Buffers를 추적할 필요가 없다는 것입니다.그리고 스레드가 있는 곳에서는 몇 나노초를 얻기 전에 스레드가 무엇을 하고 있는지 생각해 보십시오.

String Builder는 Java 1.5에서 도입되었기 때문에 이전 JVM에서는 동작하지 않습니다.

자바독에서:

String Builder 클래스는 String Buffer와 호환되는 API를 제공하지만 동기화를 보장하지는 않습니다.이 클래스는 스트링 버퍼가 단일 스레드에 의해 사용되고 있던 장소에서 StringBuffer 드롭인 대체로 사용하도록 설계되어 있습니다(일반적으로 그렇습니다).가능한 경우 이 클래스는 대부분의 구현에서 더 빠르기 때문에 StringBuffer보다 우선적으로 사용할 것을 권장합니다.

꽤 좋은 질문

다음은 차이점입니다.

String Buffer :-

StringBuffer is  synchronized
StringBuffer is  thread-safe
StringBuffer is  slow (try to write a sample program and execute it, it will take more time than StringBuilder)

String Builder:-

 StringBuilder is not synchronized 
 StringBuilder is not thread-safe
 StringBuilder performance is better than StringBuffer.

공통점:-

둘 다 같은 시그니처로 같은 방식을 사용합니다.둘 다 변이 가능합니다.

StringBuffer

• 동기화된 스레드 세이프
• 나사산이 안전하므로 속도가 느리다.

StringBuilder

• Java 5.0에서 도입
• 비동기화가 가능하므로 빠르고 효율적입니다.
• 사용자가 원할 경우 사용자가 명시적으로 동기화해야 합니다.
• , 하다, 하다, 하다로 바꿀 수 요.StringBuffer이 없이

스트링 버퍼

StringBuffer는 가변입니다.즉, 객체의 값을 변경할 수 있습니다.StringBuffer를 통해 작성된 객체는 힙에 저장됩니다.StringBuffer의 메서드는 StringBuilder와 동일하지만 StringBuffer의 각 메서드는 동기화되어 StringBuffer는 스레드세이프입니다.

이 때문에, 2개의 스레드가 동시에 같은 메서드에 액세스 할 수 없습니다.각 메서드는 한 번에 1개의 스레드에 의해서 액세스 할 수 있습니다.

그러나 스레드 세이프 속성으로 인해 StringBuffer의 퍼포먼스가 히트하기 때문에 스레드 세이프도 단점이 있습니다.따라서 String Builder는 각 클래스의 동일한 메서드를 호출할 때 String Buffer보다 빠릅니다.

StringBuffer 값은 변경할 수 있습니다.즉, 새로운 값에 할당할 수 있습니다.현재 이것은 가장 일반적인 인터뷰 질문입니다.상기 클래스의 차이입니다.String Buffer는 toString() 메서드를 사용하여 문자열로 변환할 수 있습니다.

StringBuffer demo1 = new StringBuffer(“Hello”) ;
// The above object stored in heap and its value can be changed .

demo1=new StringBuffer(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuffer

String Builder

String Builder는 String Buffer와 동일합니다.즉, 객체는 힙에 저장되며 변경할 수도 있습니다.StringBuffer와 StringBuilder의 주요 차이점은 StringBuilder도 스레드 세이프가 아니라는 것입니다.String Builder는 스레드 세이프가 아니기 때문에 고속입니다.

StringBuilder demo2= new StringBuilder(“Hello”);
// The above object too is stored in the heap and its value can be modified

demo2=new StringBuilder(“Bye”);
// Above statement is right as it modifies the value which is allowed in the StringBuilder

자원:String vs String Buffer vs String Builder

StringBuilder는 스레드 세이프가 아닙니다.String Buffer는 다음과 같습니다.자세한 것은 이쪽.

편집: 퍼포먼스에 대해서는 핫스팟을 기동한 후 String Builder가 승자입니다.단, 반복 횟수가 적을 경우 성능 차이는 무시할 수 있습니다.

StringBuilder ★★★★★★★★★★★★★★★★★」StringBuffer거의 비슷해요. 점은 '하다'는 것입니다.StringBuffer되어 있습니다.StringBuilder렇지않않 않않않다다~는,StringBuilderStringBuffer퍼포먼스의 차이는 거의 없습니다. StringBuilder이 SUN을 한 것입니다.StringBuffer모든 공개 메서드에서 동기화되지 않도록 할 뿐입니다.이치노

좋은 사용 예:

스레드에서 에는 이 텍스트를 사용하는 .StringBuffer. 되는 경우 를 StringBuilder.

String불변의 존재입니다.

StringBuffer는 가변이며 동기화되어 있습니다.

StringBuilder 、 、 、 、 is is is is is is is is is is is is is is is is is is is is is is is is is 。

javadoc은 그 차이를 설명합니다.

이 클래스는 StringBuffer와 호환되는 API를 제공하지만 동기화를 보장하지는 않습니다.이 클래스는 스트링 버퍼가 단일 스레드에 의해 사용되고 있던 장소에서 StringBuffer 드롭인 대체로 사용하도록 설계되어 있습니다(일반적으로 그렇습니다).가능한 경우 이 클래스는 대부분의 구현에서 더 빠르기 때문에 StringBuffer보다 우선적으로 사용할 것을 권장합니다.

StringBuffer와 StringBuilder 소스의 차이:

StringBuilder5에서 는 (Java 5'와 )StringBuffer 그 dismited, synchronized.dismited, synchronized.dismited는 제외합니다.이는 후자보다 성능이 우수하다는 것을 의미하지만 스레드 세이프가 없다는 단점이 있습니다.

자세한 내용은 튜토리얼을 참조하십시오.

StringBuffer와 StringBuilder의 차이를 설명하는 간단한 프로그램:

/**
 * Run this program a couple of times. We see that the StringBuilder does not
 * give us reliable results because its methods are not thread-safe as compared
 * to StringBuffer.
 * 
 * For example, the single append in StringBuffer is thread-safe, i.e.
 * only one thread can call append() at any time and would finish writing
 * back to memory one at a time. In contrast, the append() in the StringBuilder 
 * class can be called concurrently by many threads, so the final size of the 
 * StringBuilder is sometimes less than expected.
 * 
 */
public class StringBufferVSStringBuilder {

    public static void main(String[] args) throws InterruptedException {

        int n = 10; 

        //*************************String Builder Test*******************************//
        StringBuilder sb = new StringBuilder();
        StringBuilderTest[] builderThreads = new StringBuilderTest[n];
        for (int i = 0; i < n; i++) {
            builderThreads[i] = new StringBuilderTest(sb);
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            builderThreads[i].join();
        }
        System.out.println("StringBuilderTest: Expected result is 1000; got " + sb.length());

        //*************************String Buffer Test*******************************//

        StringBuffer sb2 = new StringBuffer();
        StringBufferTest[] bufferThreads = new StringBufferTest[n];
        for (int i = 0; i < n; i++) {
            bufferThreads[i] = new StringBufferTest(sb2);
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].start();
        }
        for (int i = 0; i < n; i++) {
            bufferThreads[i].join();
        }
        System.out.println("StringBufferTest: Expected result is 1000; got " + sb2.length());

    }

}

// Every run would attempt to append 100 "A"s to the StringBuilder.
class StringBuilderTest extends Thread {

    StringBuilder sb;

    public StringBuilderTest (StringBuilder sb) {
        this.sb = sb;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb.append("A");
        }

    }
}


//Every run would attempt to append 100 "A"s to the StringBuffer.
class StringBufferTest extends Thread {

    StringBuffer sb2;

    public StringBufferTest (StringBuffer sb2) {
        this.sb2 = sb2;
    }

    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            sb2.append("A");
        }

    }
}

StringBuffer는 변경되는 문자열을 저장하기 위해 사용됩니다(String 객체는 변경할 수 없습니다).필요에 따라 자동으로 확장됩니다.관련 클래스:문자열, CharSequence.

Java 5에서 String Builder가 추가되었습니다.StringBuffer는 동기화되지 않는다는 점만 제외하고 모든 면에서 동일합니다.즉, 여러 스레드가 동시에 접근하면 문제가 발생할 수 있습니다.싱글 스레드 프로그램의 경우 가장 일반적인 경우로, 동기 오버헤드를 회피하면 String Builder가 매우 고속화됩니다.

StringBuffer동기하고 있습니다만,StringBuilder그렇지 않습니다.결과적으로.StringBuilder보다 빠르다StringBuffer.

String Buffer는 가변입니다.길이와 내용 면에서 달라질 수 있습니다.StringBuffer는 스레드 세이프입니다.이는 한 번에 하나의 스레드만 StringBuffer 객체의 동기화된 코드에 액세스할 수 있도록 접근을 제어하는 동기화된 메서드가 있음을 의미합니다.따라서 StringBuffer 객체는 여러 스레드가 동시에 동일한 StringBuffer 객체에 액세스하려고 하는 멀티 스레드 환경에서 사용하는 것이 일반적으로 안전합니다.

String Builder String Builder 클래스는 액세스가 동기화되지 않아 스레드 세이프가 아니라는 점을 제외하고는 String Buffer와 매우 유사합니다.동기화되지 않음으로써 String Builder의 성능이 String Buffer보다 향상될 수 있습니다.따라서 싱글 스레드 환경에서 작업하는 경우 StringBuffer 대신 StringBuilder를 사용하면 성능이 향상될 수 있습니다.이것은 StringBuilder 로컬 변수(메서드 내의 변수)와 같은 다른 상황에서도 해당됩니다.이 경우 스레드는 1개만 StringBuilder 객체에 액세스합니다.

String Buffer:

• 멀티 스레드
• 동기화됨
• String Builder보다 느림

String Builder

• 싱글 스레드
• 비동기화
• 지금까지 이상으로 빠른 문자열

String-Builder:

int one = 1;
String color = "red";
StringBuilder sb = new StringBuilder();
sb.append("One=").append(one).append(", Color=").append(color).append('\n');
System.out.print(sb);
// Prints "One=1, Colour=red" followed by an ASCII newline.

스트링 버퍼

StringBuffer sBuffer = new StringBuffer("test");
sBuffer.append(" String Buffer");
System.out.println(sBuffer);  

String Builder는 String Buffer보다 빠르기 때문에 가능한 한 String Builder를 사용하는 것이 좋습니다.단, 스레드의 안전성이 필요한 경우 StringBuffer 객체가 최선의 옵션입니다.

A String는 불변의 객체입니다.즉, 값은 변경할 수 없습니다.StringBuffer가변성이 있습니다.

StringBuffer, 즉 가 되어 .StringBuilder는 단일 세션인스턴스에만 적합하지 않습니다.

★★★★★★★★★를 사용하는 것이 좋다.StringBuilder동기화가 되지 않기 때문에 퍼포먼스가 향상됩니다. StringBuilder오래된 것을 대체한 것입니다.StringBuffer.

★★StringBuffer 때문에 약간의 '동기'보다 .따라서 퍼포먼스에 따라서는, 보다 조금 느립니다.StringBuilder.

.StringBuilder ★★★★★★★★★★★★★★★★★」StringBuffer 두 가지 밖에 없습니다 »StringBuffer메서드가 동기화됩니다. 한 할 수 있습니다.스레드가 여러 개 있는 경우 두 번째 스레드는 첫 번째 스레드가 완료될 때까지 대기하고 세 번째 스레드는 첫 번째 스레드와 두 번째 스레드가 완료될 때까지 대기해야 합니다.이로 인해 프로세스가 매우 느려지고, 따라서 다음과 같은 경우 퍼포먼스가 향상됩니다.StringBuffer습니니다

반,는StringBuilder동기화되지 않았습니다., 한 번에 의 스레드가 ,으로 동작할 수 있습니다.StringBuilder이치노에 의해, 「」의 , 「」의 가 향상됩니다.StringBuilder높은 수준입니다.

큰 차이는 ★★★★★★★★★★★★★★★★★★★★★★★★★★★」StringBuffer 있습니다만, 「동일화」되어 있습니다.StringBuilder렇지않않 않않않다다String Buffer로 지정합니다. ,에 행 but but but butStringBuilderStringBuffer되지 않았기 .roncronized。

동기화된 추가 메서드의 내부를 확인합니다.StringBuffer .StringBuilder.

String Buffer:

public StringBuffer(String str) {
    super(str.length() + 16);
    append(str);
}

public synchronized StringBuffer append(Object obj) {
    super.append(String.valueOf(obj));
    return this;
}

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

String Builder:

public StringBuilder(String str) {
    super(str.length() + 16);
    append(str);
}

public StringBuilder append(Object obj) {
    return append(String.valueOf(obj));
}

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

는 append이므로synchronized,StringBuffer .StrinbBuilder티캐멀스레드 한, 「」를 합니다.StringBuilder이 동작은, 가 없기 때문에 고속입니다.synchronized추가 메서드로.

다음은 String vs String Buffer vs String Builder 성능 테스트 결과입니다.마지막으로 String Builder가 테스트에서 승리했습니다.테스트 코드 및 결과는 아래를 참조하십시오.

코드:

private static void performanceTestStringVsStringbuffereVsStringBuilder() {
// String vs StringBiffer vs StringBuilder performance Test

int loop = 100000;
long start = 0;

// String
String str = null;
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
  str += i + "test";
}
System.out.println("String - " + (System.currentTimeMillis() - start) + " ms");

// String buffer
StringBuffer sbuffer = new StringBuffer();
start = System.currentTimeMillis();
for (int i = 1; i <= loop; i++) {
  sbuffer.append(i).append("test");
}
System.out.println("String Buffer - " + (System.currentTimeMillis() - start) + " ms");

// String builder
start = System.currentTimeMillis();
StringBuilder sbuilder = new StringBuilder();
for (int i = 1; i <= loop; i++) {
  sbuffer.append(i).append("test");
}
System.out.println("String Builder - " + (System.currentTimeMillis() - start) + " ms");

  }

ideone에서 실행

결과:

단일 텍스트 추가를 위한 100000 반복

String - 37489 ms
String Buffer - 5 ms
String Builder - 4 ms

단일 텍스트 추가를 위한 10000회 반복

String - 389 ms
String Buffer - 1 ms
String Builder - 1 ms

• StringBuffer는 스레드 세이프이지만 StringBuilder는 스레드 세이프가 아닙니다.
• String Builder가 String Buffer보다 빠릅니다.
• String Builder는 동기화되어 있지만 String Builder는 동기화되어 있지 않습니다.

언급URL : https://stackoverflow.com/questions/355089/difference-between-stringbuilder-and-stringbuffer