Różnica między StringBuilder i StringBuffer

StringBuilder jest szybszy niż StringBuffer bo to nie synchronized.

Oto prosty test porównawczy:

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

A test run daje liczby 2241 ms dla StringBuffer vs 753 ms dla StringBuilder.

Zasadniczo, StringBuffer metody są zsynchronizowane, podczas gdy StringBuilder nie są.

Operacje są "prawie" takie same, ale używanie metod zsynchronizowanych w jednym wątku jest przesadą.

To mniej więcej o tym.

Cytat z StringBuilder API :

Ta klasa [StringBuilder] dostarcza API kompatybilne z StringBuffer, ale bez gwarancji synchronizacji. Ta klasa jest przeznaczona do użytku jako zamiennik StringBuffer w miejsca, w których bufor Łańcuchowy był używany przez pojedynczy wątek (jak to zwykle bywa). Jeśli to możliwe, zaleca się użycie tej klasy zamiast StringBuffer, ponieważ będzie ona szybsza w większości implementacji.

Więc został stworzony, aby go zastąpić.

To samo stało się z Vector i ArrayList.

Ale potrzebne, aby uzyskać wyraźną różnicę za pomocą przykładu?

StringBuffer lub StringBuilder

po prostu użyj StringBuilder, chyba że naprawdę próbujesz udostępnić bufor między wątkami. StringBuilder jest unsynchronized (less overhead = more efficient) młodszy brat oryginalnej zsynchronizowanej klasy StringBuffer.

StringBuffer był pierwszy. Sun dbał o poprawność w każdych warunkach, więc zsynchronizowali ją z zrób to na wszelki wypadek.

StringBuilder przyszedł później. Większość zastosowań StringBuffer Była jednowątkowa i niepotrzebnie ponosiła koszty synchronizacji.

Ponieważ StringBuilder jest wymiana drop-in dla StringBuffer bez synchronizacji nie byłoby różnic między przykładami.

Jeśli próbujesz współdzielić wątki, możesz użyć StringBuffer, ale zastanów się, czy konieczna jest synchronizacja wyższego poziomu, np. być może zamiast używać StringBuffer, powinieneś zsynchronizować metody, które używają Stringbuildera.

Najpierw zobaczmy podobieństwa : Zarówno StringBuilder, jak i StringBuffer są mutowalne. Oznacza to, że możesz zmienić ich zawartość, w tym samym miejscu.

Różnice : StringBuffer jest również zmienny i zsynchronizowany. Gdzie jako StringBuilder jest zmienny, ale domyślnie nie jest zsynchronizowany.

Znaczenie synchronized (synchronizacja) : Kiedy coś jest zsynchronizowane, wtedy wiele wątków może uzyskać dostęp i zmodyfikować go bez żadnego problemu lub po stronie efekt. StringBuffer jest zsynchronizowany, więc możesz go używać z wieloma wątkami bez żadnego problemu.

Którego użyć kiedy? StringBuilder: gdy potrzebujesz ciągu, który można modyfikować, a tylko jeden wątek ma dostęp i modyfikuje go. StringBuffer: gdy potrzebujesz ciągu, który można modyfikować, a wiele wątków uzyskuje dostęp i modyfikuje go.

Uwaga: nie używaj StringBuffer niepotrzebnie, tzn. nie używaj go, jeśli tylko jeden wątek jest modyfikowany i dostęp do niego, ponieważ ma dużo kodu blokującego i odblokowującego do synchronizacji, co niepotrzebnie zajmie czas procesora. Nie używaj zamków, chyba że jest to wymagane.

W pojedynczych wątkach, StringBuffer nie jest znacząco wolniejszy niż StringBuilder , dzięki OPTYMALIZACJOM JVM. A w wielowątkowości nie można bezpiecznie używać Stringbuildera.

Oto mój test:

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

Wyniki:
stringi: 319740
Bufory : 23
Budowniczy: 7 !

Więc budowniczowie są szybsi od buforów i znacznie szybsi od konkatenacji strun. Teraz użyjmy Executor dla wielu wątków:

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

