Skip to main content

3 Möglichkeiten – Java Strings verketten und zusammenfü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.

Ähnliche Beiträge

Java Übung 31: Speichere deine Würfe im Array

Java Übung Array Würfelspiel

In dieser Java Übung soll ein Würfelspiel simuliert werden. Lege eine Klasse namens, Würfelspiel an. Diese Klasse enthält eine statische Methode, namens würfeln(). Diese Methode erwartet einen Parameter vom Datentyp Integer, namens „anzahlWuerfe“. Diese Variable/Parameter repräsentiert die Anzahl der Würfe. Nachdem der Methode die Anzahl der Würfe übergeben wurde, soll die Methode Zufallszahlen zwischen 1 […]

So kannst du ein Java Programm starten und Argumente übergeben

Um ein Java Programm starten zu können, benötigst du immer die main-Methode. Das Programm startet immer genau an dieser Stelle. Alle lokalen Variablen, welche du in der Main Methode anlegst, kannst du dann im Programm nutzen. Auch alle Methoden, welche du innerhalb des Methodenrumpfes der main-Methode aufrust, werden ausgeführt. Was ist aber vor der main-Methode. […]

Java for Schleifen schachteln – So funktioniert es

Java For Schleifen schachteln

Diese Situation kennst du doch auch…. Du stehst an der Haltestelle und wartest auf den Bus. Dein Blick fällt auf die Uhr.   Oder du wartest an der Ecke auf deinen Freund oder Kollegen. Immer wieder schaust du auf deine Uhr.   Sie ist kaum noch wegzudenken. Die mobile Taschenuhr.   Lange Zeit wurde die […]

Java Übung 27 – Auf zur Mathe-Olympiade

Java Übung Mathe Olympiade

In dieser Java Übung möchte ich mit dir ein Programm erstellen, welches ein Mathematik-Test oder eine Mathe-Olympiade simuliert. Du kennst das vielleicht noch aus der Schule. Matheolympiade- Da wurden aus allen vier Grundrechenarten, Aufgaben formuliert. Die Schüler mussten diese Aufgaben lösen. Die Lehrer kontrollierten die Lösungen. Und der Schüler, welcher die wenigsten Fehler hatte – […]

Der wichtige Unterschied zwischen Java Methoden

Java Methoden Unterschied

Jetzt machen wir Nägel mit Köpfen. Dieses Sprichwort stammt aus den Anfängen des Industriezeitalters. Denn früher wurden Nägel nicht industriell, sondern per Hand gefertigt. Und da kam es schon einmal vor, dass versehentlich Nägel ohne Kopf produziert wurden. Was blieb ist das Sprichwort „Nägel mit Köpfen“ Und dieses steht sinngemäß für eine schnelle, qualitativ hochwertige […]

So kannst du Eclipse installieren

Eclipse installieren

Das Schöne an Eclipse ist, es läuft auf sämtlichen Betriebssystemen. Eclipse wird einfach auf der Webseite des Herstellers herunter geladen und kann dann installiert werden. Dabei stehen dir verschiedene Versionen zur Verfügung.

8 Java Datentypen, die du kennen solltest

Java Datentypen

Java Datentypen Ich gebe zu, ich hasse dieses Thema. Denn es ist eigentlich nichts weiter als graue Theorie. Dennoch müssen wir dieses Thema behandeln. Um schnell in das Thema zu kommen, stelle ich dir eine Übersicht aller primitiven Datentypen zur Verfügung. Wieso primitive? Es gibt außer den primitiven Datentypen, noch Referenztypen. Und diese Referenztypen sind […]

Java Exceptions Handling – Fehler- und Ausnahmenbehandlung in Java

Java Exceptions Handling

Java Exceptions Handling umfasst den richtigen Umgang mit Ausnahmen und Fehlern. Wie geht das? Und braucht man so etwas wirklich? Vielleicht sagst du jetzt: „Brauch ich nicht. Ich mache niemals Fehler.“ Doch… Bei der Java Fehlerbehandlung geht es nicht ausschließlich nur um deine Programmierfehler. Es geht auch um falsche Nutzereingaben, Hardware- und Ablauffehler. Und deshalb […]