We know that by default strings are immutable in nature. However, there are many restrictions in an immutable string, when it comes to string handling. That is why Java provides us with two classes, StringBuffer and StringBuilder, that helps programmers take a mutable string as input and work with them. There are pros and cons to both these classes, and it is necessary to know which one to use and when. In this article, we will see StringBuffer vs StringBuilder in detail.<\/p>\n
The StringBuffer class was introduced into the Java Programming Language with Java 1.0v. This class was introduced for the sole purpose of transforming a string into a mutable object. But there arose a problem while using this class in a multi-thread environment.<\/p>\n
The methods in this class are public and synchronized, so naturally, they cannot be used simultaneously in multiple threads. This was the main disadvantage of using StringBuffer. But the StringBuffer class also ensures thread safety.<\/p>\n
The StringBuffer class allows changes in the string. Adding the property of mutability to a string. It also leads to providing safety to a thread by ensuring that the thread must execute one after the other.<\/p>\n
Code to explain Java StringBuffer Class:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n To put it in simple words, the StringBuilder class was introduced in the Java 1.5v update to replace the StringBuffer class.<\/p>\n The StringBuilder class solves the problem of Multithreading easily. It contains an additional provision of non-synchronized methods which gives it compatibility to run in a multi-thread environment.<\/p>\n Although, it works fastly but it lacks in providing a safety to the thread. Threads are not synchronized so there is no blocking of the thread while the other is in running state. But programmers still prefer the StringBuilder class over the StringBuffer Class.<\/p>\n Code to understand Java StringBuilder class:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n Summarization of a few important points regarding StringBuffer and StringBuilder<\/strong><\/p>\n 1. StringBuffer class was present right from the beginning when Java was introduced. The StringBuilder class was introduced with version 1.5 update to compensate for the mistakes made in the StringBuffer class.<\/p>\n 2. The methods present in the StringBuffer class, like append(), delete(), replace(), etc are synchronized in nature. Whereas the same methods of the StringBuilder class are non-synchronized.<\/p>\n 3. The synchronized methods of the StringBuffer class provides thread safety but the StringBuilder class has non-synchronized methods and so it\u2019s not thread-safe.<\/p>\n 4. To perform string manipulation in a multi-threaded environment we should use the StringBuilder class, but if there is no multi-threaded environment involved, then StringBuffer can be better due to thread safety.<\/p>\n 5. The StringBuilder class is way faster than the StringBuffer class, as synchronization is not required in it.<\/p>\n Even though the StringBuffer is thread-safe, programmers still prefer the StringBuilder as it is way faster. Code to understand the performance of Java StringBuffer and StringBuilder:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n We can clearly see that the StringBuilder is Faster than the StringBuffer class. The greater the number of operations the greater will be the difference in time.<\/p>\n The time to execute the program depends on the performance of the machine on which it runs.<\/p>\n Code to convert StringBuilder and StringBuffer object to String in Java:<\/strong><\/p>\n The output of the above code:<\/strong><\/p>\n In this article, we saw how StringBuilder and StringBuffer have similarities and differences of their own. It is the work of the programmer to understand the situation and implement the better of the two classes for the purpose of the program. We discussed, in brief, the two classes and when to use them with regard to the environment of the system.<\/p>\n","protected":false},"excerpt":{"rendered":" We know that by default strings are immutable in nature. However, there are many restrictions in an immutable string, when it comes to string handling. That is why Java provides us with two classes,...<\/p>\n","protected":false},"author":5,"featured_media":108884,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[32],"tags":[3897,13909,13910,13911,13920,13923,13924,13925],"class_list":["post-15105","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-difference-between-stringbuffer-and-stringbuilder-in-java","tag-string-vs-stringbuffer","tag-string-vs-stringbuffer-vs-stringbuilder-in-java","tag-string-vs-stringbuilder","tag-stringbuffer-in-java","tag-stringbuffer-vs-stringbuilder","tag-stringbuilder-vs-stringbuffer","tag-stringjoiner"],"yoast_head":"\npackage com.DataFlair.Stringbuffer;\r\npublic class Append\r\n{\r\n public static void main(String args[])\r\n { \r\n StringBuffer str=new StringBuffer(\"Data\"); \r\n str.append(\"Flair\"); \r\n System.out.println(str);\r\n } \r\n} \r\n<\/pre>\nStringBuilder class in Java<\/h3>\n
package com.DataFlair.StringBuffervsStringbuilder;\r\npublic class Append\r\n{\r\n public static void main(String args[])\r\n { \r\n StringBuilder str=new StringBuilder(\"Data\"); \r\n str.append(\"Flair\"); \r\n System.out.println(str);\r\n } \r\n}\r\n<\/pre>\n\n\n
\n Parameter<\/b><\/td>\n StringBuffer<\/b><\/td>\n StringBuilder<\/b><\/td>\n<\/tr>\n \n Storage Area<\/b><\/td>\n Heap<\/span><\/td>\n Heap<\/span><\/td>\n<\/tr>\n \n Mutability<\/b><\/td>\n Yes<\/span><\/td>\n Yes<\/span><\/td>\n<\/tr>\n \n Thread Safety<\/b><\/td>\n Yes<\/span><\/td>\n No<\/span><\/td>\n<\/tr>\n \n Speed<\/b><\/td>\n Very Slow<\/span><\/td>\n Fast<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n Difference between StringBuilder vs StringBuffer in Java<\/h3>\n
\nLet us summarize the differences and similarities into a table:<\/p>\n\n\n
\n SL.No.<\/b><\/td>\n StringBuffer Class in Java<\/b><\/td>\n StringBuilder Class in Java<\/b><\/td>\n<\/tr>\n \n 1<\/span><\/td>\n The strings in the StringBuffer class are always mutable.<\/span><\/td>\n The strings in the StringBuilder class are also always mutable.<\/span><\/td>\n<\/tr>\n \n 2<\/span><\/td>\n It is thread-safe<\/span><\/td>\n It is not thread-safe.<\/span><\/td>\n<\/tr>\n \n 3<\/span><\/td>\n Present from Java 1.0<\/span><\/td>\n Introduced in Java 1.5<\/span><\/td>\n<\/tr>\n \n 4<\/span><\/td>\n It can use only one thread at a time, thus always ensuring thread safety.<\/span><\/td>\n It can use multiple threads at a time, and may or may not violate thread safety.<\/span><\/td>\n<\/tr>\n \n 5<\/span><\/td>\n If multiple threads have to be used, they need to wait for synchronization, thus adding a lot of time to execution.\u00a0<\/span><\/td>\n Multiple threads can operate together without synchronization, thus working a lot faster.<\/span><\/td>\n<\/tr>\n \n 6<\/span><\/td>\n Performance is very low<\/span><\/td>\n Performance is High<\/span><\/td>\n<\/tr>\n \n 7<\/span><\/td>\n The object is allocated heap memory.<\/span><\/td>\n The object is allocated heap memory.<\/span><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n package com.DataFlair.StringBuffervsStringbuilder;\r\npublic class PerformanceAnalysis\r\n{\r\n public static void main(String[] args)\r\n { \r\n long startTime = System.currentTimeMillis(); \r\n StringBuffer str1 = new StringBuffer(\"DataFlair\"); \r\n for (int i=0; i<10000000; i++)\r\n { \r\n str1.append(\"StringBuffer\"); \r\n } \r\n System.out.println(\"Time taken by StringBuffer in Millisecond is: \" + (System.currentTimeMillis() - startTime) + \"millisec\"); \r\n startTime = System.currentTimeMillis(); \r\n StringBuilder str2 = new StringBuilder(\"DataFlair\"); \r\n for (int i=0; i<10000000; i++)\r\n { \r\n str2.append(\"StringBuilder\"); \r\n } \r\n System.out.println(\"Time taken by StringBuilder in Millisecond is: \" + (System.currentTimeMillis() - startTime) + \"millisec\"); \r\n } \r\n}\r\n<\/pre>\n
\nTime taken by StringBuilder in Millisecond is: 316millisec<\/div>\npackage com.DataFlair.StringBuffervsStringbuilder;\r\npublic class Conversion\r\n{\r\n public static void main(String[] args) {\r\n StringBuffer str1 = new StringBuffer(\"DataFlair\");\r\n StringBuilder str2 = new StringBuilder(\"StringBuffer vs StringBuilder\");\r\n String str1C = str1.toString();\r\n System.out.println(\"StringBuffer object to String: \");\r\n System.out.println(str1C);\r\n String str2C = str2.toString();\r\n System.out.println(\"StringBuilder object to String: \");\r\n System.out.println(str2C);\r\n }\r\n}\r\n<\/pre>\n
\nDataFlair
\nStringBuilder object to String:
\nStringBuffer vs StringBuilder<\/div>\nConclusion<\/h3>\n