Difference between StringBuilder and StringBuffer

Question

What is the main difference between StringBuffer and StringBuilder  Is there any performance issues when deciding on any one of these

User · Answer

A String is an immutable object which means the value cannot be changed whereas StringBuffer is mutable   The StringBuffer is Synchronized hence thread-safe whereas StringBuilder is not and suitable for only single-threaded instances

User · Answer

The major difference is StringBuffer is syncronized but StringBuilder is not If you need to use more than one thread   then StringBuffer is recommended But  as per the execution speed StringBuilder is faster than StringBuffer   because its not syncronized

User · Answer

StringBuffer   Synchronized hence threadsafe Thread safe hence slow   StringBuilder   Introduced in Java 5 0 Asynchronous hence fast  amp  efficient User explicitly needs to synchronize it  if he wants You can replace it with StringBuffer without any other change

User · Answer

First lets see the similarities  Both StringBuilder and StringBuffer are mutable  That means you can change the content of them  with in the same location   Differences  StringBuffer is mutable and synchronized as well  Where as StringBuilder is mutable but not synchronized by default   Meaning of synchronized  synchronization   When some thing is synchronized  then multiple threads can access  and modify it with out any problem or side effect  StringBuffer is synchronized  so you can use it with multiple threads with out any problem   Which one to use when  StringBuilder   When you need a string  which can be modifiable  and only one thread is accessing and modifying it  StringBuffer   When you need a string  which can be modifiable  and multiple threads are accessing and modifying it   Note   Don t use StringBuffer unnecessarily  i e   don t use it if only one thread is modifying and accessing it because it has lot of locking and unlocking code for synchronization which will unnecessarily take up CPU time  Don t use locks unless it is required

User · Answer

Basically  StringBuffer methods are synchronized while StringBuilder are not   The operations are  almost  the same  but using synchronized methods in a single thread is overkill   That s pretty much about it   Quote from StringBuilder API      This class  StringBuilder  provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations    So it was made to substitute it   The same happened with Vector and ArrayList

User · Answer

StringBuilder is not thread safe  String Buffer is  More info here   EDIT  As for performance   after hotspot kicks in   StringBuilder is the winner  However   for small iterations   the performance difference is negligible

User · Answer

A String is an immutable object which means the value cannot be changed whereas StringBuffer is mutable   The StringBuffer is Synchronized hence thread-safe whereas StringBuilder is not and suitable for only single-threaded instances

User · Answer

StringBuilder is not thread safe  String Buffer is  More info here   EDIT  As for performance   after hotspot kicks in   StringBuilder is the winner  However   for small iterations   the performance difference is negligible

User · Answer

StringBuffer is synchronized  but StringBuilder is not  As a result  StringBuilder is faster than StringBuffer

User · Answer

Basically  StringBuffer methods are synchronized while StringBuilder are not   The operations are  almost  the same  but using synchronized methods in a single thread is overkill   That s pretty much about it   Quote from StringBuilder API      This class  StringBuilder  provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations    So it was made to substitute it   The same happened with Vector and ArrayList

User · Answer

StringBuilder was introduced in Java 1 5 so it won t work with earlier JVMs   From the Javadocs      StringBuilder class provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations

User · Answer

StringBuffer is mutable  It can change in terms of length and content  StringBuffers are thread-safe  meaning that they have synchronized methods to control access so that only one thread can access a StringBuffer object s synchronized code at a time  Thus  StringBuffer objects are generally safe to use in a multi-threaded environment where multiple threads may be trying to access the same StringBuffer object at the same time   StringBuilder The StringBuilder class is very similar to StringBuffer  except that its access is not synchronized so that it is not thread-safe  By not being synchronized  the performance of StringBuilder can be better than StringBuffer  Thus  if you are working in a single-threaded environment  using StringBuilder instead of StringBuffer may result in increased performance  This is also true of other situations such as a StringBuilder local variable  ie  a variable within a method  where only one thread will be accessing a StringBuilder object

User · Answer

String is an immutable   StringBuffer is a mutable and synchronized    StringBuilder is also mutable but its not synchronized

User · Answer

