Skip to main content

3 Möglichkeiten, um Java Strings zu verketten und zusammenzufügen


Kennst du dieses Relikt längst vergangener Tage?

Java-String-verketten

Ein Brief.
Ja früher einmal war es üblich, Briefe zu schreiben.
Lange bevor es Smartphones oder Email gab.

Man stelle sich einmal vor….
Die Leute mussten sich hinsetzen mit einem Blatt und einem Stift – und richtig schreiben.
Nein nicht tippen – schreiben.

Grausame Welt, oder?
Aber dennoch.
Ein echter Brief hat immer auch etwas Persönliches.
Er sagt etwas über den Verfasser und über die Beziehung zwischen Absender und Empfänger aus.

Was einmal in einem verschickten Brief verfasst wurde, hat Bestand.
Und deshalb hat man sich auch ganz genau überlegen müssen, was man in diesem Brief schrieb.

Nicht so wie heute….
Wo belangloses Zeug von Smartphone zu Smartphone hin- und hergesendet wird.

Manche Briefe übermittelten lediglich Glückwünsche oder Urlaubsgrüße.
Aber so mancher Liebesbrief enthielt sehr viel Herzschmerz.
Der Brief war somit auch Ausdruck für Sehnsucht und Verlangen.

Aus so manchen Briefwechsel wurden echte Freundschaften.
Eine sehr berühmte Brieffreundschaft bestand zwischen Karl Marx und Friedrich Engels.
Diese Briefwechsel wurden sogar in einem Buch aufgelegt und veröffentlicht.

Jetzt stell dir einmal vor….
Du schreibst einen Brief an deinen Lieblingsmenschen.
Am Ende des Briefes setzt du ganz gekonnt und stilvoll deine Unterschrift darunter.
Und auf einmal bemerkst du, dass in der Mitte des Briefes etwas fehlt.

Es fehlt nicht nur irgendetwas Belangloses.
Nein es fehlt etwas Entscheidendes.

Einen sehr wichtigen Aspekt wolltest du unbedingt aufschreiben.
Und dieser fehlt jetzt.

Klar könntest du ein einfaches „PS. Ich liebe Dich“ darunter setzen.
Aber dieses würde niemals die Stimmung so transportieren, wie du es vorhattest.

Dein einziger Ausweg:
Du musst den kompletten Brief nochmals schreiben.

Oh mein Gott…
Ich will gar nicht wissen, wie oft der alte Marx und Engels – Briefe doppelt schreiben mussten.

Doch zum Glück gibt es heute Programme, mit denen man elektronisch schreibt.
Klar die persönliche Note und die individuelle Handschrift fehlt.
Aber in den elektronischen Briefen kannst du jederzeit Texte einfügen, diese verketten und ersetzen.

Und deshalb nehme ich diese neuen Möglichkeiten einmal auf und zeige dir – wie du in Java Strings verketten bzw. zusammenfügen kannst.

Ein Problem von Zeichenketten in Java ist – Sie sind starr.

Nimm irgendeinen String.
Völlig egal, ob du diesen mit einem Konstruktor oder ohne erzeugst.

public class JavaStringsVerketten {

	public static void main(String[] args) {
		String textEins = new String ("Beispieltext Eins ");//String mit Konstruktoraufruf
		String textZwei ="Beispieltext Zwei";//String ohne Konstruktor
		
	}
}

Du kannst nicht, ohne weiteres, einen neuen Text anhängen.
 
Klar könntest du bei der Bildschirmausgabe, mittels Plus-Operator, etwas rumspielen.

public class JavaStringsVerketten {

	public static void main(String[] args) {
		String textEins = new String ("Beispieltext Eins ");
		String textZwei ="Beispieltext Zwei";
		
		String textDrei= textEins + textZwei;//Zusammensetzen der Texte
		
		System.out.println(textDrei);//Bildschirmausgabe
	}
}

Aber am eigentlichen String-Objekt wird nichts verändert.
Du müsstest also immer wieder neue String-Objekte anlegen und diese dann abrufen.
 
Es stellt sich somit die Frage:

„Wie kann man an einem bestehenden Java String – ganz flexibel neue Zeichenketten oder Textteile hinzufügen?“

 