Teraz StringBuffers weź 157 ms na 100000 załączników. To nie jest ten sam test, ale w porównaniu z poprzednimi 37 ms, można bezpiecznie założyć, że StringBuffers appends są wolniejsze przy użyciu wielowątkowości. Powodem jest to, że JIT/hotspot/compiler/something tworzy optymalizacje, gdy wykryje, że nie ma potrzeby sprawdzania blokad.

Ale z Stringbuilderem, masz Javę.lang.ArrayIndexOutOfBoundsException , ponieważ współbieżny wątek próbuje dodać coś tam, gdzie nie powinno.

Wniosek jest taki, że nie musisz gonić za Stringbufferami. A jeśli masz wątki, pomyśl o tym, co robią, zanim spróbujesz uzyskać kilka nanosekund.

StringBuilder został wprowadzony w Javie 1.5, więc nie będzie działał z wcześniejszymi systemami JVMs.

Z Javadocs :

Klasa StringBuilder dostarcza API kompatybilne z StringBuffer, ale bez gwarancji synchronizacji. Klasa ta jest przeznaczona do użycia jako zamiennik StringBuffer w miejscach, w których bufor łańcuchów był używany przez pojedynczy wątek (jak to zwykle bywa). Tam, gdzie to możliwe, zaleca się, aby klasa ta była używana zamiast StringBuffer, ponieważ będzie szybszy w większości implementacji.

Całkiem Dobre Pytanie

Oto różnice, które zauważyłem:

StringBuffer:-

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:-

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

Wspólna rzecz:-

Obie mają te same metody z tymi samymi podpisami. Oba są mutowalne.

StringBuilder nie jest bezpieczny dla wątków. String Buffer jest. Więcej informacji tutaj .

EDIT: jeśli chodzi o wydajność, po tym jak hotspot zacznie działać , StringBuilder wygrywa. Jednak w przypadku małych iteracji różnica w wydajności jest znikoma.

StringBuilder i StringBuffer są prawie takie same. Różnica polega na tym, że StringBuffer jest zsynchronizowana, a StringBuilder nie. Chociaż StringBuilder jest szybszy niż StringBuffer, różnica w wydajności jest bardzo niewielka. StringBuilder jest zamiennikiem Słońca StringBuffer. To po prostu unika synchronizacji ze wszystkimi metodami publicznymi. Zamiast tego, ich funkcjonalność jest taka sama.

Przykład dobrego użycia:

Jeśli Twój tekst ma się zmienić i jest używany przez wiele wątków, lepiej jest użyć StringBuffer. Jeśli tekst się zmieni, ale jest używany przez pojedynczy wątek, następnie użyj StringBuilder.

StringBuffer

StringBuffer jest zmienny oznacza, że można zmienić wartość obiektu . Obiekt utworzony przez StringBuffer jest przechowywany w stercie. StringBuffer ma te same metody co StringBuilder, ale każda metoda w StringBuffer jest zsynchronizowana, co oznacza, że StringBuffer jest bezpieczny dla wątku .

Z tego powodu nie pozwala dwóm wątkom na jednoczesny dostęp do tej samej metody . Każda metoda może być dostępna po jednym wątku na raz .

Ale bycie thread safe ma również wady, ponieważ wydajność StringBuffer uderza z powodu właściwości thread safe . W ten sposób StringBuilder jest szybszy niż StringBuffer podczas wywoływania tych samych metod każdej klasy.

Wartość StringBuffer można zmienić , to znaczy, że można ją przypisać do nowej wartości . Obecnie jest to najczęstsze pytanie o wywiad, różnice między powyższymi klasami . Bufor Łańcuchowy można przekonwertować na łańcuch za pomocą toString() metoda.

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

StringBuilder jest taki sam jak StringBuffer , czyli przechowuje obiekt w stercie i może być również modyfikowany . Główną różnicą między StringBuffer i StringBuilder jest to, że StringBuilder nie jest również bezpieczny dla wątków. StringBuilder jest szybki, ponieważ nie jest bezpieczny dla wątków .

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

Resource: String Vs StringBuffer Vs StringBuilder

StringBuffer

• Synchronized threadsafe
• thread safe though slow
-

StringBuilder