In single threads  StringBuffer is not significantly slower than StringBuilder  thanks to JVM optimisations  And in multithreading  you can t use safely a StringBuilder   Here is my test  not a benchmark  just a test      public static void main String   args         String withString          long t0   System currentTimeMillis        for  int i   0   i  lt  100000  i             withString   some string             System out println  strings      System currentTimeMillis   - t0         t0   System currentTimeMillis        StringBuffer buf   new StringBuffer        for  int i   0   i  lt  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  lt  100000  i             building append  some string              System out println  Builder      System currentTimeMillis   - t0        Results   strings  319740 Buffers   23 Builder   7    So Builders are faster than Buffers  and WAY faster than strings concatenation  Now let s use an Executor for multiple threads    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  lt  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  lt  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 lt T extends Appendable gt  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  lt  10000   j                 try                   appendable append  some string                  catch  IOException e                       time   System currentTimeMillis   - t0             Now StringBuffers take 157 ms for 100000 appends  It s not the same test  but compared to the previous 37 ms  you can safely assume that StringBuffers appends are slower with multithreading use  The reason is that the JIT hotspot compiler something makes optimizations when it detects that there is no need for checking locks   But with StringBuilder  you have java lang ArrayIndexOutOfBoundsException  because a concurrent thread tries to add something where it should not    Conclusion is that you don t have to chase StringBuffers  And where you have threads  think about what they are doing  before trying to gain a few nanoseconds

User · Answer

In single threads  StringBuffer is not significantly slower than StringBuilder  thanks to JVM optimisations  And in multithreading  you can t use safely a StringBuilder   Here is my test  not a benchmark  just a test      public static void main String   args         String withString          long t0   System currentTimeMillis        for  int i   0   i  lt  100000  i             withString   some string             System out println  strings      System currentTimeMillis   - t0         t0   System currentTimeMillis        StringBuffer buf   new StringBuffer        for  int i   0   i  lt  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  lt  100000  i             building append  some string              System out println  Builder      System currentTimeMillis   - t0        Results   strings  319740 Buffers   23 Builder   7    So Builders are faster than Buffers  and WAY faster than strings concatenation  Now let s use an Executor for multiple threads    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  lt  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  lt  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 lt T extends Appendable gt  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  lt  10000   j                 try                   appendable append  some string                  catch  IOException e                       time   System currentTimeMillis   - t0             Now StringBuffers take 157 ms for 100000 appends  It s not the same test  but compared to the previous 37 ms  you can safely assume that StringBuffers appends are slower with multithreading use  The reason is that the JIT hotspot compiler something makes optimizations when it detects that there is no need for checking locks   But with StringBuilder  you have java lang ArrayIndexOutOfBoundsException  because a concurrent thread tries to add something where it should not    Conclusion is that you don t have to chase StringBuffers  And where you have threads  think about what they are doing  before trying to gain a few nanoseconds

User · Answer

The javadoc explains the difference      This class provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations

User · Answer

StringBuilder  introduced in Java 5  is identical to StringBuffer  except its methods are not synchronized   This means it has better performance than the latter  but the drawback is that it is not thread-safe   Read tutorial for more details

User · Answer

StringBuffer   Synchronized hence threadsafe Thread safe hence slow   StringBuilder   Introduced in Java 5 0 Asynchronous hence fast  amp  efficient User explicitly needs to synchronize it  if he wants You can replace it with StringBuffer without any other change

User · Answer

StringBuilder and StringBuffer are almost the same  The difference is that StringBuffer is synchronized and StringBuilder is not  Although  StringBuilder is faster than StringBuffer  the difference in performance is very little  StringBuilder is a SUN s replacement of StringBuffer  It just avoids synchronization from all the public methods  Rather than that  their functionality is the same   Example of good usage   If your text is going to change and is used by multiple threads  then it is better to use StringBuffer  If your text is going to change but is used by a single thread  then use StringBuilder

User · Answer

StringBuilder  introduced in Java 5  is identical to StringBuffer  except its methods are not synchronized   This means it has better performance than the latter  but the drawback is that it is not thread-safe   Read tutorial for more details

User · Answer

StringBuilder was introduced in Java 1 5 so it won t work with earlier JVMs   From the Javadocs      StringBuilder class provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations

User · Answer

Since StringBuffer is synchronized  it needs some extra effort  hence based on perforamance  its a bit slow than StringBuilder

