What is the difference between String and StringBuffer in Java

Question

What is the difference between String and StringBuffer in Java   Is there a maximum size for String

User · Answer

String                                          StringBuffer  Immutable                                       Mutable String s new String  karthik                   StringBuffer sb new StringBuffer  karthik   s concat  reddy                                sb append  reddy    System out println s                           System out println sb   O P karthik                                    O P karthikreddy  --- gt once we created a String object            ---- gt once we created a StringBuffer object we can t perform any changes in the existing  we can perform any changes in the existing object If we are trying to perform any        object It is nothing but mutablity of  changes with those changes a new object       of a StrongBuffer object will be created It is nothing but Immutability of a String object  Use String--- gt If you require immutabilty Use StringBuffer---- gt If you require mutable   threadsafety Use StringBuilder--- gt If you require mutable   with out threadsafety  String s new String  karthik    --- gt here 2 objects will be created one is heap and the other is in stringconstantpool scp  and s is always pointing to heap object  String s  karthik    --- gt In this case only one object will be created in scp and s is always pointing to that object only

User · Answer

A StringBuffer or its younger and faster brother StringBuilder is preferred whenever you re going do to a lot of string concatenations in flavor of  string    newString    or equivalently  string   string   newString    because the above constructs implicitly creates new string everytime which will be a huge performance and drop  A StringBuffer   StringBuilder is under the hoods best to be compared with a dynamically expansible List lt Character gt

User · Answer

String is immutable     Why  Check here   StringBuffer is not  It is thread safe     Further questions like when to use which and other concepts can be figured out following this   Hope this helps

User · Answer

Performance wise StringBuffer is much better than String   because whenever you apply concatenation on String Object then new String object are created on each concatenation   Principal Rule   String are immutable Non Modifiable  and StringBuffer are mutable Modifiable    Here is the programmatic experiment where you get the performance difference    public class Test      public static int LOOP ITERATION  100000     public static void stringTest        long startTime   System currentTimeMillis        String string    This       for int i 0 i lt LOOP ITERATION i             string   string  Yasir              long endTime   System currentTimeMillis        System out println endTime - startTime              public static void stringBufferTest        long startTime   System currentTimeMillis        StringBuffer stringBuffer   new StringBuffer  This        for int i 0 i lt LOOP ITERATION i             stringBuffer append  Yasir               long endTime   System currentTimeMillis        System out println endTime - startTime          public static void main String   args       stringTest       stringBufferTest              Output of  String are in my machine     14800  Output of StringBuffer are in my machine   14

User · Answer

A StringBuffer is used to create a single string from many strings  e g  when you want to append parts of a String in a loop   You should use a StringBuilder instead of a StringBuffer when you have only a single Thread accessing the StringBuffer  since the StringBuilder is not synchronized and thus faster   AFAIK there is no upper limit for String size in Java as a language  but the JVMs probably have an upper limit

User · Answer

String is used to manipulate character strings that cannot be changed  read-only and immutable     StringBuffer is used to represent characters that can be modified   Performance wise  StringBuffer is faster when performing concatenations  This is because when you concatenate a String  you are creating a new object  internally  every time since String is immutable   You can also use StringBuilder which is similar to StringBuffer except it is not synchronized  The maximum size for either of these is Integer MAX VALUE  231 - 1   2 147 483 647  or maximum heap size divided by 2  see How many characters can a Java String have    More information here

User · Answer

From the API      A thread-safe  mutable sequence of characters  A string buffer is like a String  but can be modified  At any point in time it contains some particular sequence of characters  but the length and content of the sequence can be changed through certain method calls

User · Answer