• wprowadzone w Javie 5.0
• asynchroniczny, szybki i wydajny
• użytkownik wyraźnie musi ją zsynchronizować, jeśli chce
• możesz go zastąpić StringBuilder bez żadnych innych zmian

String jest niezmienny.

StringBuffer jest zmienny i zsynchronizowany.

StringBuilder jest również zmienny, ale nie jest zsynchronizowany.

Javadoc wyjaśnia różnicę:

Ta klasa dostarcza API kompatybilne z StringBuffer, ale bez gwarancji synchronizacji. Klasa ta jest przeznaczona do użycia jako zamiennik StringBuffer w miejscach, w których bufor łańcuchów był używany przez pojedynczy wątek (jak to zwykle bywa). Tam, gdzie to możliwe, zaleca się użycie tej klasy zamiast StringBuffer, ponieważ będzie ona szybsza w większości implementacji.

StringBuilder (wprowadzony w Javie 5) jest identyczny z StringBuffer, z tym że jego metody nie są zsynchronizowane. Oznacza to, że ma lepszą wydajność niż ten drugi, ale wadą jest to, że nie jest bezpieczny dla nici.

Przeczytaj tutorial aby uzyskać więcej szczegółów.

StringBuilder jest znacznie szybszy niż StringBuffer, ponieważ nie jest zsynchronizowany.

Tutaj masz więcej informacji na temat kosztów synchronizacji

Spójrzmy programowo ile StringBuilder jest szybszy niż StringBuffer

public class Test{  
 public static void main(String[] args){  
    long startTime = System.currentTimeMillis();  
    StringBuffer sb = new StringBuffer("Yasir");  
    for (int i=0; i<10000; i++){  
        sb.append("Shabbir");  
    }  
    System.out.println("Time taken by StringBuffer: " + (System.currentTimeMillis() - startTime) + "ms");  
    startTime = System.currentTimeMillis();  
    StringBuilder sb2 = new StringBuilder("Yasir");  
    for (int i=0; i<10000; i++){  
        sb2.append("Shabbir");  
    }  
    System.out.println("Time taken by StringBuilder: " + (System.currentTimeMillis() - startTime) + "ms");  
}  
}  

OutPut

Time taken by StringBuffer: 16ms

Time taken by StringBuilder: 0ms

Prosty program obrazujący różnicę między StringBuffer i 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");
        }

    }
}

Lepiej używać Stringbuildera, ponieważ nie jest zsynchronizowany i do tego lepsza wydajność. StringBuilder jest zastąpieniem starszego Stringbuffera.

StringBuffer jest zsynchronizowany, ale StringBuilder nie jest. W rezultacie StringBuilder jest szybszy niż StringBuffer.

StringBuffer jest zmienny. Może się zmieniać pod względem długości i treści. Stringbuffery są bezpieczne dla wątków, co oznacza, że mają zsynchronizowane metody Kontroli Dostępu, tak aby tylko jeden wątek mógł uzyskać dostęp do zsynchronizowanego kodu obiektu StringBuffer na raz. Tak więc obiekty StringBuffer są na ogół bezpieczne w środowisku wielowątkowym, w którym wiele wątków może próbować uzyskać dostęp do tego samego obiektu StringBuffer w tym samym czasie.

StringBuilder Na Klasa StringBuilder jest bardzo podobna do StringBuffer, z tym wyjątkiem, że jej dostęp nie jest zsynchronizowany, więc nie jest bezpieczny dla wątków. Nie będąc zsynchronizowanym, wydajność StringBuilder może być lepsza niż StringBuffer. Tak więc, jeśli pracujesz w środowisku jednowątkowym, użycie StringBuilder zamiast StringBuffer może spowodować zwiększenie wydajności. Dotyczy to również innych sytuacji, takich jak zmienna lokalna StringBuilder (czyli zmienna w metodzie), w której tylko jeden wątek będzie uzyskiwanie dostępu do obiektu StringBuilder.

StringBuffer

StringBuffer jest zmienny oznacza, że można zmienić wartość obiektu . Obiekt utworzony przez StringBuffer jest przechowywany w stercie. StringBuffer ma te same metody co StringBuilder, ale każda metoda w StringBuffer jest zsynchronizowana, co oznacza, że StringBuffer jest bezpieczny dla wątku .