User · Answer

Pretty Good Question   Here are the differences  i have noticed    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    Common thing  -     Both have same methods with same signatures  Both are mutable

User · Answer

StringBuffer is synchronized  StringBuilder is not

User · Answer

Every method present in StringBuffer is Synchronized  hence at a time only one thread is allowed to operate StringBuffer object  It Increases waiting time of a Thread and Creates Performance problems to overcome this problem SUN People intoduced StringBuilder in 1 5 version

User · Answer

A simple program illustrating the difference between StringBuffer and 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  lt  n  i                  builderThreads i    new StringBuilderTest sb                     for  int i   0  i  lt  n  i                  builderThreads i  start                      for  int i   0  i  lt  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  lt  n  i                  bufferThreads i    new StringBufferTest sb2                     for  int i   0  i  lt  n  i                  bufferThreads i  start                      for  int i   0  i  lt  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  lt  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  lt  100  i                  sb2 append  A

User · Answer

StringBuffer is mutable  It can change in terms of length and content  StringBuffers are thread-safe  meaning that they have synchronized methods to control access so that only one thread can access a StringBuffer object s synchronized code at a time  Thus  StringBuffer objects are generally safe to use in a multi-threaded environment where multiple threads may be trying to access the same StringBuffer object at the same time   StringBuilder The StringBuilder class is very similar to StringBuffer  except that its access is not synchronized so that it is not thread-safe  By not being synchronized  the performance of StringBuilder can be better than StringBuffer  Thus  if you are working in a single-threaded environment  using StringBuilder instead of StringBuffer may result in increased performance  This is also true of other situations such as a StringBuilder local variable  ie  a variable within a method  where only one thread will be accessing a StringBuilder object

User · Answer

StringBuffer is used to store character strings that will be changed  String objects cannot be changed   It automatically expands as needed  Related classes  String  CharSequence   StringBuilder was added in Java 5  It is identical in all respects to StringBuffer except that it is not synchronized  which means that if multiple threads are accessing it at the same time  there could be trouble  For single-threaded programs  the most common case  avoiding the overhead of synchronization makes the StringBuilder very slightly faster

User · Answer

Basically  StringBuffer methods are synchronized while StringBuilder are not   The operations are  almost  the same  but using synchronized methods in a single thread is overkill   That s pretty much about it   Quote from StringBuilder API      This class  StringBuilder  provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations    So it was made to substitute it   The same happened with Vector and ArrayList

User · Answer

Check the internals of synchronized append method of StringBuffer and non-synchronized append method of 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      Since append is synchronized  StringBuffer has performance overhead compared to StrinbBuilder in multi-threading scenario  As long as you are not sharing buffer among multiple threads  use StringBuilder  which is fast due to absence of synchronized in append methods

User · Answer

The javadoc explains the difference      This class provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations

User · Answer

StringBuilder was introduced in Java 1 5 so it won t work with earlier JVMs   From the Javadocs      StringBuilder class provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations

User · Answer

Others have rightly pointed out the key differences between the two  However in terms of performance I would like to add that a JVM level optimization  Lock Elision  which could make the performance difference in context of synchronization to be almost non-existent  An excellent read on this is here and  here

User · Answer

StringBuffer is thread-safe but StringBuilder is not thread safe  StringBuilder is faster than StringBuffer  StringBuffer is synchronized whereas StringBuilder is not synchronized

User · Answer

StringBuffer is synchronized  StringBuilder is not

User · Answer

Here is the performance testing result for String vs StringBuffer vs StringBuilder  Finally  StringBuilder won the Test  See below for test code and result   Code   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  lt   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  lt   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  lt   loop  i        sbuffer append i  append  test      System out println  String Builder -      System currentTimeMillis   - start      ms           Execute Me on ideone  Result   100000 iteration for adding a single text  String - 37489 ms String Buffer - 5 ms String Builder - 4 ms   10000 iteration for adding a single text  String - 389 ms String Buffer - 1 ms String Builder - 1 ms

User · Answer