By printing the hashcode of the String StringBuffer object after any append operation also prove  String object is getting recreated internally every time with new values rather than using the same String object   public class MutableImmutable            param args     public static void main String   args        System out println  String is immutable        String s    test       System out println s      s hashCode         for  int i   0  i  lt  10  i              s     tre           System out println s      s hashCode                System out println  String Buffer is mutable         StringBuffer strBuf   new StringBuffer  test        System out println strBuf      strBuf hashCode         for  int i   0  i  lt  10  i              strBuf append  tre            System out println strBuf      strBuf hashCode                    Output  It prints object value along with its hashcode      String is immutable     test  3556498     testtre  -1422435371     testtretre  -1624680014     testtretretre  -855723339     testtretretretre  2071992018     testtretretretretre  -555654763     testtretretretretretre  -706970638     testtretretretretretretre  1157458037     testtretretretretretretretre  1835043090     testtretretretretretretretretre  1425065813     testtretretretretretretretretretre  -1615970766     String Buffer is mutable     test  28117098     testtre  28117098     testtretre  28117098     testtretretre  28117098     testtretretretre  28117098     testtretretretretre  28117098     testtretretretretretre  28117098     testtretretretretretretre  28117098     testtretretretretretretretre  28117098     testtretretretretretretretretre  28117098     testtretretretretretretretretretre  28117098

User · Answer

A String is an immutable character array   A StringBuffer is a mutable character array  Often converted back to String when done mutating   Since both are an array  the maximum size for both is equal to the maximum size of an integer  which is 2 31-1  see JavaDoc  also check out the JavaDoc for both String and StringBuffer  This is because the  length argument of an array is a primitive int   See Arrays

User · Answer

String is immutable  meaning that when you perform an operation on a String you are really creating a whole new String   StringBuffer is mutable  and you can append to it as well as reset its length to 0   In practice  the compiler seems to use StringBuffer during String concatenation for performance reasons

User · Answer

String is an immutable class  This means that once you instantiate an instance of a string like so   String str1    hello     The object in memory cannot be altered  Instead you will have to create a new instance  copy the old String and append whatever else as in this example   String str1    hello   str1   str1     world      What is really happening hear is that we are NOT updating the existing str1 object    we are reallocating new memory all together  copying the  hello  data and appending   world   to the end  then settings the str1 reference to point to this new memory  So it really looks more like this under the hood   String str1    hello   String str2   str1     world    str1   str2    So it follows that this  copy   paste and move stuff around in memory  process can be very expensive if done repitively especially recursively   When you are in that situation of having to do things over and over utilize StringBuilder  It is mutable and can append strings to the end of the current one because it s back by an  growing array   not 100  if that is the actual data structure  could be a list

User · Answer

While I understand that this is not a major differentiating factor  I noticed today that StringBuffer and StringBuilder  provides some interesting methods that String doesn t    reverse   setCharAt

User · Answer

The differences are   Only in String class   operator is overloaded  We can concat two String object using   operator  but in the case of StringBuffer we can t  String class is overriding toString    equals    hashCode   of Object class  but StringBuffer only overrides toString     String s1   new String  abc    String s2   new String  abc    System out println s1 equals s2        output true  StringBuffer sb1   new StringBuffer  abc    StringBuffer sb2   new StringBuffer  abc    System out println sb1 equals sb2        output false  String class is both Serializable as well as Comparable  but StringBuffer is only Serializable   Set lt StringBuffer gt  set   new TreeSet lt StringBuffer gt     set add sb1   set add sb2   System out println set       gives ClassCastException because there is no Comparison mechanism  We can create a String object with and without new operator  but StringBuffer object can only be created using new operator  String is immutable but StringBuffer is mutable  StringBuffer is synchronized  whereas String ain t  StringBuffer is having an in-built reverse   method  but String dosen t have it

User · Answer

