1. Introduce the three categories of String, StringBuffer and StringBuilder

1.String class

java.lang.String is a very important class in Java for representing and manipulating strings. Following are some key points about the String class:

Immutability : StringOnce an object is created, its value cannot be changed. This means that when trying to modify Stringthe object, a new string object is actually created. This feature enables Stringthread safety and caching potential.

String constant pool (String Pool) : In order to improve performance and save memory, Java uses a string constant pool. String constant pool is a special memory area used to store string constants. When creating a string literal (for example String str = "Hello"), if a string with the same content already exists in the constant pool, the reference in the constant pool will be returned directly without creating a new object.

String manipulation : StringThe class provides various methods for manipulating strings, such as splicing ( , concat()operator +), splitting ( split()), extracting substrings ( substring()), and other string processing methods (such as case conversion, character replacement, string comparison, etc.).

Advantages of immutability :

Thread safety: StringThe immutability of the object makes it thread-safe in a multi-threaded environment without additional synchronization measures.

Caching and performance optimization: Since strings are immutable, strings can be shared and cached during compilation to improve program performance and efficiency.

String comparison : StringThe class overrides the equals()and hashCode()method to compare whether the contents of two strings are equal.

equals()method compares the contents of strings for equality.

==operator compares the references of two string objects for equality.

String concatenation :

If you need to concatenate a small number of strings, you usually use +an operator or concat()method.

For large concatenation operations, StringBuilderor should be used StringBuffer, which outperform multiple string concatenations in performance.

Encoding and character set : StringThe class supports conversion between different character sets, such as using getBytes()methods to convert strings to byte arrays, or using getBytes(charset)methods to specify specific character sets for conversion.

2.StringBuffer class

The StringBuffer class is a variable string sequence class provided by Java , defined in the java.lang package. It is similar to the String class, but with one important difference: the String class is immutable, i.e. its contents cannot be changed after creation, whereas the StringBuffer class allows strings to be modified in-place .

Following are some important features of StringBuffer class −

Mutability : The main feature of the StringBuffer class is that its content is mutable and the string can be modified in-place. This allows us to perform operations such as insertion, deletion, and replacement without creating new string objects.

Thread safety : StringBuffer is thread safe, that is, multiple threads can access and modify the contents of the same StringBuffer object at the same time without causing data inconsistency. Its methods are all modified by the synchronized keyword, which can ensure thread safety in a multi-threaded environment.

Performance : Since StringBuffer is mutable, the overhead of creating a large number of intermediate strings is avoided. This is very useful in scenarios where strings are frequently spliced and modified, because it is not necessary to create a new string object for each operation, but directly modify the original string.

Rich API : The StringBuffer class provides many methods to manipulate and modify strings. In addition to the usual methods for adding, inserting, and deleting strings, there are also methods for reversing strings, replacing substrings, truncating substrings, and more. This makes StringBuffer powerful and flexible.

It should be noted that since StringBuffer is designed for thread safety, in a single-threaded environment, you can use the StringBuilder class with better performance, which is similar to the StringBuffer class, but it is not thread safe.

Here is a sample code using StringBuffer:
StringBuffer sb = new StringBuffer();
sb.append("Hello");
sb.append(" ");
sb.append("World");
sb.insert(5, ","); // 在第5个字符位置插入逗号
sb.delete(5, 6); // 删除第5个字符
sb.reverse(); // 反转字符串
System.out.println(sb.toString()); // 输出：dlroW, olleH
By using the StringBuffer class, we can easily perform dynamic operation and modification of strings, and can efficiently handle the needs of string operations.

Tips:

When using synchronizeda decorated instance method, it locks the current instance object. Only the thread that has acquired the lock can execute this method, and other threads need to wait for the lock to be released before they can access this method.

3.StringBuilder class

The StringBuilder class is a variable string sequence class provided by Java, which is similar to the StringBuffer class, but the difference is that StringBuilder is not thread-safe. The StringBuilder class is located in the java.lang package.

Following are some important features of StringBuilder class −

Mutability : The main feature of the StringBuilder class is that its content is mutable and the string can be modified in place. The StringBuilder class is more flexible than the String class because it allows operations such as insertion, deletion, and replacement without creating new string objects.

Not Thread Safe : Unlike StringBuffer class, StringBuilder class is not thread safe . That is to say, when multiple threads access and modify the same StringBuilder object at the same time, data inconsistency may result. Therefore, if you use variable strings in a multi-threaded environment, you should use the thread-safe StringBuffer class.

Performance : Since StringBuilder is variable, it avoids the overhead of creating a large number of intermediate strings and improves performance. In a single-threaded environment, StringBuilder is more efficient than StringBuffer because it does not require synchronization .

