StringBuilder와 StringBuffer의 차이점

질문자 :blacktiger

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

StringBuffer , 동기 StringBuilder 없습니다.

sblundy

StringBuilder synchronized 되지 않기 때문에 StringBuffer 보다 빠릅니다.

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

 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 .

polygenelubricants

기본적으로 StringBuffer 메서드는 동기화되지만 StringBuilder 는 동기화되지 않습니다.

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

그것에 대해 꽤 많이 있습니다.

StringBuilder API 에서 인용:

이 클래스 [StringBuilder]는 StringBuffer와 호환되는 API를 제공 하지만 동기화를 보장하지는 않습니다 . 이 클래스는 단일 스레드에서 문자열 버퍼를 사용하던 곳(일반적으로)에서 StringBuffer의 드롭인 대체품으로 사용하도록 설계되었습니다. 가능한 경우 대부분의 구현에서 이 클래스가 더 빠르기 때문에 StringBuffer보다 우선적으로 이 클래스를 사용하는 것이 좋습니다.

그래서 대신하게 되었습니다.

Vector 및 ArrayList 동일한 일이 발생했습니다.

OscarRyz

하지만 예제의 도움으로 명확한 차이를 얻을 필요가 있습니까?

StringBuffer 또는 StringBuilder

스레드 간에 버퍼를 공유하려는 경우가 아니면 StringBuilder 사용하십시오. StringBuilder 는 동기화되지 않은(더 적은 오버헤드 = 더 효율적인) 원래 동기화된 StringBuffer 클래스의 동생입니다.

StringBuffer 가 먼저 나왔습니다. Sun은 모든 조건에서 정확성을 고려했기 때문에 만일을 대비하여 스레드로부터 안전하도록 동기화했습니다.

StringBuilder 는 나중에 왔습니다. StringBuffer 사용의 대부분은 단일 스레드였으며 불필요하게 동기화 비용을 지불했습니다.

이후 StringBuilder 드롭에 대한 대체 StringBuffer 동기가없는 모든 실시 예 사이의 차이가 없을 것이다.

당신이 스레드간에 공유하려는 경우, 당신이 사용할 수있는 StringBuffer , 그러나 아마 대신 StringBuffer를 사용의 예를 들면, 높은 레벨의 동기화가 필요한지 여부를 고려, 당신은 모두 StringBuilder를 사용하는 방법을 동기화해야합니다.

Bert F

먼저 유사점을 살펴보겠습니다. StringBuilder와 StringBuffer는 모두 변경 가능합니다. 즉, 같은 위치에서 내용을 변경할 수 있습니다.

차이점 : StringBuffer는 변경 가능하고 동기화됩니다. StringBuilder는 변경 가능하지만 기본적으로 동기화되지 않습니다.

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

언제 어느 것을 사용해야합니까? StringBuilder : 수정할 수 있는 문자열이 필요하고 하나의 스레드만 해당 문자열에 액세스하고 수정하는 경우. StringBuffer : 수정할 수 있는 문자열이 필요하고 여러 스레드가 해당 문자열에 액세스하여 수정하는 경우.

참고 : StringBuffer를 불필요하게 사용하지 마십시오. 즉, CPU 시간을 불필요하게 차지하는 동기화를 위한 잠금 및 잠금 해제 코드가 많기 때문에 하나의 스레드만 수정하고 액세스하는 경우에는 사용하지 마십시오. 필요한 경우가 아니면 잠금을 사용하지 마십시오.

user1923551

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

다음은 내 테스트입니다(벤치마크가 아니라 테스트일 뿐입니다).

 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
버퍼: 23
빌더: 7!

따라서 빌더는 버퍼보다 빠르고 문자열 연결보다 빠릅니다. 이제 여러 스레드에 Executor 를 사용하겠습니다.

 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); } }

이제 StringBuffers 100000 추가를 위해 157 밀리 걸릴. 동일한 테스트는 아니지만 이전 37ms와 비교하여 StringBuffers 추가가 멀티스레딩 사용으로 더 느리다고 안전하게 가정할 수 있습니다. 그 이유는 JIT/hotspot/compiler/something이 잠금을 확인할 필요 가 없음을 감지할 때 최적화를 수행하기 때문입니다.

그러나 StringBuilder를 사용하면 java.lang.ArrayIndexOutOfBoundsException이 있습니다 . 동시 스레드가 추가해서는 안 되는 위치에 무언가를 추가하려고 하기 때문입니다.

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

Nicolas Zozol

StringBuilder는 Java 1.5에서 도입되었으므로 이전 JVM에서는 작동하지 않습니다.

Javadocs에서 :

StringBuilder 클래스는 StringBuffer와 호환되는 API를 제공하지만 동기화를 보장하지는 않습니다. 이 클래스는 단일 스레드에서 문자열 버퍼를 사용하던 곳(일반적으로)에서 StringBuffer의 드롭인 대체품으로 사용하도록 설계되었습니다. 가능한 경우 대부분의 구현에서 이 클래스가 더 빠르기 때문에 StringBuffer보다 우선적으로 이 클래스를 사용하는 것이 좋습니다.

Marc Novakowski

