Java String concat() Method

What You’ll Learn

The concat() method joins one string to the end of another and returns a new combined string. It is a readable, method-based alternative to the + operator for simple two-string joins.

Definition and Usage

In Java, concat(String str) belongs to java.lang.String. When you call greeting.concat("World!"), Java creates a new string containing the characters of greeting followed by "World!". The greeting variable still points to the old text unless you assign the result back to it.

Because strings are immutable, every concatenation produces a fresh object. That design keeps strings thread-safe and predictable, but it also means you should not call concat() thousands of times in a tight loop without a StringBuilder.

📝 Syntax

The concat() method is declared in the String class:

public String concat(String str)

Parameters

• str — the string appended to the end of the caller. Must not be null.

Return Value

Returns a new String whose content is the caller followed by str.

Exceptions

Throws NullPointerException if str is null.

Examples Gallery

These programs run in Java 8+. They cover basic joining, immutability, chaining, comparison with +, and when to reach for StringBuilder.

public class StringConcatenation {
    public static void main(String[] args) {
        String originalString = "Hello, ";
        String appendString   = "World!";

        String resultString = originalString.concat(appendString);

        System.out.println("Concatenated: " + resultString);
        System.out.println("Original still: " + originalString);
    }
}

Concatenated: Hello, World!
Original still: Hello, 

public class ImmutableDemo {
    public static void main(String[] args) {
        String word = "Code";

        word.concat("ToFun");  // return value ignored!

        System.out.println("word is still: " + word);

        word = word.concat("ToFun");  // assign the result
        System.out.println("word now:    " + word);
    }
}

word is still: Code
word now:    CodeToFun

public class ChainConcat {
    public static void main(String[] args) {
        String result = "Java"
            .concat(" is ")
            .concat("fun")
            .concat("!");

        System.out.println(result);
    }
}

Java is fun!

public class ConcatVsPlus {
    public static void main(String[] args) {
        String first  = "Hello";
        String second = "Java";

        String withConcat = first.concat(", ").concat(second);
        String withPlus   = first + ", " + second;

        System.out.println("concat(): " + withConcat);
        System.out.println("+ operator: " + withPlus);
        System.out.println("Same content? " + withConcat.equals(withPlus));
    }
}

concat(): Hello, Java
+ operator: Hello, Java
Same content? true

public class BuilderLoop {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();

        for (int i = 1; i <= 5; i++) {
            sb.append("Item ").append(i).append("; ");
        }

        String report = sb.toString().trim();
        System.out.println(report);
    }
}

Item 1; Item 2; Item 3; Item 4; Item 5;

🚀 Common Use Cases

• Building messages — combine a label and a value: "Score: ".concat(scoreText).
• File paths and URLs — append path segments when you already hold base strings.
• Method-style chaining — readable pipelines that append fixed suffixes.
• Teaching immutability — show that string operations return new objects.
• Legacy APIs — some libraries expect explicit concat() instead of operators.

📝 Notes

• Strings are immutable—concat() never edits the caller in place.
• The + operator is the most common concatenation style in modern Java code.
• concat() accepts only String; use + or String.valueOf() to append numbers.
• Concatenating with empty string "" returns a string equal in content to the caller.
• For repeated joins, use StringBuilder or String.join() / String.format() when appropriate.

⚡ Optimization

A single concat() call is efficient and fine for joining two strings. Inside loops, avoid s = s.concat(part) because each iteration allocates a new string copying everything so far. Use StringBuilder.append() instead, then call toString() once at the end. The Java compiler also optimizes some compile-time + chains automatically.

💡 Best Practices