I found interest answer for compare performance String vs StringBuffer by Reggie Hutcherso Source  http   www javaworld com javaworld jw-03-2000 jw-0324-javaperf html  Java provides the StringBuffer and String classes  and the String class is used to manipulate character strings that cannot be changed  Simply stated  objects of type String are read only and immutable  The StringBuffer class is used to represent characters that can be modified   The significant performance difference between these two classes is that StringBuffer is faster than String when performing simple concatenations  In String manipulation code  character strings are routinely concatenated  Using the String class  concatenations are typically performed as follows    String str   new String   Stanford       str     Lost       If you were to use StringBuffer to perform the same concatenation  you would need code that looks like this    StringBuffer str   new StringBuffer   Stanford      str append  Lost        Developers usually assume that the first example above is more efficient because they think that the second example  which uses the append method for concatenation  is more costly than the first example  which uses the   operator to concatenate two String objects   The   operator appears innocent  but the code generated produces some surprises  Using a StringBuffer for concatenation can in fact produce code that is significantly faster than using a String  To discover why this is the case  we must examine the generated bytecode from our two examples  The bytecode for the example using String looks like this   0 new  7  lt Class java lang String gt  3 dup  4 ldc  2  lt String  Stanford   gt  6 invokespecial  12  lt Method java lang String java lang String  gt  9 astore 1 10 new  8  lt Class java lang StringBuffer gt  13 dup 14 aload 1 15 invokestatic  23  lt Method java lang String valueOf java lang Object  gt  18 invokespecial  13  lt Method java lang StringBuffer java lang String  gt  21 ldc  1  lt String  Lost    gt  23 invokevirtual  15  lt Method java lang StringBuffer append java lang String  gt  26 invokevirtual  22  lt Method java lang String toString   gt  29 astore 1   The bytecode at locations 0 through 9 is executed for the first line of code  namely    String str   new String  Stanford       Then  the bytecode at location 10 through 29 is executed for the concatenation    str     Lost       Things get interesting here  The bytecode generated for the concatenation creates a StringBuffer object  then invokes its append method  the temporary StringBuffer object is created at location 10  and its append method is called at location 23  Because the String class is immutable  a StringBuffer must be used for concatenation   After the concatenation is performed on the StringBuffer object  it must be converted back into a String  This is done with the call to the toString method at location 26  This method creates a new String object from the temporary StringBuffer object  The creation of this temporary StringBuffer object and its subsequent conversion back into a String object are very expensive   In summary  the two lines of code above result in the creation of three objects    A String object at location 0 A StringBuffer object at location 10 A String object at location 26   Now  let s look at the bytecode generated for the example using StringBuffer   0 new  8  lt Class java lang StringBuffer gt  3 dup 4 ldc  2  lt String  Stanford   gt  6 invokespecial  13  lt Method java lang StringBuffer java lang String  gt  9 astore 1 10 aload 1  11 ldc  1  lt String  Lost    gt  13 invokevirtual  15  lt Method java lang StringBuffer append java lang String  gt  16 pop   The bytecode at locations 0 to 9 is executed for the first line of code    StringBuffer str   new StringBuffer  Stanford       The bytecode at location 10 to 16 is then executed for the concatenation    str append  Lost        Notice that  as is the case in the first example  this code invokes the append method of a StringBuffer object  Unlike the first example  however  there is no need to create a temporary StringBuffer and then convert it into a String object  This code creates only one object  the StringBuffer  at location 0   In conclusion  StringBuffer concatenation is significantly faster than String concatenation  Obviously  StringBuffers should be used in this type of operation when possible  If the functionality of the String class is desired  consider using a StringBuffer for concatenation and then performing one conversion to String

User · Answer

A String is immutable  i e  when it s created  it can never change   A StringBuffer  or its non-synchronized cousin StringBuilder  is used when you need to construct a string piece by piece without the performance overhead of constructing lots of little Strings along the way   The maximum length for both is Integer MAX VALUE  because they are stored internally as arrays  and Java arrays only have an int for their length pseudo-field   The performance improvement between Strings and StringBuffers for multiple concatenation is quite significant  If you run the following test code  you will see the difference  On my ancient laptop with Java 6  I get these results    Concat with String took  1781ms Concat with StringBuffer took  0ms   public class Concat       public static String concatWithString                 String t    Cat           for  int i 0  i lt 10000  i                          t   t    Dog                     return t            public static String concatWithStringBuffer                 StringBuffer sb   new StringBuffer  Cat            for  int i 0  i lt 10000  i                          sb append  Dog                      return sb toString              public static void main String   args                long start   System currentTimeMillis            concatWithString            System out println  Concat with String took       System currentTimeMillis   - start     ms            start   System currentTimeMillis            concatWithStringBuffer            System out println  Concat with StringBuffer took       System currentTimeMillis   - start     ms

[java] What is the difference between String and StringBuffer in Java?

Examples related to java

Examples related to string

Examples related to stringbuilder

Examples related to stringbuffer