Skip to main content

So einfach lassen sich Java Strings umkehren und rückwärts darstellen


java programmierung strings umkehren rückwärts

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 ist so ein zusammengesetztes Palindrom.
  • Und da das Regallager aus den Wörtern Regal und Lager besteht und beide Wörter eigenständige Palindrome sind – kannst du diese auch neu zusammensetzen.
  • Somit sind Regallager und auch das Lagerregal komplett von hinten nach vorn lesbar – und ergeben die gleiche Bedeutung.

Übrigens…..
Das längste deutsche Palindrom – Reliefpfeiler – schaffte es sogar in das Guinness Buch der Rekorde.

Was erwartet dich in diesem Beitrag?
Ich möchte dir zeigen, wie du Java Zeichenketten umkehren kannst.
Also wie ein normaler Java String rückwärts dargestellt werden kann.

Dazu….

  • Schauen wir uns ein paar Grundlagen zu Strings an,
  • basteln eine for-Schleife, welche einen String durchlaufen und auslesen soll
  • und schließlich kehren wir dann die For-Schleife einfach um.

Na Bock drauf?
Dann lass uns ein paar Java Strings umdrehen.

So lassen sich Java Strings zeichenweise verarbeiten

Mit der String-Methode charAt() lässt sich jedes Zeichen einer Zeichenkette herauslesen.

Die Methode erwartet aber einen Index, als Argument.
Und anhand dieses Positionsindexes (hier 0 und 4) wird das entsprechende Zeichen zurückgegeben.

public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";

		Character teilEins = textEins.charAt(0);// Speichern des Teilstrings - Position 0 = "H"
		Character teilZwei = textEins.charAt(4);// Speichern des Teilstrings - Position 4 ="o"

	}
}

Wichtig dabei ist…..

  • Wie bei jeder String-Methode, bleibt der ursprüngliche String unverändert.
  • Diesen Teilstring bzw. das einzelne Zeichen kannst du dir in einer Variablen speichern und dann später auslesen lassen.
  • Da aber die charAt()-Methode als Rückgabewert einen Characterdatentypen liefert, musst du den Teilstring auch in einer Variable vom Datentyp Character speichern.
  • Und den gespeicherten Wert aus diesen beiden neuen Char-Variablen, kannst du dann separat auslesen und als Bildschirmausgabe zurückgeben lassen.
public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";

		Character teilEins = textEins.charAt(0);// Speichern des Teilstrings - Position 0 = "H"
		Character teilZwei = textEins.charAt(4);// Speichern des Teilstrings - Position 4 ="o"

		System.out.println(teilEins);// Bildschirmausgabe H
		System.out.println(teilZwei);// Bildschirmausgabe o
	}
}

Alternativ kannst du die Methodenrückgabe direkt in die Bildschirmausgabe einbetten.

public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";
		
		System.out.println(textEins.charAt(0));// Bildschirmausgabe H
		System.out.println(textEins.charAt(4));// Bildschirmausgabe o
	}
}

Bedenke….
Die Teilstrings sind somit nirgendwo gespeichert und lassen sich somit auch nicht weiter verwenden.
Für unsere Zwecke reicht es aber vorerst aus.

Jeder Java String hat eine Länge.

Und dieser lässt sich anhand der Variable „length“ bestimmen.

Denn….
Sobald du einen String in einem Java Programm anlegst, steht dir automatisch diese Instanzvariable aus der String-Klasse zur Verfügung.
Aufgerufen wird diese Variable, wie jede Intanzvariable, direkt an der Referenzvariablen.
In diesem Beispiel „textEins“-Punkt-length.

public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";
		
		System.out.println(textEins.charAt(0));// Bildschirmausgabe H
		System.out.println(textEins.charAt(4));// Bildschirmausgabe o
		
		int laenge = textEins.length();
		System.out.println(laenge);//Länge = 24 Zeichen
	}
}

Auch diesen Wert könntest du in einer Variablen speichern und dann als Bildschirmausgabe zurückgeben lassen.
In unserem Fall hat der String – „Hallo dies ist ein Test!“ – eine Länge von 24 Zeichen.

Und auch hier….
Brauchst du den Wert eigentlich nicht zwischenspeichern.
Sondern kannst dir diesen als Bildschirmausgabe gleich anzeigen lassen.

public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";
		
		System.out.println(textEins.charAt(0));// Bildschirmausgabe H
		System.out.println(textEins.charAt(4));// Bildschirmausgabe o
		
		System.out.println(textEins.length());//Länge = 24 Zeichen
	}
}

Okay so weit so gut.
Bis hierher sind es lediglich die gedanklichen Grundlagen.

Du weißt jetzt:

  1. Wie du an die Länge des Strings kommst.
  2. Und du kennst eine Möglichkeit dir jedes Zeichen des Java Strings separat ausgeben zu lassen.

Was jetzt fehlt – ist eine Schleife.
Diese beginnt bei der Position 0, also beim „H“ und durchläuft den kompletten String bis zur Endposition – length() = 24.

So kannst du den String mit einer for-Schleife durchlaufen und auslesen.

BÄÄM – Hier ist die Schleife.

public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";
		
		for (int i = 0; i < textEins.length(); i ++ ){
			System.out.println(textEins.charAt(i));
		}
	}
}

Wie schon gesagt:

  • Die Schleife beginnt beim Index 0 (int i = 0) und durchläuft den kompletten String.
  • Und zwar solange bis i < textEins.lenghth.
  • Bei jedem Durchlauf wird i erhöht.

Probiere es aus und klicke auf RUN!
Und läuft?

Problem ist nur, dass der Text nicht rückwärts durchlaufen wird.
Jetzt lass und den Java String umkehren.

So kannst du den Java String von hinten nach vorn umkehren.

Bis jetzt waren alles nur Grundlagen.
Die for-Schleife ist aber soweit in Ordnung.
Aber im Schleifenkopf müsstest du jetzt einige Dinge abändern.

  • Aus der Startposition i = 0 wird i = textEins.length().
    Denn du fängst von hinten an.
  • Die Schleife würde somit bei 24 starten und bis zur Stelle 0 laufen.
    Dies wären 25 Positionen und somit eine zu viel.
    Deshalb lautet der Startwert i = textEins.length() - 1 .
  • Aus der Bedingung i < textEins.lenghth wird i > = 0.
    Denn die Schleife soll an der Position 0 aussteigen.
  • Und natürlich darf i nicht mehr erhöht, sondern muss erniedrigt werden.
    Aus i ++ wird i--
public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";
		
		for (int i = textEins.length()-1; i >= 0; i -- ){
			System.out.println(textEins.charAt(i));
		}
	}
}

Und läuft?

Was noch stört ist der doofe Zeilenumbruch nach jedem Zeichen.

Also mach aus der println-Anweisung im Rumpf - eine print-Anweisung.
Und fertig!

public class JavaStringVerarbeiten {
	public static void main(String[] args) {
		String textEins = "Hallo dies ist ein Test!";
		
		for (int i = textEins.length()-1; i >= 0; i -- ){
			System.out.print(textEins.charAt(i));
		}
	}
}

Cool, oder?

Zusammenfassung:

  • Mit der Methode charAt(), welche die String Klasse bereitstellt – kannst du die einzelnen Zeichen einer Zeichenkette extrahieren.
  • Mit einer for-Schleife kannst du das Ganze dann automatisieren.
  • Um die Java Strings dann noch umkehren zu können, musst du nur noch die for-Schleife von hinten nach vorne laufen lassen.

Ähnliche Beiträge