Möglichkeit 1: Die Zeichenketten in einem Array speichern und dann die Java String zusammenfügen.

Arrays sind schon eine tolle Möglichkeit mehrere Strings entgegen zu nehmen.
Der Vorteil liegt darin, dass du nur ein String-Array brauchst und in diesem sämtliche Teiltexte speichern kannst.

Okay – also machst du dir ein Array mit einer bestimmten Länge und packst in jedes Fach einen neuen String.

public class JavaStringsVerketten {

	public static void main(String[] args) {
		String [] texte = new String [3];//String Array mit 3 Fächern
		texte[0]="Hallo";//Belegung Fach 1
		texte[1]=" mein";//Belegung Fach 2
		texte[2]=" Freund";//Belegung Fach 3
		
		System.out.print(texte[0]+texte[1]+texte[2]);//Bildschirmausgabe
	}
}

Besser und schöner ist es, das Array mit for Schleife und Bildschirmeingabe zu füllen.


import java.util.Scanner;//Importanweisung Scanner

public class JavaStringsVerketten {

	public static void main(String[] args) {
		String [] texte = new String [3];//String Array mit 3 Fächern
		
		Scanner scan = new Scanner(System.in);//Neues Scannerobjekt
		
		for (int i =0 ; i< texte.length;i++){
			System.out.println("gib Text ein!");//Auforderung zur Bildschirmeingabe
			texte[i]=scan.next();//Eingabe wird in das Fach i gespeichert 
		}
		
		System.out.println(texte[0]+texte[1]+texte[2]);//Bildschirmausgabe
	}
}

Und eine zweite for-Schleife könnte dann das Array auslesen und dir dann die Werte auf dem Bildschirm anzeigen.

import java.util.Scanner;

public class JavaStringsVerketten {

	public static void main(String[] args) {
		String [] texte = new String [3];//String Array mit 3 Fächern
		
		Scanner scan = new Scanner(System.in);//Neues Scannerobjekt
		
		/*
		 * For Schleife füllt Array
		 */
		for (int i =0 ; i< texte.length;i++){
			System.out.println("gib Text ein!");//Auforderung zur Bildschirmeingabe
			texte[i]=scan.next();//Eingabe wird in das Fach i gespeichert 
		}
		
		/*
		 * For-Schleife zum Lesen und Ausgeben
		 */
		for (int i = 0; i<texte.length;i++){
			System.out.print(texte[i]);
		}		
	}
}

Klar kann man machen.
Problem ist nur, dass Arrays ebenfalls starr sind.
Die Fächeranzahl ist von vorneherein vorgegeben.

Natürlich könntest du das Array dynamisch erweitern lassen.
Aber vielleicht gibt es bessere hausgemachte Möglichkeiten.
 

Möglichkeit 2: Java String mit dem Stringbuilder verketten.

Eine solche hausgemachte Möglichkeit ist der StringBuilder.
Diesen bringt nämlich die Java Bibliothek bereits mit.
 
Um den StringBuilder zu verwenden, musst du lediglich ein Objekt der StringBuilder-Klasse anlegen.

public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();// neues Objekt der Klasse StringBuilder
	}

}

Und dann kannst du mit der append()-Methode sämtliche neuen Textteile hinzufügen.

public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();// neues Objekt
		sb.append("Hallo");
		sb.append(" mein");
		sb.append(" Freund");
		
		System.out.println(sb);//Rückgabe
	}

}

Besonders toll ist….
Dem StringBuilder ist es völlig egal, wie du die Texte verknüpfst.
Du kannst ihm einen Text übergeben oder den Verweis auf einen Java String.
Der StringBuilder schluckt Alles und gibt dir dann sehr schön deine zusammengefügten Texte zurück.

public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();// neues Objekt
		String str = "Dieser Text wird verkettet.";//Stringvariable
		sb.append(str);//Verketten des Strings - str
		sb.append("Und dieser Text auch.");//Verknüpfung mit Zeichenkette
		
		System.out.println(sb);//Rückgabe
		
	}

}

Du kannst mit dem StringBuilder Texte verketten, aber auch Zahlen.


