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 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.

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

Nutze das Keyword this für deine Java Konstruktoren

Java konstruktoren this

Es ist gemein. Wahrscheinlich hast den Beitrag zu den lokalen Variablen gelesen. Vielleicht hast du auch den Artikeln zum Anlegen und Überladen von Java Konstruktoren gelesen. Und wenn du die beschriebene Inhalte selbst ausprobiert hast…… Dann hast du dir wahrscheinlich sehr viele lokale Variablennamen für die Parameterliste ausdenken müssen.

Java Übung 17: Char-Zeichen mit For-Schleife

Java Übung Char Zeichen For Schleife

In dieser Java Übung werden wir uns die Zeichen des Character Datentypen näher anschauen. Die einzelnen Zeichen sollen auf der Konsole ausgegeben werden. Und wie? Das ganze sollst du mit einer For Schleife machen. Erstelle deshalb eine Klasse „CharZeichen“. In dieser Klasse implementierst du dann eine Klassenmethode, namens „gibZeichen“. Und im Methodenrumpf durchläuft eine For-Schleife […]

Der bedeutende Unterschied zwischen Klassenvariablen und Instanzvariablen

Java Klassenvariablen

Bei der Java Programmierung unterscheidet man drei Arten von Variablen. Als erste Gruppe sind die lokalen Variablen zu nennen. Auf diese gehe ich in einem separaten Artikel ein. Mich interessieren die zwei anderen Variablentypen. Zum einen existieren Klassenvariablen. Und dann sind da noch die Instanzvariablen. Wo liegt der Unterschied? Instanzvariablen stehen einem Objekt zur Verfügung. […]

Java Binärzahl in Dezimalzahl umwandeln – So geht’s.

Java-Binärzahl-umrechnen

Erinnerst du dich? In einer der letzten Beiträge haben wir uns die Zusammenhänge zwischen dem dualen und dem dezimalen Zahlensystem angeschaut. Aber wir haben noch keine Java Binärzahl in eine Dezimalzahl verwandelt. Zumindestens nicht praktisch…. Stattdessen…. Haben wir festgestellt, dass beide Zahlensysteme im Grunde genommen sehr ähnlich sind. Beim Dezimalsystem spielt die Zahl 10, als […]

So verwendest du den Java Oder Operator

Java Oder Operator

Kennst du das auch aus deiner Schulzeit? Du schreibst eine Klassenarbeit in irgendeinem Fach. Nehmen wir einfach mal an – Mathe. Jetzt bist gerade fertig mit deiner Arbeit. Und zu Hause wirst du gefragt: „Und wie lief es?“ Du antwortet:“ Ganz gut. Es wird bestimmt eine Eins oder eine Zwei.“ Drei oder vier Tage später […]

Du bekommst was du vereinbarst – Die Rückgabewerte von Java Methoden

Java Methoden Rückgabetypen

Was du vereinbarst, das bekommst du zurück. Ach wäre es schön, wenn alles im Leben so funktionieren würde. Aber zum Glück funktioniert dieses Prinzip bei deinen Java Methoden. Denn du kannst den Rückgabetypen im Methodenkopf vereinbaren. Doch bevor ich dir zeige, wie du den Rückgabetypen anlegen kannst…. Lass mich dir zeigen, wofür du den Kram […]

Du musst in Java nicht jede Exception fangen

Java Exception fangen

Kennst du die Metapher mit dem Jongleur und den Bällen? Ein Jongleur hält drei Bälle in der Luft, dann vier und irgendwann fünf. Aber irgendwann ist es genau ein Ball zu viel. Und Alles bricht zusammen. Ja ein Ball zu viel, kann alles versauen. 🙂 Und so ist es doch immer im Leben. Du kannst […]