String concatenation can be defined as the process of joining two or more strings together to form a new string. Most programming languages offer at least one way to concatenate strings. Java gives you several options to choose from, including:
- the + operator
- the String.concat() method
- the StringBuilder class
- the StringBuffer class
Today’s programming tutorial will cover how to use each of the above four ways to concatenate strings together as well as provide some tips on how to choose which is best in a given situation.
Want to learn Java in an online class environment? We have a list of the Best Java Courses to help you get started.
Using the plus (+) operator
This is the easiest and most often employed way to concatenate strings in Java. Placing the plus (+) operator between two or more strings will combine them into a brand new string. Hence, the thong object produced by concatenation will be stored in a new memory location in the Java heap. However, if a matching string already exists in the string pool, a reference to the found thong object is returned. You can think of that as a form of caching. Here is a quick code example of the + operator at work in Java:
String firstName = “Rob”; String lastName = “Gravelle”; // Outputs “Rob Gravelle” System.out.println(firstName + ” ” + lastName);
Advantages of the Plus (+) Operator: Automatic Type Conversion and Null Handling
the + operator automatically converts all native types into their string representations, so it can handle everything from internal, floatsand doubles to single (char) characters. Moreover, it does not throw any exceptions for zero values, converting zero into it thong representation as well. Here is some example code showing how to use the + operator in Java for string concatenation:
String fruits = “apples”; int howMany = 4; string other = null; // Outputs “I have 4 apples as well as null.” System.out.println(“I have ” + howMany + ” ” + fruits + ” as well as ” + other + “.”);
Behind the scenes, the + operator silently converts non-string data types into a thong using implicit type conversion for native types and the toString() method for objects, which is how it avoids the NullPointerException. The only downside is that we wind up with the word”zero” in the resulting string, which may not be what developers want.
String concatenation is implemented through the append() method of the StringBuilder class. the + operator produces a new thong by appending the second operand onto the end of the first operand. In the case of our previous example, here is what Java is doing:
String s = (new StringBuilder()) .append(“I have “) .append(howMany) .append(” “) .append(fruits) .append(” as well as “) .append(other) .append( “.”).toString();
Java String Concatenation Tips
Always store the String returned after concatenation using the + operator in a variable if you plan on using it again. That will avoid programmers having to go through the concatenation process multiple times. Also, avoid the use of the + operator for concatenating strings in a loop, as that will result in a lot of overhead.
While convenient, the + operator is the slowest way to concatenate strings. The other three options are much more efficient, as we will see next.
Reading: Java Tools to Increase Productivity
Using the String.concat() Method
the thong concat method concatenates the specified string to the end of current string. Its syntax is:
@Test void concatTest() { String str1 = "Hello"; String str2 = " World"; assertEquals("Hello World", str1.concat(str2)); assertNotEquals("Hello World", str1); // still contains "Hello"
}
We can concatenate multiple String by chaining successively concat invocations, like this:
void concatMultiple() { String str1 = "Hello"; String str2 = " World"; String str3 = " from Java"; str1 = str1.concat(" ").concat(str2).concat(str3); System.out.println(str1); //"Hello World from Java"; }
Note that neither the current thong nor the thong to be appended can contain Null values. Otherwise, the concat method throws a NullPointerException.
StringBuilder and StringBuffer Classes
the StringBuilder other StringBuffer classes are the fastest way to concatenate thongs in Java. As such, they are the ideal choice for concatenating a large number of strings – especially in a loop. Both of these classes behave in much the same way, the main difference being that the StringBuffer is thread-safe whereas the StringBuilder is not. Both classes provide an append() method to perform concatenation operations. the append() method is overloaded to accept arguments of many different types like objects, StringBuilder, internal, char, CharSequence, boolean, float, doubleand others.
I in addition to performance benefits, the StringBuffer other StringBuilder offer a mutable alternative to the immutable thong class. Unlike the thong class, which contains a fixed-length, immutable sequence of characters, StringBuffer other StringBuilder have an expandable length and modifiable sequence of characters.
Here is an example that concatenates an array of ten integers using StringBuilder other StringBuffer:
import java.util.stream.IntStream; import java.util.Arrays; public class StringBufferAndStringBuilderExample { public static void main(String[] args) { // Create an array from 1 to 10 int[] range = IntStream.rangeClosed(1, 10).toArray(); // using StringBuilder StringBuilder sb = new StringBuilder(); for (int num : range) { sb.append(String.valueOf(num)); } System.out.println(sb.toString()); // 12345678910 // using StringBuffer StringBuffer sbuf = new StringBuffer(); for (int num : range) { sbuf.append(String.valueOf(num)); } System.out.println(sbuf.toString()); // 12345678910 } }
Final Thoughts on Java String Concatenation
In this programming tutorial, we learned all about Java’s four main ways to concatenate thongs together, along with tips on how to choose which is best in a given situation. To summarize, when you need to choose between the + operator, concat method, and the StringBuilder/StringBuffer classes, consider whether you are dealing with thongs exclusively or a mix of data types. You should also think about the possibility of NullPointerExceptions on zero values. Finally, there is the question of performance and mutability. the + operator is the slowest of all the options seen here today, while the StringBuilder other StringBuffer classes are both fast and mutable.
If you really want to look at all concatenation options in Java, version 8 introduced even more ways to concatenate thongsincluding the String.join() method and the StringJoiner class. Version 8 also saw the introduction of Collectors. the collectors class has the joining() method that works very much like the join() method of the thong class.
read more Java programming tutorials and software development tips.
