Java String concat() with examples

This tutorial will explain how to concat strings in Java, including different methods and examples of concatenating strings. String concatenation refers to the process of combining two or more strings into a single string. The term “append” denotes adding an extra string to an existing string variable.

The are various ways for concat string so we will try to learn all of them one by one with examples. This tutorial contains all of the useful information that you need to get started working with strings and concatenating them.

Post On:	Java String concat() in Java
Post Type:	Java Tutorials
Published On:	www.softwaretestingo.com
Applicable For:	Freshers & Experience
Get Updates:	SoftwareTestingo Telegram Group

Java String Concatenation meaning

A Java String is an object that contains a sequence of characters. Strings are immutable, which means they can’t be changed after they’re created. However, you can append strings together by using java concatenation methods.

Before going deep into it you need to have some basic knowledge of strings in order to understand the concatenation process. You can learn more about Java strings from this article. In this tutorial, we’ll cover multiple ways to concatenate strings using the Java programming language.

Different Ways to Concatenate String in Java

There are a few different ways you can concatenate strings in Java. The most common methods are listed below:

• Using + operator
• Using StringBuffer class
• Using StringBuilder class
• Using String.concat() method

Using + Operator

The string that results from concatenation using the + operator will be a new String pointing to a fresh memory location in the Java heap. If there’s already a string object in that pool, it’ll return that same string object; otherwise, it creates a new one.

There are some important things to keep in mind when using the + operator for joining strings:

• The + operator should be avoided when concatenating strings in a loop as it will create a lot of garbage.
• You should always store references to objects that are returned after concatenating strings using the + operator.
• You can convert an integer to a string in java by using the + operator.

package com.SoftwareTestingO.Strings;
public class StringConcatUsingoperator 
{
	public static void main(String[] args) 
	{
		String s1 = "Welcome";
		String s2 = "Java";
		String s3 = s1 + s2;
		System.out.println("String 1: " + s1);
		System.out.println("String 2: " + s2);
		System.out.println("Concatenated string: " + s3);
	}
}

Using a String Buffer

This is a more efficient way to concatenate java strings. Rather than using the + operator, which creates a new object of the resulting string, using String Buffer saves memory space.

When concatenating strings using a string buffer, initialize the string buffer object with a capacity equal to the number of characters in the final concatenated string. This will result in more efficient memory usage as well as saving time spent during resizing of characters.

One downside to this approach is that the append methods by StringBuffer are synchronized. However, it otherwise works similarly to the StringBuilder method. Additionally, it provides various overloaded append methods to concatenate characters, integers, shorts, etc.

The following is the simple syntax of the StringBuffer class.

StringBuffer NewStringBuffer = new StringBuffer();
NewStringBuffer.append(stringName);

Example:

package com.SoftwareTestingO.Strings;
public class StringConcatUsingStringBuffer 
{
	public static void main(String[] args) 
	{
		String s1 = "Welcome";
		String s2 = "Java";

		// create StringBuffer Instance
		StringBuffer newstring=new StringBuffer();

		// using append method to concatenate strings
		StringBuffer concatenate=newstring.append(s1).append(s2);

		// printing
		System.out.println(concatenate);
	}
}

With the append() method we can use two different data types like below:

package com.SoftwareTestingO.Strings;
public class StringConcatUsingStringBuffer 
{
	public static void main(String[] args) 
	{
		String s1 = "Welcome to SoftwareTestingo on: ";
		Integer s2 = 2022;

		// create StringBuffer Instance
		StringBuffer newstring=new StringBuffer();

		// using append method to concatenate strings
		StringBuffer concatenate=newstring.append(s1).append(s2);

		// printing
		System.out.println(concatenate);
	}
}

Using String Builder

One of the best methods to concatenate strings in Java is by using the StringBuilder class. This method is easy and efficient to use when you need to append multiple strings together. However, this method is not commonly used when you only need to concatenate two strings.

package com.SoftwareTestingO.Strings;
public class StringConcatUsingStringBuilder 
{
	public static void main(String[] args) 
	{
		String s1 = "Welcome to SoftwareTestingo on: ";
		Integer s2 = 2022;

		// create StringBuffer Instance
		StringBuilder newstring=new StringBuilder();

		// using append method to concatenate strings
		StringBuilder concatenate=newstring.append(s1).append(s2);

		// printing
		System.out.println(concatenate);
	}
}

Using String.concat() method

This method appends some specific Strings to the end of the string. It creates a char array whose length is equal to the combined lengths of both strings being joined. This method copies the String data into a new string using the private String constructor. The private String constructor does not copy the input char[].

package com.SoftwareTestingO.Strings;
public class StringConcatUsingConcat 
{
	public static void main(String[] args) 
	{
		String s1 = "Welcome to : ";
		String s2 = "SoftwareTestingo";

		// java string concatenation 
		String s3 = s1.concat(s2);
		System.out.println(s3);
	}
}

Performance:

It’s important to be mindful of how you concatenate strings in Java, as it can have an impact on performance. Let’s see which method is best for string concatenation in terms of performance.

It is always best to use StringBuilder to concatenate strings in Java. This will provide the best performance as it outperforms all other methods. We can easily test that it is several hundred times faster than using the + operator and concat() method in Java. Additionally, StringBuilder performs better than StringBuffer due to the overhead caused by the thread safety of StringBuffer.

Conclusion

The ‘string concatenation operation’ refers to the process of joining two strings together. In this tutorial, we learned about how to do this in Java. There are four different methods that can be used for string concatenation in Java, which are: using the StringBuffer class, using the Plus operator, using the concat() method, and using the StringBuilder class.