Rich API : The StringBuilder class provides many methods to manipulate and modify strings. It has the same API as the StringBuffer class, including methods such as adding, inserting, deleting, reversing, replacing, and substring interception. This makes StringBuilder powerful and flexible.

In a single-threaded environment, by using the StringBuilder class, we can easily perform dynamic manipulation and modification of strings, and can efficiently handle string manipulation requirements. However, in a multi-threaded environment, it is recommended to use the thread-safe StringBuffer class to ensure data consistency.

4. What is a string constant pool

The string constant pool is a special memory area in Java for storing string constants. Its main feature is that the strings in the string constant pool are immutable, that is, they cannot be modified after they are created.
String s1 = "Hello"; // 字符串常量池中创建了一个字符串对象"Hello"
String s2 = "Hello"; // 由于字符串常量池中已存在相同内容的字符串对象"Hello"，所以直接引用已存在的对象
String s3 = new String("Hello"); // 在堆内存中创建了一个新的字符串对象"Hello"
String s4 = new String("Hello"); // 在堆内存中创建了另一个新的字符串对象"Hello"

System.out.println(s1 == s2); // 输出：true，s1和s2引用同一个字符串对象
System.out.println(s1 == s3); // 输出：false，s1和s3引用不同的字符串对象
System.out.println(s3 == s4); // 输出：false，s3和s4引用不同的字符串对象
System.out.println(s1.equals(s3)); // 输出：true，s1和s3的值相等
During code execution, a pool of string constants is maintained in the string constant pool to avoid repeated creation of string objects with the same content. When we use string direct assignment or use string literal to create a string object, we will first check whether there is already a string object with the same content in the string constant pool, and if it exists, directly reference the existing object; if If it does not exist, create a new string object in the string constant pool. When using the new keyword to create a string object, no matter whether there is a string object with the same content in the string constant pool, a new string object will be created in the heap memory.

It should be noted that using the string constant pool can save memory, but it is recommended to use the StringBuilder or StringBuffer class when performing string concatenation and other operations that frequently modify the string content to avoid unnecessary object creation and memory overhead.

Give another example for easy understanding
String s1 = "abc";
String s2 = new String("abc");
String s3 = "abc";
String s4 = new String("abc");  
//创建了几个String对象
Let's analyze briefly:

1.String s1 = "abc"; : This line of code will create a String object "abc" in the string constant pool. If there is already an object with the same content in the constant pool, directly refer to the existing object.

2.String s2 = new String("abc"); : This line of code will create a new String object "abc" in the heap memory, because the new keyword is used, no matter whether there is an object with the same content in the constant pool, will create a new object.

3.String s3 = "abc"; : This line of code does not create a new object, but assigns the existing object reference in the constant pool to s3.

4.String s4 = new String("abc"); : This line of code will create another new String object "abc" in the heap memory, even if there is an object with the same content in the constant pool.

So, a total of 3 String objects are created. Among them, s1 and s3 refer to the same object in the constant pool, while s2 and s4 are new objects created in the heap memory according to the new keyword.

4. Why does the StringBuilder class not need to perform synchronization operations

Because the StringBuilder class is not thread-safe, data inconsistency may occur when multiple threads access and modify the same StringBuilder object concurrently. However, since the StringBuilder class does not require synchronization, its performance is slightly better than that of the StringBuffer class in a single-threaded environment.

Tips:

Concurrent access refers to the behavior of multiple threads or processes accessing shared resources at the same time. Concurrent access occurs when multiple threads or processes attempt to read, write, or modify the same shared resource at the same time.

In the case of concurrent access, since the execution of threads or processes is parallel and alternate, the following problems may arise:

Race Condition : When multiple threads or processes try to write to the same resource at the same time, due to the uncertainty of the execution order, it may lead to uncertainty or wrong results.

Data inconsistency : When multiple threads or processes modify shared resources at the same time, if proper synchronization is not performed, data inconsistency may result, that is, part of the data is modified, but other threads or processes may see the same as before the modification The data.

Deadlock (Deadlock) : When multiple threads or processes are waiting for other threads or processes to release resources, a circular waiting state is formed, resulting in the inability of all threads or processes to continue executing.

Concurrent access is an important concept in common multithreaded programming. When dealing with concurrent access, it is necessary to use appropriate synchronization mechanisms (such as locks, semaphores, atomic operations, etc.) to ensure data consistency and correctness of concurrent access.

2. Common interview questions about String, StringBuffer and StringBuilder

1. Why String is immutable