꽤 좋은 질문

차이점은 다음과 같습니다.

문자열 버퍼:-

 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)

스트링 빌더:-

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

일반적인 것 :-

둘 다 동일한 서명으로 동일한 방법을 사용합니다. 둘 다 변경 가능합니다.

Sireesh Yarlagadda

StringBuffer

• 동기화되어 스레드로부터 안전함
• 스레드 안전하므로 느림

StringBuilder

• 자바 5.0에 도입
• 비동기식이므로 빠르고 효율적입니다.
• 사용자는 원하는 경우 명시적으로 동기화해야 합니다.
• 다른 변경 없이 StringBuffer 대체할 수 있습니다.

JRomio

StringBuilder는 스레드로부터 안전하지 않습니다. 문자열 버퍼입니다. 추가 정보 여기 .

편집: 성능에 관해서는 핫스팟이 시작된 후 StringBuilder가 승자입니다. 그러나 작은 반복의 경우 성능 차이는 무시할 수 있습니다.

Learning

문자열 버퍼

StringBuffer는 변경 가능하다는 것은 객체의 값을 변경할 수 있음을 의미합니다. StringBuffer를 통해 생성된 객체는 heap에 저장된다. StringBuffer에는 StringBuilder와 동일한 메서드가 있지만 StringBuffer의 각 메서드는 동기화되어 StringBuffer가 스레드로부터 안전합니다.

이 때문에 두 개의 스레드가 동시에 동일한 메소드에 액세스하는 것을 허용하지 않습니다. 각 메소드는 한 번에 하나의 스레드에서 액세스할 수 있습니다.

그러나 스레드로부터 안전한 것은 스레드로부터 안전한 속성으로 인해 StringBuffer의 성능이 적중하기 때문에 단점도 있습니다. 따라서 StringBuilder는 각 클래스의 동일한 메서드를 호출할 때 StringBuffer보다 빠릅니다.

StringBuffer 값은 변경될 수 있으며 이는 새 값에 할당될 수 있음을 의미합니다. 요즘 가장 흔한 면접 질문인 위의 클래스 간의 차이점. 문자열 버퍼는 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

스트링 빌더

StringBuilder는 StringBuffer와 동일합니다. 즉, 객체를 힙에 저장하고 수정할 수도 있습니다. StringBuffer와 StringBuilder의 주요 차이점은 StringBuilder도 스레드로부터 안전하지 않다는 것입니다. StringBuilder는 스레드로부터 안전하지 않으므로 빠릅니다.

 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

리소스: 문자열 대 StringBuffer 대 StringBuilder

Afee

StringBuilder 와 StringBuffer 는 거의 동일합니다. 차이점은 StringBuffer 는 동기화되고 StringBuilder 는 동기화되지 않는다는 것입니다. 비록 StringBuilder 빠르게보다 StringBuffer , 성능 차이는 거의이다. StringBuilder 는 SUN이 StringBuffer 대체한 것입니다. 모든 공용 메서드에서 동기화를 방지합니다. 그 대신 기능은 동일합니다.

좋은 사용법의 예:

텍스트가 변경되고 여러 스레드에서 사용되는 경우 StringBuffer 를 사용하는 것이 좋습니다. 텍스트가 변경되지만 단일 스레드에서 사용되는 경우 StringBuilder 를 사용하십시오.

subodh ray

String 은 변경할 수 없습니다.

StringBuffer 는 변경 가능하고 동기화됩니다.

StringBuilder 도 변경 가능하지만 동기화되지 않습니다.

sudhakar

javadoc 은 차이점을 설명합니다.

이 클래스는 StringBuffer와 호환되는 API를 제공하지만 동기화를 보장하지는 않습니다. 이 클래스는 단일 스레드에서 문자열 버퍼를 사용하던 곳(일반적으로)에서 StringBuffer의 드롭인 대체품으로 사용하도록 설계되었습니다. 가능한 경우 대부분의 구현에서 이 클래스가 더 빠르기 때문에 StringBuffer보다 우선적으로 이 클래스를 사용하는 것이 좋습니다.

skaffman

StringBuilder (Java 5에서 도입됨)는 메서드가 동기화되지 않는다는 점을 제외하고 StringBuffer 이는 후자보다 성능이 더 우수하지만 스레드로부터 안전하지 않다는 단점이 있습니다.

자세한 내용은 튜토리얼 을 읽어보세요.

Sébastien Le Callonnec

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, ie * 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"); } } }

Kevin Lee

StringBuffer와 StringBuilder 소스의 차이점:

Zohra Khan

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

StringBuilder는 Java 5에 추가되었습니다. StringBuffer와 동기화되지 않는다는 점을 제외하면 모든 면에서 동일합니다. 즉, 여러 스레드가 동시에 액세스하면 문제가 발생할 수 있습니다. 단일 스레드 프로그램의 경우 가장 일반적인 경우 동기화 오버헤드를 피하면 StringBuilder가 약간 더 빨라집니다.

abhishek pathak

StringBuffer 동기화되어 있지만, StringBuilder 없습니다. 그 결과, StringBuilder 빠르게보다 StringBuffer .