public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();// neues Objekt
		String str = "Dieser Text wird verkettet.";
		sb.append(str);//Verketten des Strings str
		sb.append("Und dieser Text auch.");
		sb.append(2);//Die Zahl 2 wird ebenfalls verkettet
		
		System.out.println(sb);//Rückgabe
		
	}

}

Oder du übergibst diesem einen Wahrheitswert.
Kein Problem für den StringBuilder.

public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();// neues Objekt
		String str = "Dieser Text wird verkettet.";
		sb.append(str);//Verketten des Strings str
		sb.append("Und dieser Text auch.");
		sb.append(true);//Der Wahrheitswert wird ebenfalls verknüpft
		
		System.out.println(sb);//Rückgabe
		
	}

}

Den verketten String kannst du dir dann auch in einer neuen Variablen abspeichern.
Nutze dafür die toString()-Methode.


public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();// neues Objekt
		String str = "Dieser Text wird verkettet.";
		sb.append(str);//Verketten des Strings str
		sb.append("Und dieser Text auch.");
		sb.append(true);//Der Wahrheitswert wird ebenfalls verknüpft
		
		str = sb.toString();//Variable str mit allen Zeichenketten
		
		System.out.println(str);//Rückgabe des Strings
		
	}

}

Somit hast du die Möglichkeit Teiltexte zu speichern und diese bei Bedarf miteinander zu verknüpfen.

Natürlich kannst du auch mit dem StringBuilder -Java Strings mit einer Bildschirmeingabe verknüpfen.

import java.util.Scanner;

public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuilder sb = new StringBuilder();// neues Objekt

		Scanner scan = new Scanner(System.in);//Speichert die Abbruchbedingung
		Scanner scan2 = new Scanner(System.in);//Speichert den Text
		int abruch = 1;// Bei Eingabe 0 = Abbruch

		while (abruch != 0) {
			System.out.println("Weiter? ");//Abfrage der Abbruchbedingung
			abruch = scan.nextInt();//Speichern der Abbruchvariablen
			
			if (abruch != 0) {
				System.out.println("Neuer Text");//Aufforderung zur Texteingabe
				sb.append(scan2.next());//Hinzufügen der neuen Zeichenkette
			}
		}
		System.out.println(sb);//Bildschirmausgabe
	}

}
  • Als Erstes brauchst du zwei Variablen „scan“ und „scan2“.
  • Die Variable „scan“ soll entscheiden ob weitere Zeichenketten vernüpft werden sollen.
    Sobald du die Zahl 0 eingibst, würde das Programm enden und dir den kompletten Text zurückgeben.
    Falls du eine andere Zahl eingibst, springt das Programm in den if-Block und führt diesen aus.
  • Die zweite Variable „scan2“ nimmt dann im if-Block die eingegebenen Texte entgegen und verkettet diese.
  • Da die ganze Prozedur beliebig oft wiederholt werden soll, bietet sich eine while Schleife für die Umsetzung an.

Möglichkeit 3: Analog kannst du Java Strings auch mit dem StringBuffer verknüpfen.

Der StringBuffer funktioniert nach dem gleichen Prinzip.

  • Objekt anlegen
  • Append-Methode am Objekt aufrufen und neue Zeichenketten hinzufügen
public class JavaStringsVerketten {

	public static void main(String[] args) {
		StringBuffer  sb = new StringBuffer ();// neues StringBuffer-Objekt
		String str = "Dieser Text wird verkettet.";
		sb.append(str);//Verketten des Strings str
		sb.append("Und dieser Text auch.");
	
		System.out.println(sb);//Bildschirmausgabe
		
	}

}

 

Zusammenfassung:

  • Um Java Strings verketten zu können, kannst du den StringBuilder oder den StringBuffer nutzen.
  • Durch die mitgelieferte append-Methode ist es recht einfach Zeichenketten zusammen zu fügen.
  • Die Rückgabe der append()-Methoden kannst du dir entweder separat abspeichern oder dir direkt ausgeben lassen.

Über den Autor

wissen
Folge Sciodoo und bleibe stets auf dem Laufenden. Schließ dich uns an und abonniere unseren Instagram-Kanal ein. Wir stellen täglich neue Artikel für dich rein.
Weiter zum Kanal>>>
     

Ähnliche Beiträge