The main reason String is designed to be immutable is to improve performance, security, and utilization of the string constant pool . Here's an explanation of why String is immutable and its underlying array logic:

1. Performance optimization : Since String is immutable, once created, its value cannot be changed. This means that strings can be cached and reused to improve performance. In the string constant pool, if there are string constants with the same value, you can directly refer to the existing object, avoiding the creation of multiple objects with the same value.

2. Thread safety : Since String is immutable, it can be shared in a multi-threaded environment without additional synchronization measures. Each thread operates its own copy and will not interfere with each other, avoiding thread safety issues.

3. Hash hash optimization : Since String is immutable, its hash value (obtained through the hashCode() method) only needs to be calculated once and can be cached. This is great for fast insertion, lookup, and comparison of strings. 4. Underlying array logic : The underlying implementation of String is a character array (char[]), which is used to store the content of the string. When a String object is created, its value is stored in the array, and the length of the array is fixed and cannot be expanded or reduced.

5. Side effects of string modification : Since String is immutable, every time a string is modified, a new string object will be created. This means that when a string is modified, additional memory needs to be used to store the new string object, and the old string object becomes unreachable and eventually garbage collected.

To sum up, String is immutable in order to improve performance, ensure thread safety, optimize hash hashing, and utilize string constant pool. Its underlying layer is a character array. Once created, its value cannot be modified, and a new String object needs to be created to represent the modified string.

Tips:

Starting from the Java 9 version, Java introduced the Compact Strings feature, and the underlying implementation of String has changed . For most character sets, String is no longer a simple character array.

The Compact Strings feature was introduced to improve storage efficiency. In the old implementation, each character was stored using 2 bytes (16 bits), even for ASCII characters that only required 1 byte. This wastes space, especially when storing large numbers of ASCII characters. Compact Strings save space by storing character data of different lengths. The specific implementation method is that the inside of the String object contains a byte array (byte[]) and a field identifying the length. When the string contains only ASCII characters, the character data will be stored in the byte array in the form of bytes, and each byte corresponds to a character. When the string contains any non-ASCII characters, it will be stored in other ways to support a larger character set. Such an implementation can still access and manipulate string data as a character array in most cases, especially when the string contains only ASCII characters. New implementations may need to perform some additional conversion operations only when accessing the byte representation of the string is required .

Summary: In different versions of Java, the underlying implementation of String may be different.

2. What is the difference between StringBuffer and StringBuilder?

I will explain the difference between StringBuffer and StringBuilder from the following points

thread safety

StringBuffer is thread safe. Its method is synchronized through the synchronized keyword, so it is safe to use in a multi-threaded environment. Multiple threads can access and modify the same StringBuffer object at the same time without causing data conflicts or concurrent modification problems.
StringBuilder is not thread safe. Its methods are not synchronized, and there is no additional synchronization overhead, so better performance can be obtained in a single-threaded environment. However, in a multi-threaded environment, if multiple threads access and modify the same StringBuilder object at the same time, data inconsistency may occur.

performance

The method of StringBuffer uses the synchronized keyword for synchronization, so it is safe and reliable in a multi-threaded environment, but it will bring a certain performance overhead. Using StringBuffer may result in slightly lower performance if multi-threaded operations are not involved.
The method of StringBuilder is not synchronized and has no additional synchronization overhead, so it has better performance in a single-threaded environment. Because it doesn't have to deal with thread safety, it's usually faster than StringBuffer.

variability

Both StringBuffer and StringBuilder provide variable string operations, such as append(), insert(), delete(), etc. They allow for easy modification and splicing of strings.
The methods of StringBuffer are all thread-safe, so additional synchronization operations are required when modifying strings, resulting in slightly lower performance.
The method of StringBuilder does not add synchronization operations, so it can directly perform faster operations in a single-threaded environment.

scenes to be used

If you need to perform string operations in a multi-threaded environment , or pay attention to thread safety, you should use StringBuffer , which can ensure data consistency and is suitable for concurrent operations or shared object scenarios.
If you perform string operations in a single-threaded environment and need better performance, you can choose to use StringBuilder , which has no synchronization overhead and is suitable for building and modifying strings in a single-threaded environment.

To sum up, StringBuffer is suitable for multi-threaded or thread-safe scenarios, while StringBuilder is suitable for single-threaded and high-performance scenarios. In most cases, if there is no requirement for thread safety, it is recommended to use StringBuilder because of its higher performance.

3. Why is using StringBuilder more efficient than using String in the case of frequent string splicing or modification?

Mutability : StringBuilder is mutable while String is immutable. When we splice or modify an existing string, String will create a new string object, while the original string object remains unchanged. This means that every splicing or modification will generate a new string object, resulting in frequent object creation and destruction , resulting in waste of memory and performance. Instead, StringBuilder can be modified in a mutable string buffer, avoiding the overhead of creating new objects.

