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

Ein Java Fenster erzeugen mit dem JFrame

Java-Fenster-erzeugen

Ein Java Fenster erzeugen mit Swing. Java Swing – was ist das? Zum Erstellen von grafischen Benutzeroberflächen, kurz GUI, bietet Java eine eigene Standardklasse an. Diese Klasse nennt sich Swing. Aus dieser Swing-Klasse heraus können Objekte erstellt werden. Diese Objekte lassen sich in vier verschiedene Kategorien einteilen. Fenster und Dialoge bilden das Grundgerüst einer grafischen […]

10 ganz nützlichen Feature der Klasse Java Math

In diesem Beitrag geht es um eine spezielle Java Klasse. Die Klasse nennt sich Java Math. Diese ist in der Standardbibliothek von Java enthalten. Warum solltest du diese Klasse kennen? Die Math Klasse bietet dir einen Menge Methoden an, welche zur Berechnung von mathematischen Gleichungen ganz hilfreich sind. Aber auch für Nichtmathematiker ist etwas dabei. […]

So organisierst und verwaltest du ganz bequem deine Java Projekte

Du kennst das auch. Denn du bist ja fleißig. Und weil du so fleißig bist, hast du mitunter auch mehrere Java Projekte gleichzeitig laufen. Und dann kommt es vor, dass du enorm viele Java Projekte am Laufen hast. Und dein Package-Explorer wird extrem unübersichtlich. In diesem Beitrag möchte ich dir zwei Varianten vorstellen, wie du […]

So kannst du dein Java Programm mit der main Methode ausführen

Auf zum ersten Java Programm. Vielleicht fragst du dich jetzt gerade: Na, was haben wir denn bisher gemacht? War das etwa kein Java Programm? Wir haben bisher nur eine Klasse „Human“ für ein zuküntfiges Mensch-Objekt erstellt. Diesem Objekt haben wir eine Instanzvariable, namens size (Größe) zugeordnet. Und wir haben eine Instanzmethode, namens grow (wachsen) geschrieben. […]

So unterstützen dich Java Vererbungstabellen beim Entwurf

Java Vererbungstabellen

Bei der Java Vererbung gibt es zwei Klassenarten bzw. -stufen. Die Superklassen, welche einen allgemeinen Typen darstellen Und die spezielleren Unterklassen, welche die Superklasse um bestimmte Funktionen erweitern. Jetzt ist dieses ganze „Der-erbt-von-dem-Konzept“ mitunter sehr schwierig darzustellen. Zum Beispiel in einem Werkzeugkoffer. In einem Werkzeugkoffer befinden sich sämtliche Werkzeuge, von Säge bis Bohrmaschine. Wie machst […]

Verwalte deine Java Klassen in packages

java klassen verwalten

Es macht durchaus Sinn deine Java Klassen in verschiedenen Paketen zu organisieren. Wieso? Es sprechen mehrere Gründe dafür: Du kannst doppelte Klassennamen verwenden Du kannst deinen Code oder deine Klassen inhaltlich trennen Du kannst Hierarchien abbilden. Und genau um diese Dinge geht es in diesem Beitrag