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

So einfach lassen sich Java Strings umkehren

Java Strings umkehren

Kennst du noch das Lied „ANNA“ von Freundeskreis? Da hieß es: Du bist von hinten, wie von vorne A-N-N-A. Solche Namen oder Wörter, welche von hinten nach vorne gelesen – die gleiche Bedeutung haben, nennt man Palindrome. Anna, Ehe oder Ebbe sind recht kurze Palindrome. Aber auch längere zusammengesetzte Palindrome kennt die deutsche Sprache: Regallager […]

So nutzt du die While Schleife in deinem Java Programm

Java While Schleife

Manchmal ist es wichtig, Dinge einmal öfter zu tun. Bei der Java Programmierung kann es schonmal sein, dass du einen Code mehrfach ausführen lassen musst. Zum Beispiel die Zahlen eins bis zehn. Ein Java Programm, welches die Zahlen eins bis zehn wiedergibt. Na wie wäre das? Der Java Code dazu würde so aussehen: public class […]

Java lernen von Kopf bis Fuß

Wenn du Java lernen möchtest, kannst du an meinem kostenlosen Java Kurs teilnehmen. Aber manch Einer hätte gern eine zweite Meinung. Und da bieten sich natürlich Java Bücher an. Eines dieser Java Bücher möchte ich dir jetzt vorstellen. Dieses Buch nennt sich „Java von Kopf bis Fuß“. Was kannst du von diesem Buch erwarten? Also […]

So implementierst du Instanzmethoden in deine Java Klasse

Java Instanzmethoden

In einen der letzten Beiträge habe ich dir gezeigt, wie du eine Klasse anlegen kannst. Ich habe die Klasse „Mensch“ oder „Human“ angelegt und wir haben die erste Instanzvariable implementiert. Dein Code sollte jetzt so aussehen: public class Human { int size=156;//size in centimeter } In diesem Beitrag werde ich dir zeigen, wie du Java […]

So kannst du ein neues Java Projekt mit Eclipse anlegen und konfigurieren

Java Projekt anlegen Eclipse

In diesem Beitrag möchte ich dir zeigen, wie du ein neues Java Projekt mit Eclipse anlegen kannst. Ich werde dir außerdem einen kurzen Überblick über die Konfigurationsmöglichkeiten geben. Dann gebe ich dir noch eine ganz einfache Schritt-für-Schritt-Anleitung für dein allererstes Java Projekt und ich zeige dir, was nach dem Anlegen des Projektes eigentlich passiert ist.

Das Instanzieren von Java Klassen verhindern

Java Objekte Instanzieren verhindern

Die Instanzierung von Java Klassen verhindern. Was heißt das? Instanzen sind die Objekte einer Java Klasse. Und Instanzieren oder Instanzierung heißt nichts anderes, als Objekterstellung. Aber was soll das? Oder mal anders gefragt: Wieso sollte man verhindern, dass eine Java Klasse – Objekte erstellen kann? Schließlich sind doch Objekte der Sinn und Zweck jeder objektorientierten […]

So kannst du Java Arrays mit for Schleife füllen und auslesen

Java Arrays For Schleife

Wir haben in einem anderen Beitrag bereits über Java Arrays gesprochen. So ein Array speichert Zahlen, Texte oder Objekte in eine Art Liste. Und dann kannst du ganz bequem über den Index das Array füllen und die bereits enthaltenen Werte abrufen. Ganz bequem? So, wie ich dich aus dem letzten Beitrag entlassen habe, war das […]

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 […]