But needed to get the clear difference with the help of an example  StringBuffer or StringBuilder  Simply use StringBuilder unless you really are trying to share a buffer between threads  StringBuilder is the unsynchronized  less overhead   more efficient  younger brother of the original synchronized StringBuffer class  StringBuffer came first   Sun was concerned with correctness under all conditions  so they made it synchronized to make it thread-safe just in case  StringBuilder came later   Most of the uses of StringBuffer were single-thread and unnecessarily paying the cost of the synchronization  Since StringBuilder is a drop-in replacement for StringBuffer without the synchronization  there would not be differences between any examples  If you are trying to share between threads  you can use StringBuffer  but consider whether higher-level synchronization is necessary  e g  perhaps instead of using StringBuffer  should you synchronize the methods that use the StringBuilder

User · Answer

Here is the performance testing result for String vs StringBuffer vs StringBuilder  Finally  StringBuilder won the Test  See below for test code and result   Code   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  lt   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  lt   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  lt   loop  i        sbuffer append i  append  test      System out println  String Builder -      System currentTimeMillis   - start      ms           Execute Me on ideone  Result   100000 iteration for adding a single text  String - 37489 ms String Buffer - 5 ms String Builder - 4 ms   10000 iteration for adding a single text  String - 389 ms String Buffer - 1 ms String Builder - 1 ms

User · Answer

Difference between StringBuffer and StringBuilder Source

User · Answer

StringBuffer    Multi-Thread Synchronized Slow than StringBuilder   StringBuilder   Single-Thread Not-Synchronized Faster than ever String

User · Answer

StringBuilder is faster than StringBuffer because it s not synchronized   Here s a simple benchmark test   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 -- gt  0                      sb append                                System out println System currentTimeMillis   - t                                    StringBuilder sb   new StringBuilder                t   System currentTimeMillis                for  int i   N  i  gt  0   i--                    sb append                                System out println System currentTimeMillis   - t                       A test run gives the numbers of 2241 ms for StringBuffer vs 753 ms for StringBuilder

User · Answer

String is an immutable   StringBuffer is a mutable and synchronized    StringBuilder is also mutable but its not synchronized

User · Answer

But needed to get the clear difference with the help of an example  StringBuffer or StringBuilder  Simply use StringBuilder unless you really are trying to share a buffer between threads  StringBuilder is the unsynchronized  less overhead   more efficient  younger brother of the original synchronized StringBuffer class  StringBuffer came first   Sun was concerned with correctness under all conditions  so they made it synchronized to make it thread-safe just in case  StringBuilder came later   Most of the uses of StringBuffer were single-thread and unnecessarily paying the cost of the synchronization  Since StringBuilder is a drop-in replacement for StringBuffer without the synchronization  there would not be differences between any examples  If you are trying to share between threads  you can use StringBuffer  but consider whether higher-level synchronization is necessary  e g  perhaps instead of using StringBuffer  should you synchronize the methods that use the StringBuilder

User · Answer

StringBuffer    Multi-Thread Synchronized Slow than StringBuilder   StringBuilder   Single-Thread Not-Synchronized Faster than ever String

User · Answer

StringBuffer  StringBuffer is mutable means one can change the value of the object   The object created through StringBuffer is stored in the heap    StringBuffer  has the same methods as the StringBuilder   but each method in StringBuffer is synchronized that is StringBuffer is thread safe    because of this it does not allow  two threads to simultaneously access the same method   Each method can be accessed by one thread at a time    But being thread safe has disadvantages too as the performance of the StringBuffer hits due to thread safe property   Thus  StringBuilder is faster than the StringBuffer when calling the same methods of each class   StringBuffer value can be changed   it means it can be assigned to the new value   Nowadays its a most common interview question  the differences between the above classes   String Buffer can be converted to the string by using toString   method   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  is same as the StringBuffer   that is it stores the object in heap and it can also be modified   The main difference between the StringBuffer and StringBuilder is that StringBuilder is also not thread safe   StringBuilder is fast as it is not thread safe    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

User · Answer

Better use StringBuilder since it is not synchronized and offers therefore better performance  StringBuilder is a drop-in replacement of the older StringBuffer

User · Answer

StringBuilder is not thread safe  String Buffer is  More info here   EDIT  As for performance   after hotspot kicks in   StringBuilder is the winner  However   for small iterations   the performance difference is negligible

User · Answer

