Bemærk venligst, at dette blogindlæg blev udgivet i januar 2011, så afhængigt af hvornår du læser det, kan visse dele være forældede. Desværre kan jeg ikke altid holde disse indlæg fuldt opdaterede for at sikre, at oplysningerne forbliver nøjagtige.
As a web developer working with Java Servlets on a daily basis, I find my self often concatenating Strings all the time to create blocks of HTML, JavaScript, SQL (and so on) code to be used by the site. However, even the basic thing as concatenating Strings in Java could be more complicated than you thought when you looking under the hood.
The big question
In Java Strings are immutable, meaning once they are created they cannot be changed. So, if they cannot be changed and you want to modify the String, how do you do that the most efficient way without wasting resources?
The different ways and how they work
The three most common ways to concatenate a String is either by using the regular String concatenation (the "+=" operator), or using the StringBuilder (introduced in Java 5) or the StringBuffer (which is the synchronized version) classes.
Each time you do a regular String concatenation, a new Java object will be created. Meaning the code "A" + "B" would leave three objects in the memory ("A", "B" and "AB"). However, this does not mean it's a total waste of resources. If you actually want the result of two Strings together (a+b), you might as well simply just do the regular concatenation instead of create a new StringBuilder/StringBuffer, because the Java compiler will most likely optimize it and you won't notice a difference in performance at all.
But if you are planing to build up a large String in a loop and only needing the result at the very end, StringBuilder/StringBuffer is a better option, since regular concatenation has a O(N2) complexity while StringBuilder has O(N) in complexity, due to StringBuilder instead contains a sequence of characters.
The bottom line is that String concatenation is always going to be less efficient than using a StringBuilder/StringBuffer. Even looking at the Javadoc of StringBuilder, StringBuffer is less efficient than StringBuilder:
Where possible, it is recommended that this class be used in preference to StringBuffer as it will be faster under most implementations.
But don't sacrifice code readability
Even thought using StringBuilder might be the most efficient way, don't sacrifice the readability of your code as it is also important. Typical code like:
String message = new StringBuffer().append("Welcome ").append(name).append(". What do you want to do").toString();
which can be written much more readably as:
String message = "Welcome " + name + ". What do you want to do?";
The Rule of thumb
- Using the regular String concatenation is fine for a single statement
- If you're looping to build up a large data of characters, go for StringBuffer.
- Don't sacrifice code readability; getting confused or not understanding the code at all is often far more worse than decreased performance
What I do
Ever since I researched the different ways to concatenate Strings in Java, I always tend to automatically create a StringBuilder (over the regular String concatenation and StringBuffer) when dealing with large texts. Mostly because I know it's almost always the most efficient way to manipulate Strings. Even though it's unsynchronized it's very rare I need to share the information between threads.
