This is the third day of my participation in the August Text Challenge.More challenges in August

The difference between String and StringBuffer and StringBuilder in Java

introduce

String is one of the most commonly used classes in Java, and strings are one of the most important topics in Java interviews.

The StringBuffer and StringBuilder classes provide methods for manipulating strings.

We’ll look at the differences between StringBuffer and StringBuilder.

The distinction between StringBuffer and StringBuilder is a common interview question in Java.

To print the contents of the program on the console, use String. This blog introduces the main features of the String class, and then we’ll compare the StringBuffer and StringBuilder classes.

String

Pay attention to a common mistake, don’t remember wrong. Because String is final, it cannot be inherited. So String is not a Java base data type. Strings are immutable in Java and therefore suitable for use in multithreaded environments. When we create a string using double quotes, as follows, the JVM first looks for strings with the same value in the string pool.

String str1 = "ABC";
Copy the code

If found, it returns a reference to the string object in the string pool. Otherwise, it creates a string object in the string pool and returns a reference. The JVM saves a lot of memory by using the same string in different threads.

If a string is created using the new operator, it is created in the heap.

The + operator is overloaded for String, and we can use it to concatenate two strings. Internally, though, it uses A StringBuilder to perform this action.

Two strings are equal only if they have the same string, and the equals() method is case sensitive. If you are looking for case-insensitive checks, you should use the equalsIgnoreCase() method.

Concatenated string

Because strings are immutable in Java, every time we perform String concatenation, it generates a new String and discards the old String for garbage collection. These repeated operations can create a lot of garbage redundancy in the heap. So Java provides classes StringBuffer and StringBuilder, which should be used for string manipulation. StringBuffer and StringBuilder are mutable objects in Java.

They provide append, INSERT, DELETE, and SubString methods for string operations.

Prior to Java 1.4, StringBuffer was the only option for string manipulation. However, one disadvantage is that all public methods are synchronous. StringBuffer provides thread-safety, but at the expense of performance.

In most cases, we won’t use strings in multithreaded environments. So Java 1.5 introduced a new class, StringBuilder, which is similar to StringBuffer, except for thread safety and synchronization.

StringBuffer has some additional methods, such as SubString, Length, Capacity, trimToSize, and so on. However, these are not required, because String also has all of them. This is why these methods are never implemented in the StringBuilder class.

StringBuffer was introduced in Java 1.0, and the StringBuilder class was introduced in Java 1.5 after looking at the shortcomings of StringBuffer.

Assume that in a single-threaded or thread-independent environment, StringBuilder is used. Instead, use StringBuffer for thread-safe operations.

conclusion

• Strings are immutable, whereas StringBuffer and StringBuilder are mutable classes.

• StringBuffer is thread-safe and synchronous, StringBuilder is not. This is why StringBuilder is faster than StringBuffer.

• The string concatenation operator (+) uses the StringBuilder class internally.

• For string operations in non-multithreaded environments, we should use StringBuilder or use the StringBuffer class.