StringBuilder

StringBuilder jest taki sam jak StringBuffer, czyli przechowuje obiekt w stercie i może być również modyfikowany . Główna różnica pomiędzy StringBuffer i StringBuilder jest to, że StringBuilder nie jest bezpieczny dla wątku. StringBuilder jest szybki, ponieważ nie jest bezpieczny dla wątków .

StringBuffer:

• Wielowątkowa
• zsynchronizowane
• Slow than StringBuilder

StringBuilder

• Jednowątkowa
• Nie-Zsynchronizowane
• Faster than ever String

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.

String-Buffer

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

Zaleca się używanie Stringbuildera, gdy jest to możliwe, ponieważ jest szybszy niż StringBuffer. Jeśli jednak konieczne jest zabezpieczenie wątku, najlepszą opcją są obiekty StringBuffer.

StringBuffer jest używany do przechowywania łańcuchów znaków, które zostaną zmienione (obiekty String nie mogą być zmieniane). Automatycznie rozszerza się w razie potrzeby. Podobne klasy: String, CharSequence.

StringBuilder został dodany w Javie 5. Jest identyczny pod każdym względem z Stringbufferem, z wyjątkiem tego, że nie jest zsynchronizowany, co oznacza, że jeśli wiele wątków uzyskuje do niego dostęp w tym samym czasie, mogą wystąpić problemy. W przypadku programów jednowątkowych, najczęstszym przypadkiem, unikając napowietrznych synchronizacja sprawia, że StringBuilder jest bardzo nieco szybszy.

Nie ma podstawowych różnic między StringBuilder i StringBuffer, istnieje tylko kilka różnic między nimi. W StringBuffer metody są zsynchronizowane. Oznacza to, że jednocześnie może na nich działać tylko jeden wątek. Jeśli jest więcej niż jeden wątek, to drugi wątek będzie musiał poczekać na ukończenie pierwszego, a trzeci będzie musiał poczekać na ukończenie pierwszego i drugiego itd. To sprawia, że proces jest bardzo powolny, a co za tym idzie wydajność w przypadku StringBuffer jest niski.

Z drugiej strony StringBuilder nie jest zsynchronizowany. Oznacza to, że jednocześnie wiele wątków może działać na tym samym obiekcie StrinBuilder w tym samym czasie. To sprawia, że proces jest bardzo szybki, a tym samym wydajność StringBuilder jest wysoka.

Ponieważ {[0] } jest zsynchronizowany, wymaga dodatkowego wysiłku, stąd w oparciu o perforamancję, jest nieco powolny niż StringBuilder.

String jest niezmiennym obiektem, co oznacza, że wartość nie może zostać zmieniona, gdy As StringBuffer jest zmienny.

StringBuffer jest zsynchronizowany, stąd thread safe, gdzie as StringBuilder nie jest odpowiedni tylko dla pojedynczych instancji gwintowanych.

Główna różnica polega na tym, że StringBuffer jest zsynchronizowana, ale StringBuilder nie jest.Jeśli potrzebujesz użyć więcej niż jednego wątku, zaleca się StringBuffer.Ale zgodnie z szybkością wykonania {[1] } jest szybsza niż StringBuffer, ponieważ nie jest zsynchronizowana .

Sprawdź wewnętrzne metody zsynchronizowanego dodawania StringBuffer i niezsynchronizowanego dodawania metody StringBuilder.

StringBuffer :

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

StringBuilder :

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

Ponieważ dołączanie jest synchronized, StringBuffer ma narzut wydajności w porównaniu do StrinbBuilder w scenariuszu wielowątkowym. Dopóki nie udostępniasz bufora między wieloma wątkami, użyj StringBuilder, co jest szybkie z powodu braku synchronized w metodach dodawania.

Ten link pozwoli Ci zrozumieć pojęcia nie tylko StringBuilder i StringBuffer, ale także ich związek i różnica z klasą String. To pozwoli Ci zrozumieć, kiedy użyć jakiej klasy. http://www.acquireandinspire.org/2013/01/string-string-builder-string-buffer.html