StringBuilder is faster than StringBuffer because it s not synchronized   Here s a simple benchmark test   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 -- gt  0                      sb append                                System out println System currentTimeMillis   - t                                    StringBuilder sb   new StringBuilder                t   System currentTimeMillis                for  int i   N  i  gt  0   i--                    sb append                                System out println System currentTimeMillis   - t                       A test run gives the numbers of 2241 ms for StringBuffer vs 753 ms for StringBuilder

User · Answer

There are no basic differences between StringBuilder and StringBuffer  only a few differences exist between them  In StringBuffer the methods are synchronized  This means that at a time only one thread can operate on them  If there is more than one thread then the second thread will have to wait for the first one to finish and the third one will have to wait for the first and second one to finish and so on  This makes the process very slow and hence the performance in the case of StringBuffer is low   On the other hand  StringBuilder is not synchronized  This means that at a time multiple threads can operate on the same StringBuilder object at the same time  This makes the process very fast and hence performance of StringBuilder is high

User · Answer

StringBuffer   Synchronized hence threadsafe Thread safe hence slow   StringBuilder   Introduced in Java 5 0 Asynchronous hence fast  amp  efficient User explicitly needs to synchronize it  if he wants You can replace it with StringBuffer without any other change

User · Answer

StringBuffer  StringBuffer is mutable means one can change the value of the object   The object created through StringBuffer is stored in the heap    StringBuffer  has the same methods as the StringBuilder   but each method in StringBuffer is synchronized that is StringBuffer is thread safe    because of this it does not allow  two threads to simultaneously access the same method   Each method can be accessed by one thread at a time    But being thread safe has disadvantages too as the performance of the StringBuffer hits due to thread safe property   Thus  StringBuilder is faster than the StringBuffer when calling the same methods of each class   StringBuffer value can be changed   it means it can be assigned to the new value   Nowadays its a most common interview question  the differences between the above classes   String Buffer can be converted to the string by using toString   method   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  is same as the StringBuffer   that is it stores the object in heap and it can also be modified   The main difference between the StringBuffer and StringBuilder is that StringBuilder is also not thread safe   StringBuilder is fast as it is not thread safe    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

User · Answer

StringBuffer is synchronized  but StringBuilder is not  As a result  StringBuilder is faster than StringBuffer

User · Answer

Pretty Good Question   Here are the differences  i have noticed    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    Common thing  -     Both have same methods with same signatures  Both are mutable

User · Answer

StringBuilder was introduced in Java 1 5 so it won t work with earlier JVMs   From the Javadocs      StringBuilder class provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations

User · Answer

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       It is recommended to use StringBuilder whenever possible because it is faster than StringBuffer  However  if the thread safety is necessary  the best option is StringBuffer objects

User · Answer

The major difference is StringBuffer is syncronized but StringBuilder is not If you need to use more than one thread   then StringBuffer is recommended But  as per the execution speed StringBuilder is faster than StringBuffer   because its not syncronized

User · Answer

StringBuffer is synchronized  StringBuilder is not

User · Answer

There are no basic differences between StringBuilder and StringBuffer  only a few differences exist between them  In StringBuffer the methods are synchronized  This means that at a time only one thread can operate on them  If there is more than one thread then the second thread will have to wait for the first one to finish and the third one will have to wait for the first and second one to finish and so on  This makes the process very slow and hence the performance in the case of StringBuffer is low   On the other hand  StringBuilder is not synchronized  This means that at a time multiple threads can operate on the same StringBuilder object at the same time  This makes the process very fast and hence performance of StringBuilder is high

User · Answer

Check the internals of synchronized append method of StringBuffer and non-synchronized append method of 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      Since append is synchronized  StringBuffer has performance overhead compared to StrinbBuilder in multi-threading scenario  As long as you are not sharing buffer among multiple threads  use StringBuilder  which is fast due to absence of synchronized in append methods

User · Answer

StringBuilder is not thread safe  String Buffer is  More info here   EDIT  As for performance   after hotspot kicks in   StringBuilder is the winner  However   for small iterations   the performance difference is negligible

User · Answer

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       It is recommended to use StringBuilder whenever possible because it is faster than StringBuffer  However  if the thread safety is necessary  the best option is StringBuffer objects

