Samenvoegen van strings

Java:
Samenvoegen van strings

Hoe:

Hier is de snelle uitleg over hoe je strings kunt samenvoegen in Java:

public class StringConcatenationDemo {
    public static void main(String[] args) {
        String firstName = "John";
        String lastName = "Doe";
        
        // Met de plus-operator
        String fullName = firstName + " " + lastName;
        System.out.println(fullName); // Output: John Doe
        
        // Met de concat()-methode
        String anotherFullName = firstName.concat(" ").concat(lastName);
        System.out.println(anotherFullName); // Output: John Doe
        
        // Met StringBuilder voor meerdere samenvoegingen
        StringBuilder builder = new StringBuilder();
        builder.append(firstName).append(" ").append(lastName);
        System.out.println(builder.toString()); // Output: John Doe
    }
}

Diepere duik

Het samenvoegen van strings lijkt simpel genoeg, toch? Het zit al vanaf het begin in Java en we hebben een paar manieren om het te doen. Eerdere Java-versies gebruikten StringBuilder onder de motorkap wanneer je een simpele + deed. Toen kwam Java 5, en dingen werden efficiënter met de introductie van de StringJoiner en meer verbeteringen aan de StringBuilder klasse.

Nu vraag je je misschien af waarom niet altijd de + operator gebruiken als het hetzelfde is? Blijkt dat + geweldig is voor een snelle klus met kleine strings of een paar samenvoegingen. Achter de schermen kan het echter qua prestaties kostbaar worden als je het in een lus met veel iteraties gebruikt omdat het tijdelijke objecten creëert voordat de uiteindelijke stringversie bereikt wordt.

In die zware gevallen, gebruik je StringBuilder of StringBuffer. StringBuilder is doorgaans sneller omdat het niet gesynchroniseerd is - waardoor het thread-unsafe maar snel is. StringBuffer is de oudere, thread-safe optie. Het is trager vanwege de synchronisatie-overhead. Kies op basis van je behoeften aan thread safety.

Voor de concat() methode, het is eenvoudig maar niet zo flexibel als StringBuilder. Wil je in een lus blijven en meer strings toevoegen? concat() is minder handig.

Vanaf Java 8 en verder hebben we ook String.join() wat best netjes is voor het samenvoegen van verzamelingen strings met een scheidingsteken.

Zie ook