Performance optimization : StringBuilder internally uses an expandable character array (char[]) to store string data . It will dynamically adjust the capacity to meet the needs of the splicing operation, avoiding the overhead of frequently reallocating memory space. In contrast, String needs to create a new string object every time it is concatenated or modified, and the overhead of memory allocation and copying is relatively large.

Unified performance : When using StringBuilder for frequent splicing and modification, all operations are performed on the same object, without additional object creation and destruction. This consistency can improve performance, especially in scenarios where loops or large numbers of strings are concatenated, significantly reducing the pressure on memory management and garbage collection.

Note : Although StringBuilder is more efficient than String in most cases, it also needs to be selected according to specific needs and application scenarios. If you perform string operations in a multi-threaded environment or need thread safety, you should choose StringBuffer; if you perform string operations in a single-threaded environment and focus on performance, StringBuilder is a better choice. For simple string concatenation, using String's plus operator (+) is also efficient enough. The best choice depends on your specific use case and performance needs.

Tips:

When the capacity of StringBuilder's internal character array (char[]) is not enough to accommodate new characters, it will automatically expand to accommodate more characters.

The following is a simple sample code that uses StringBuilder to concatenate strings and demonstrate its expansion mechanism:
package com.xw.framework;

public class test {
public static void main(String[] args) {
	StringBuilder sb = new StringBuilder();
	System.out.println("初始容量：" + sb.capacity());

	// 拼接字符
	for (int i = 1; i <= 20; i++) {
	    sb.append("Char").append(i).append(" ");
	    System.out.println("当前容量：" + sb.capacity());
	}

	String result = sb.toString();
	System.out.println("最终结果：" + result);
}
}
Example output:

In this example:

StringBuilderThe initial capacity of the object is 16.

Every time a new character is spliced, if the current capacity is not enough to hold the character, the capacity StringBuilderwill be expanded. Typically, scaling doubles the current capacity. But it does not expand every time, only when it is actually needed.

After gradually splicing characters, the capacity increases sequentially. It can be observed that the capacities are 16, 34, 70, 142 respectively. Double the original base and add two more, (16*2)+2=34 ....(34*2)+2=70....(70*2)+2=142.. ...

The end result is a string of 20 characters concatenated.

4. How to choose the appropriate type among String, StringBuffer and StringBuilder?

Thread safety requirements : If you need to perform string operations in a multi-threaded environment, or need to ensure thread safety, you should select it StringBuffer. StringBuffer The method is thread-safe, using synchronization operations to ensure that multiple threads can safely access and modify the same object. But this also comes with some performance overhead.
If you operate strings in a single-threaded environment, or you don't need to consider thread safety, you can choose StringBuilder or String.

Performance requirements : String It is immutable, and a new string object will be created every time a string is modified, so the performance is low in frequent string concatenation or modification operations. If performance is a key factor, it should be preferred StringBuilder.

StringBuilder It is variable and has no synchronization overhead, suitable for frequent string concatenation and modification operations.

StringBuffer It can also be used for frequent string operations, but since it is thread-safe, each method is synchronized, and the performance may be slightly lower StringBuilder.

Initialization size and estimated string length : If you know the approximate length of the string or the expected number of characters, you can consider initializing StringBuilder or StringBuffer initial capacity to avoid unnecessary expansion operations.

Considering the above factors, you can choose according to your actual needs:

Select if thread safety or string manipulation in a multi-threaded environment is required .StringBuffer

If frequent string concatenation or modification operations are performed in a single-threaded environment , and thread safety is not required, select can achieve better performance. StringBuilder

If the string is a constant or only requires a small amount of splicing operations , and there is no need to modify the string content , String it can be used directly.

It is necessary to select the appropriate type according to specific scenarios and needs to obtain the best performance and functions.

I hope this blog can help you understand the differences and usage scenarios of String, StringBuffer and StringBuilder! !

The difference between String, StringBuffer and StringBuilder (interview questions)

1. Introduce the three categories of String, StringBuffer and StringBuilder

1.String class

2.StringBuffer class

3.StringBuilder class

4. What is a string constant pool

4. Why does the StringBuilder class not need to perform synchronization operations

2. Common interview questions about String, StringBuffer and StringBuilder

1. Why String is immutable

2. What is the difference between StringBuffer and StringBuilder?

3. Why is using StringBuilder more efficient than using String in the case of frequent string splicing or modification?

4. How to choose the appropriate type among String, StringBuffer and StringBuilder?

Guess you like