User · Answer

StringBuffer   Synchronized hence threadsafe Thread safe hence slow   StringBuilder   Introduced in Java 5 0 Asynchronous hence fast  amp  efficient User explicitly needs to synchronize it  if he wants You can replace it with StringBuffer without any other change

User · Answer

Since StringBuffer is synchronized  it needs some extra effort  hence based on perforamance  its a bit slow than StringBuilder

User · Answer

StringBuffer is thread-safe but StringBuilder is not thread safe  StringBuilder is faster than StringBuffer  StringBuffer is synchronized whereas StringBuilder is not synchronized

User · Answer

Every method present in StringBuffer is Synchronized  hence at a time only one thread is allowed to operate StringBuffer object  It Increases waiting time of a Thread and Creates Performance problems to overcome this problem SUN People intoduced StringBuilder in 1 5 version

User · Answer

A simple program illustrating the difference between StringBuffer and 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  lt  n  i                  builderThreads i    new StringBuilderTest sb                     for  int i   0  i  lt  n  i                  builderThreads i  start                      for  int i   0  i  lt  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  lt  n  i                  bufferThreads i    new StringBufferTest sb2                     for  int i   0  i  lt  n  i                  bufferThreads i  start                      for  int i   0  i  lt  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  lt  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  lt  100  i                  sb2 append  A

User · Answer

First lets see the similarities  Both StringBuilder and StringBuffer are mutable  That means you can change the content of them  with in the same location   Differences  StringBuffer is mutable and synchronized as well  Where as StringBuilder is mutable but not synchronized by default   Meaning of synchronized  synchronization   When some thing is synchronized  then multiple threads can access  and modify it with out any problem or side effect  StringBuffer is synchronized  so you can use it with multiple threads with out any problem   Which one to use when  StringBuilder   When you need a string  which can be modifiable  and only one thread is accessing and modifying it  StringBuffer   When you need a string  which can be modifiable  and multiple threads are accessing and modifying it   Note   Don t use StringBuffer unnecessarily  i e   don t use it if only one thread is modifying and accessing it because it has lot of locking and unlocking code for synchronization which will unnecessarily take up CPU time  Don t use locks unless it is required

User · Answer

StringBuffer is used to store character strings that will be changed  String objects cannot be changed   It automatically expands as needed  Related classes  String  CharSequence   StringBuilder was added in Java 5  It is identical in all respects to StringBuffer except that it is not synchronized  which means that if multiple threads are accessing it at the same time  there could be trouble  For single-threaded programs  the most common case  avoiding the overhead of synchronization makes the StringBuilder very slightly faster

User · Answer

StringBuilder and StringBuffer are almost the same  The difference is that StringBuffer is synchronized and StringBuilder is not  Although  StringBuilder is faster than StringBuffer  the difference in performance is very little  StringBuilder is a SUN s replacement of StringBuffer  It just avoids synchronization from all the public methods  Rather than that  their functionality is the same   Example of good usage   If your text is going to change and is used by multiple threads  then it is better to use StringBuffer  If your text is going to change but is used by a single thread  then use StringBuilder

User · Answer

Basically  StringBuffer methods are synchronized while StringBuilder are not   The operations are  almost  the same  but using synchronized methods in a single thread is overkill   That s pretty much about it   Quote from StringBuilder API      This class  StringBuilder  provides an API compatible with StringBuffer  but with no guarantee of synchronization  This class is designed for use as a drop-in replacement for StringBuffer in places where the string buffer was being used by a single thread  as is generally the case   Where possible  it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations    So it was made to substitute it   The same happened with Vector and ArrayList

User · Answer

StringBuffer is synchronized  StringBuilder is not

User · Answer

Others have rightly pointed out the key differences between the two  However in terms of performance I would like to add that a JVM level optimization  Lock Elision  which could make the performance difference in context of synchronization to be almost non-existent  An excellent read on this is here and  here

User · Answer

Difference between StringBuffer and StringBuilder Source

User · Answer

Better use StringBuilder since it is not synchronized and offers therefore better performance  StringBuilder is a drop-in replacement of the older StringBuffer

[java] Difference between StringBuilder and StringBuffer

Examples related to java

Examples related to stringbuilder

Examples related to stringbuffer