Ahmad adawi

StringBuffer 는 변경 가능합니다. 길이와 내용이 변경될 수 있습니다. StringBuffers는 스레드로부터 안전합니다. 즉, 한 번에 하나의 스레드만 StringBuffer 개체의 동기화된 코드에 액세스할 수 있도록 액세스를 제어하는 동기화된 메서드가 있습니다. 따라서 StringBuffer 개체는 일반적으로 여러 스레드가 동일한 StringBuffer 개체에 동시에 액세스하려고 할 수 있는 다중 스레드 환경에서 사용하는 것이 안전합니다.

StringBuilder StringBuilder 클래스는 액세스가 동기화되지 않아 스레드로부터 안전하지 않다는 점을 제외하면 StringBuffer와 매우 유사합니다. 동기화되지 않음으로써 StringBuilder의 성능은 StringBuffer보다 나을 수 있습니다. 따라서 단일 스레드 환경에서 작업하는 경우 StringBuffer 대신 StringBuilder를 사용하면 성능이 향상될 수 있습니다. 이것은 StringBuilder 지역 변수(즉, 메서드 내의 변수)와 같이 하나의 스레드만 StringBuilder 개체에 액세스하는 것과 같은 다른 상황에서도 마찬가지입니다.

Android Genius

문자열 버퍼:

• 다중 스레드
• 동기화됨
• StringBuilder보다 느림

스트링 빌더

• 단일 스레드
• 동기화되지 않음
• 그 어느 때보다 빠른 String

Asif Mushtaq

문자열 빌더 :

 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);

StringBuffer보다 빠르기 때문에 가능하면 StringBuilder를 사용하는 것이 좋습니다. 그러나 스레드 안전성이 필요한 경우 가장 좋은 옵션은 StringBuffer 개체입니다.

Avinash

String 은 변경할 수 없는 객체이므로 값을 변경할 수 없는 반면 StringBuffer 는 변경할 수 있습니다.

StringBuffer 는 동기화되어 스레드로부터 안전하지만 StringBuilder 는 단일 스레드 인스턴스에만 적합하지 않고 적합합니다.

Ketan Patel

동기화 되지 않아 더 나은 성능을 제공하므로 StringBuilder 사용하는 것이 좋습니다. StringBuilder 는 이전 StringBuffer 의 드롭인 교체 입니다.

Niclas

StringBuffer 는 동기화되기 때문에 약간의 추가 노력이 필요하므로 성능에 따라 StringBuilder 보다 약간 느립니다.

Shuhail Kadavath

StringBuilder 와 StringBuffer 사이에는 기본적인 차이점이 없으며 단지 몇 가지 차이점만 있습니다. StringBuffer 에서 메서드가 동기화됩니다. 이것은 한 번에 하나의 스레드만 해당 스레드에서 작동할 수 있음을 의미합니다. 스레드가 두 개 이상인 경우 두 번째 스레드는 첫 번째 스레드가 완료될 때까지 기다려야 하고 세 번째 스레드는 첫 번째와 두 번째 스레드가 완료될 때까지 기다려야 하는 식입니다. 이것은 프로세스를 매우 느리게 만들고 따라서 StringBuffer 의 경우 성능이 낮습니다.

반면 StringBuilder 는 동기화되지 않습니다. 즉, 한 번에 여러 스레드가 동일한 StringBuilder 개체에서 동시에 작동할 수 있습니다. 이것은 프로세스를 매우 빠르게 만들고 따라서 StringBuilder 성능이 높습니다.

Pratik Paul

가장 큰 차이점은 StringBuffer 는 동기화되지만 StringBuilder 는 그렇지 않다는 것입니다. 둘 이상의 스레드를 사용해야 하는 경우 StringBuffer를 사용하는 것이 좋습니다. 그러나 실행 속도에 따라 StringBuilder 는 동기화되지 않기 때문에 StringBuffer 보다 빠릅니다.

JDGuide

의 동기화 APPEND 방법의 내부 점검 StringBuffer 와의 비 동기화 APPEND 방법 StringBuilder .

문자열 버퍼 :

 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; }

스트링 빌더 :

 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; }

추가가 synchronized StringBuffer 는 다중 스레딩 시나리오에서 StrinbBuilder 에 비해 성능 오버헤드가 있습니다. 여러 스레드 간에 버퍼를 공유하지 않는 한 추가 메서드에서 synchronized 되지 않기 때문에 빠른 StringBuilder

Ravindra babu

다음은 String 대 StringBuffer 대 StringBuilder 에 대한 성능 테스트 결과입니다. 마침내 StringBuilder가 테스트에서 승리했습니다. 테스트 코드 및 결과는 아래를 참조하십시오.

코드 :

 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

Ganesa Vijayakumar

• StringBuffer는 스레드로부터 안전하지만 StringBuilder는 스레드로부터 안전하지 않습니다.
• StringBuilder는 StringBuffer보다 빠릅니다.
• StringBuffer는 동기화되지만 StringBuilder는 동기화되지 않습니다.

Praveen Kishor

출처 : http:www.stackoverflow.com/questions/355089/difference-between-stringbuilder-and-stringbuffer