Разница между StringBuilder и StringBuffer

голоса
1k

Какова главная разница между StringBufferи StringBuilder? Есть ли какие - либо проблемы с производительностью при принятии решения о какой - либо одной из них?

Задан 10/12/2008 в 05:34
источник пользователем
На других языках...                            


34 ответов

голоса
1k

StringBufferсинхронизирован, StringBuilderнет.

Ответил 10/12/2008 в 05:36
источник пользователем

голоса
656

StringBuilderбыстрее , StringBufferпотому что это не 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.

Ответил 05/05/2010 в 10:15
источник пользователем

голоса
225

В основном, StringBufferметоды синхронизированы , пока StringBuilderнет.

Операции «почти» то же самое, но с использованием методов синхронизированы в одном потоке является излишним.

Это довольно много об этом.

Цитата StringBuilder API :

Этот класс [StringBuilder] предоставляет API , совместимый с StringBuffer, но без гарантии синхронизации . Этот класс предназначен для использования в качестве капельной замены для StringBuffer в местах , где строка буфер используется один потоком (как это обычно бывает). Там , где это возможно, рекомендуется , чтобы этот класс будет использоваться в предпочтении к StringBuffer , как это будет быстрее в большинстве реализаций.

Так это было сделано, чтобы заменить его.

То же самое случилось с Vectorи ArrayList.

Ответил 10/12/2008 в 05:37
источник пользователем

голоса
148

Но нужно, чтобы получить четкую разницу с помощью примера?

StringBuffer или StringBuilder

Просто используйте , StringBuilderесли вы действительно пытаетесь разделить буфер между потоками. StringBuilderявляется несинхронизированных (меньше накладные расходы = более эффективные) младший брат оригинального синхронизированного StringBufferкласса.

StringBufferпришел первым. ВС была связана с правильностью в любых условиях, так что они сделали это синхронизировано, чтобы сделать его поточно-на всякий случай.

StringBuilderпришли позже. Большинство видов использования StringBufferбыло одной нитью и излишне платить стоимость синхронизации.

Так как StringBuilderэто капля в замене для StringBufferбез синхронизации, то не было бы разницы между любыми примерами.

Если будут пытаться разделить между потоками, вы можете использовать StringBuffer, но рассмотреть вопрос о необходимости синхронизации более высокого уровня, например , может быть , вместо того , чтобы использовать StringBuffer, вы должны синхронизировать методы , которые используют StringBuilder.

Ответил 25/01/2011 в 13:30
источник пользователем

голоса
73

Во- первых позволяет увидеть сходство : оба StringBuilder и StringBuffer изменчивы. Это означает , что вы можете изменить их содержание, с в том же месте.

Отличия : StringBuffer изменчиво и синхронизированы , а также. Где , как StringBuilder изменяемые , но не синхронизированы по умолчанию.

Значение синхронизированной (синхронизация) : Когда некоторые вещи синхронизирована, то несколько потоков могут получить доступ, и изменить его без каких - либо проблем или побочного эффекта. StringBuffer синхронизирован, так что вы можете использовать его с несколькими потоками с любой проблемой.

Какой из них использовать , когда? StringBuilder: Когда вам нужна строка, которая может быть изменяемым, и только один поток доступа и модификации. StringBuffer: Когда вам нужна строка, которая может быть изменяемым, и несколько потоков доступа и модификации.

Примечание : Не используйте StringBuffer без необходимости, то есть, не использовать его , если только одна нить изменения и доступа к ней , потому что она имеет много блокировки и разблокировки кода для синхронизации , который будет излишне принимать процессорное время. Не используйте замки , если это не требуется.

Ответил 11/12/2013 в 08:11
источник пользователем

голоса
42

В одиночных нитей, StringBuffer не значительно медленнее , чем StringBuilder , благодаря JVM оптимизаций. И в многопоточности, вы не можете безопасно использовать в 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
Builder: 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);
    }
}

Теперь StringBuffers взять 157 мс на 100000 в конец. Это не тот же самый тест, но по сравнению с предыдущими 37 мс, то можно смело предположить , что StringBuffers Присоединяет медленнее с использованием многопоточности . Причина заключается в том, что JIT / точка доступа / составитель / что - то делает оптимизацию , когда он обнаруживает , что нет нет необходимости проверять замки.

Но с StringBuilder, у вас есть java.lang.ArrayIndexOutOfBoundsException , поскольку одновременно поток пытается что- то добавить , где он не должен.

Вывод в том, что вы не должны преследовать StringBuffers. А где у вас есть темы, думать о том, что они делают, прежде чем пытаться получить несколько наносекунд.

Ответил 15/11/2012 в 17:20
источник пользователем

голоса
37

StringBuilder был введен в Java 1.5, поэтому он не будет работать с более ранней JVM.

Из Javadocs :

StringBuilder класс предоставляет API, совместимый с StringBuffer, но без гарантии синхронизации. Этот класс предназначен для использования в качестве капельной замены для StringBuffer в местах, где строка буфер используется один потоком (как это обычно бывает). Там, где это возможно, рекомендуется, чтобы этот класс будет использоваться в предпочтении к StringBuffer, как это будет быстрее в большинстве реализаций.

Ответил 10/12/2008 в 05:38
источник пользователем

голоса
32

Довольно Хороший вопрос

Вот различие, я заметил:

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.

Общее дело: -

Оба имеют одни и те же методы с одинаковыми сигнатурами. Оба изменчивы.

Ответил 11/04/2014 в 21:25
источник пользователем

голоса
19

StringBuilderи StringBufferпочти то же самое. Разница заключается в том, что StringBufferсинхронизация и StringBuilderнет. Хотя, StringBuilderэто быстрее , чем StringBufferразница в производительности очень мало. StringBuilderявляется заменой солнцезащитным о StringBuffer. Он просто избегает синхронизации из всех общедоступных методов. Вместо того , что их функциональность та же.

Пример хорошего использования:

Если текст будет меняться и используется несколькими потоками, то лучше использовать StringBuffer. Если текст будет меняться , но используется в одном потоке, а затем использовать StringBuilder.

Ответил 03/12/2010 в 07:38
источник пользователем

голоса
19

StringBuilder не поточно. Строка Буфер. Более подробная информация здесь .

EDIT: Что касается производительности, после того, как точка доступа ног в StringBuilder является победителем. Однако, для небольших итераций, разница в производительности незначительна.

Ответил 10/12/2008 в 05:41
источник пользователем

голоса
16

StringBuffer

StringBuffer является изменяемым означает, что один может изменить значение объекта. Объект, созданный StringBuffer хранится в куче. 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

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

введите описание изображения здесь

Ресурс: Строка Vs StringBuffer Vs StringBuilder

Ответил 20/09/2016 в 17:40
источник пользователем

голоса
14

StringBuffer

  • Синхронное следовательно поточно
  • Потокобезопасная следовательно замедлится
  • -

StringBuilder

  • Введенный в Java 5.0
  • Асинхронный поэтому быстро и эффективный
  • Пользователь явно нужно синхронизировать его, если он хочет
  • Вы можете заменить его будет StringBuilderбез каких - либо других изменений
Ответил 10/12/2008 в 06:00
источник пользователем

голоса
12

String непреложный.

StringBuffer является изменяемым и синхронизированы.

StringBuilder также изменчиво, но его не синхронизированы.

Ответил 18/03/2013 в 09:12
источник пользователем

голоса
11

Javadoc объясняет разницу:

Этот класс предоставляет API, совместимый с StringBuffer, но без гарантии синхронизации. Этот класс предназначен для использования в качестве капельной замены для StringBuffer в местах, где строка буфер используется один потоком (как это обычно бывает). Там, где это возможно, рекомендуется, чтобы этот класс будет использоваться в предпочтении к StringBuffer, как это будет быстрее в большинстве реализаций.

Ответил 25/01/2011 в 13:21
источник пользователем

голоса
9

StringBuilder(введенный в Java 5) идентичны StringBuffer, за исключением того, его методы не синхронизированы. Это означает , что он имеет более высокую производительность , чем последний, но недостатком является то, что он не является потокобезопасным.

Читать учебник для более подробной информации.

Ответил 25/01/2011 в 13:23
источник пользователем

голоса
6

StringBuilder гораздо быстрее, чем StringBuffer, потому что это не синхронизированы.

Здесь вы получили больше представления о стоимости Синхронизировать

Давайте принимать программно выглядеть как много StringBuilder быстрее, чем 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");  
}  
}  

Вывод

Время, затраченное на StringBuffer: 16ms

Время, затраченное на StringBuilder: 0ms

Ответил 17/09/2016 в 11:35
источник пользователем

голоса
4

Простая программа, иллюстрирующая разницу между 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");
        }

    }
}
Ответил 14/03/2014 в 19:40
источник пользователем

голоса
3

StringBuffer:

  • Многопотоковый
  • синхронизированный
  • Медленное чем StringBuilder

StringBuilder

  • Однозаходные
  • Не-Синхронное
  • Быстрее, чем когда-либо строки
Ответил 27/09/2015 в 20:34
источник пользователем

голоса
3

StringBuffer

StringBuffer является изменяемым означает, что один может изменить значение объекта. Объект, созданный StringBuffer хранится в куче. StringBuffer, имеет те же методы, что и StringBuilder, но каждый метод в StringBuffer синхронизирован, что это StringBuffer является поточно.

StringBuilder

StringBuilder, такой же, как StringBuffer, который он хранит объект в куче, и она также может быть изменен. Основное различие между StringBuffer и StringBuilder, что StringBuilder не поточно. StringBuilder быстро, как это не поточно.

Ответил 15/06/2015 в 14:11
источник пользователем

голоса
3

StringBuffer изменчиво. Она может меняться с точки зрения длины и содержания. StringBuffers потокобезопасны, а это означает , что они синхронизированы методы контроля доступа , так что только один поток может получить доступ к синхронизированной коде объекта StringBuffer в то время , . Таким образом, объекты StringBuffer , как правило , безопасны для использования в многопоточной среде , где несколько потоков могут получить доступ , и тот же объект StringBuffer одновременно.

StringBuilder StringBuilder класс очень похож на StringBuffer, за исключением того, что доступ к нему не синхронизированы таким образом, что она не поточно-. К не синхронизированы, производительность StringBuilder может быть лучше , чем StringBuffer. Таким образом, если вы работаете в однопоточной среде, используя StringBuilder вместо StringBuffer может привести к увеличению производительности. Это также справедливо и для других ситуаций , таких как локальная переменная StringBuilder (т.е. переменная внутри метода) , где только один поток будет доступ к объекту StringBuilder.

Ответил 05/09/2014 в 11:02
источник пользователем

голоса
3

Лучше использовать StringBuilder, так как не синхронизированы, и для этого лучше производительность. StringBuilder это капля в замене старой StringBuffer.

Ответил 25/01/2011 в 13:21
источник пользователем

голоса
3

StringBufferсинхронизирован, но StringBuilderэто не так . В результате, StringBuilderпроисходит быстрее , чем StringBuffer.

Ответил 23/12/2009 в 09:42
источник пользователем

голоса
2

Стринг-строитель :

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

Рекомендуется использовать StringBuilder каждый раз, когда это возможно, потому что это быстрее, чем StringBuffer. Однако, если безопасность потока необходимо, лучший вариант объекты StringBuffer.

Ответил 01/02/2017 в 08:44
источник пользователем

голоса
2

Проверьте внутренности синхронизированного метода дописывания из StringBufferи не синхронизированных метода дописывания в 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;
}

Так Append есть synchronized, StringBufferесть накладные расходы на производительность по сравнению с StrinbBuilderв сценарии многопоточного. До тех пор , пока вы не разделяя буфер между несколькими потоками, использованием StringBuilder, которое быстро из - за отсутствия synchronizedв дописать методы.

Ответил 09/06/2016 в 07:16
источник пользователем

голоса
2

Там нет принципиальных различий между StringBuilder и StringBuffer, лишь некоторые различия между ними существуют. В StringBuffer синхронизированы методы. Это означает, что в то время только один поток может работать на них. Если есть более чем один поток, то второй поток будет ждать первый закончить и третий один придется ждать первого и второго, чтобы закончить и так далее. Это делает процесс очень медленно и, следовательно, производительность в случае StringBuffer низка.

С другой стороны, StringBuilder является не синхронизированы. Это означает, что в то время, несколько потоков могут работать на тот же объект StrinBuilder в то же самое время. Это делает процесс очень быстро и, следовательно, производительность StringBuilder высока.

Ответил 10/05/2016 в 07:57
источник пользователем

голоса
2

Так как StringBufferсинхронизация, она нуждается в некоторых дополнительных усилий, следовательно , на основе perforamance, его немного медленно чем StringBuilder.

Ответил 25/07/2013 в 07:39
источник пользователем

голоса
2

StringBuffer используется для хранения символьных строк, которые будут изменены (объекты Строки не могут быть изменены). Он автоматически расширяется по мере необходимости. Связанные классы: Строка, CharSequence.

StringBuilder был добавлен в Java 5. Он идентичен во всех отношениях StringBuffer, за исключением, что он не синхронизированы, что означает, что если несколько потоков доступа к ней в то же время, могут быть неприятности. Для однопоточных программ, в наиболее общем случае, избегая накладные расходы синхронизации очень немного быстрее делает StringBuilder.

Ответил 23/04/2009 в 14:44
источник пользователем

голоса
1
  • StringBuffer является поточно-но StringBuilder не поточно.
  • StringBuilder быстрее, чем StringBuffer.
  • StringBuffer синхронизирован, тогда как StringBuilder не синхронизирован.
Ответил 01/11/2018 в 17:41
источник пользователем

голоса
1

Основное различие StringBufferсинхронизировано , но StringBuilderэто not.If вам нужно использовать более чем одну нить, то StringBuffer является recommended.But, согласно скорости исполнения StringBuilderбыстрее StringBuffer, потому что его не синхронизирована.

Ответил 15/11/2013 в 19:05
источник пользователем

голоса
1

Эта ссылка позволит Вам понять концепции не только StringBuilderи , StringBufferно также их ассоциации и различия с Stringклассом. Это позволит вам понять , когда использовать какой класс. http://www.acquireandinspire.org/2013/01/string-string-builder-string-buffer.html

Ответил 25/07/2013 в 07:38
источник пользователем

голоса
1

Строка представляет собой неизменное объект, который означает, что значение не может быть изменено, где, как StringBuffer, является изменяемым.

StringBuffer синхронизируется поэтому поточно где, как StringBuilder не является и подходят только для одного резьбовых экземпляров.

Ответил 17/11/2010 в 12:33
источник пользователем

голоса
0

StringBuffer синхронизируется и поточно, StringBuilder не synchrnised и быстрее.

Ответил 11/07/2019 в 14:48
источник пользователем

голоса
0

Вот результат тестирования производительности для строки против 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
Ответил 24/08/2018 в 07:59
источник пользователем

голоса
0

Каждый метод присутствует в StringBuffer синхронизируется. следовательно, в то время только один поток разрешено работать объект StringBuffer. Это увеличивает время ожидания нити и создает проблемы производительности, чтобы преодолеть эту проблему SUN Люди intoduced StringBuilder в версии 1.5.

Ответил 01/07/2013 в 14:52
источник пользователем

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more