Skip to main content

So lassen sich Java Strings in char zerlegen

Java Strings sind Zeichenketten.
Und diese Zeichenketten lassen sich aufsplitten und in ihre Einzelteile zerlegen.

Ich möchte dir in diesem Beitrag Möglichkeiten vorstellen, wie du Strings in Character-Datentypen zerlegen, extrahieren und die Einzelteile in Arrays speichern kannst.

So lassen sich Java Strings zeichenweise zerlegen.

Java Strings sind Objekte.
Genau genommen sind diese, Objekte der Standard-Java-Klasse String.

Das bedeutet:
Immer wenn du einen String anlegst, bekommst du die Standardmethoden der Klassen-Bibliothek automatisch dazu.

Und eine dieser Standard-Methoden heißt: charAt().
Diese Methode hat eine Parameterliste, welche die Eingabe eines Index-Wertes einfordert.
Und dieser Index-Wert ist vom Datentyp Integer – also eine ganze Zahl.

Was macht die Methode?
Sie gibt dir das Zeichen zurück, welches du als Index übergeben hast.

Am Beispiel:
Du legst in deinem Java-Programm einen x-beliebigen String an.
Es ist völlig egal, ob du diesen mittels Konstruktoraufruf oder ohne diese anlegst.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";// String-Objekt ohne Konstruktor
		String s2 = new String("Das ist ein zweiter Java String");// Objekt mit Konstruktoraufruf

	}
}

Nun hast du zwei String-Objekte.

Bedenke:
Wenn du eine Methode auf String-Objekte anwenden möchtest, musst du den Rückgabewert in einem neuen Objekt speichern.

Das heißt:

  • Du musst eine neue Variable anlegen.
    Die Methode charAt(index) – gibt einen Wert vom Datentyp Character zurück.
    Du musst deshalb den Rückgabewert auch in einer Character-Variablen abspeichern.
  • Dann weist du dieser Variablen den Rückgabewert mittels Zuweisungsoperator (=) zu.
  • Und dann rufst du die Methode char(index) am Objekt auf.

Klingt schwierig – ist es aber gar nicht.
So geht’s.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";
		String s2 = new String("Das ist ein zweiter Java String");

		char char1 = s1.charAt(12);//char1 speichert die Rückgabe der Methode am Objekt s1
		System.out.println(char1);// Rückgabe J

		char char2 = s2.charAt(12);//char2 speichert die Rückgabe der Methode auf dem Objekt s2
		System.out.println(char2);// Rückgabe z
	}
}

Beiden Methodenaufrufen habe ich, den Wert 12 übergeben.
Für den ersten String wäre das 12-te Zeichen ein J.
Und beim zweiten String wäre das 12-te Zeichen ein z.

Zu diesem Zeitpunkt bekommst du genau ein Zeichen zurück.
Wir möchten erreichen, dass uns der komplette String, Zeichen-für-Zeichen, zurückgegeben wird.

So lässt du die charAt()-Methode am kompletten String durchlaufen.

Strings haben, wie Arrays auch, eine Länge.

Du kannst dir die Länge ganz einfach ausgeben lassen.
Rufe dafür die Methode length() am jeweiligen String-Objekt auf.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";
		String s2 = new String("Das ist ein zweiter Java String");

		System.out.println(s1.length());// String s1 mit Länge 23
		System.out.println(s2.length());// String s2 mit Länge 31
	}
}

Und jetzt da du die Länge der einzelnen Java Strings kennst – kannst du eine for-Schleife erstellen.
Diese for-Schleife durchläuft den kompletten String und gibt diesen Zeichen-für-Zeichen zurück.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";
		String s2 = new String("Das ist ein zweiter Java String");

		// for Schleife für s1
		for (int i = 0; i < s1.length(); i++) {
			System.out.println(s1.charAt(i));// Zeichen an der Stelle i
		}

		// for Schleife für String s2
		for (int i = 0; i < s2.length(); i++) {
			System.out.println(s2.charAt(i));// Zeichen an der Stelle i
		}
	}
}

Ganz kurz zum Schleifenkopf.

  • Die Schleife startet bei i =0.
    Denn der erste Index ist immer 0.
  • Das Schriftzeichen „D“ in beiden Strings befindet sich somit an der Stelle 0.
  • Die Schleife durchläuft den String solange bis s1.length oder s2.length erreicht ist.
  • Im Falle des ersten Strings hast du 23 Durchläufe und im zweiten String 31 Durchläufe.
  • Bei jedem Durchlauf wird der Index i um eins erhöht. (i++)

Im Schleifenrumpf wird dann die charAt()-Methode am jeweiligen String Objekt aufgerufen.
Es wird jeweils das entsprechende Zeichen, an der Stelle des for-Schleifen-Indexes (i), ausgegeben.

Um jetzt die Werte zu speichern, brauchst du ein Array.

So lassen sich die Schriftzeichen des Strings in einem Array speichern.

Du benötigst zwei Char-Arrays mit einer Länge, welche den Strings entsprechen.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";
		String s2 = new String("Das ist ein zweiter Java String");
		char[] zeichen1 = new char[s1.length()];// Char-Array mit Länge 23
		char[] zeichen2 = new char[s2.length()];// Char-Array mit Länge 31
	}
}

Und dann speicherst du die entsprechenden Werte in das jeweilige Char-Array.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";
		String s2 = new String("Das ist ein zweiter Java String");
		char[] zeichen1 = new char[s1.length()];// Char-Array mit Länge 23
		char[] zeichen2 = new char[s2.length()];// Char-Array mit Länge 31

		// Die Zeichen des Strings s1 werden im Array zeichen1 gespeichert
		for (int i = 0; i < zeichen1.length; i++) {
			zeichen1[i] = s1.charAt(i);// Speicherung an der Stelle i
		}

		// Die Zeichen des Strings s2 werden im Array zeichen2 gespeichert
		for (int i = 0; i < zeichen2.length; i++) {
			zeichen2[i] = s2.charAt(i);// Speichern an der Stelle i
		}
	}
}

Um dann die Werte aus dem Array zu lesen, benötigst du wieder eine For-Schleife.
Und diese for-Schleifen durchlaufen dann beide Arrays und geben das Zeichen an der Stelle i zurück.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";
		String s2 = new String("Das ist ein zweiter Java String");
		char[] zeichen1 = new char[s1.length()];
		char[] zeichen2 = new char[s2.length()];

		// Die Zeichen des Strings s1 werden im Array zeichen1 gespeichert
		for (int i = 0; i < zeichen1.length; i++) {
			zeichen1[i] = s1.charAt(i);// Speicherung an der Stelle i
		}

		// Die Zeichen des Strings s2 werden im Array zeichen2 gespeichert
		for (int i = 0; i < zeichen2.length; i++) {
			zeichen2[i] = s2.charAt(i);// Speichern an der Stelle i
		}

		// For Schleife zum Lesen des Arrays zeichen1
		for (int i = 0; i < zeichen1.length; i++) {
			System.out.println(zeichen1[i]);// Ausgabe an der Stelle i
		}

		// For Schleife zum Lesen des Arrays zeichen2
		for (int i = 0; i < zeichen2.length; i++) {
			System.out.println(zeichen2[i]);// Rückgabe an der Stelle i
		}
	}
}

Was jetzt noch irgendwie blöd ist, ist die Tatsache, dass du ein Char-Array mit char-Werten hast.
Es wäre doch besser String-Werte in einem String-Array zu haben.

So lassen sich Char-Werte in String-Werte umwandeln.

Die Methode nennt sich valueOf().
Sie wird am jeweiligen String-Objekt aufgerufen.

Sie ist außerdem überladen.
Das heißt – du kannst ihr sämtliche Datentypen übergeben und bekommst einen String zurück.

Für unser Programm hieße dies:
Die Speicherung der char-Werte soll zukünftig in einem String-Array erfolgen.
Und dafür müssen die Methodenrückgaben:

  • s1.charAt(i)
  • s2.charAt(i)

umgewandelt werden.

Und heraus kommt dann:

  • s1.valueOf(s1.charAt(i))
  • s2.valueOf(s2.charAt(i))

Und so sieht die Rückverwandlung und Speicherung der Zeichen in einem String-Array aus.

public class StringsZerlegen {

	public static void main(String[] args) {
		String s1 = "Das ist ein Java String";
		String s2 = new String("Das ist ein zweiter Java String");
		String[] zeichen1 = new String[s1.length()];// String Array mit Länge des Strings s1
		String[] zeichen2 = new String[s2.length()];// String Array mit Länge des Strings s2

		// Die Zeichen des Strings s1 werden im Array zeichen1 gespeichert
		for (int i = 0; i < zeichen1.length; i++) {
			zeichen1[i] = s1.valueOf(s1.charAt(i));// Speicherung des Strings an der Stelle i
		}

		// Die Zeichen des Strings s2 werden im Array zeichen2 gespeichert
		for (int i = 0; i < zeichen2.length; i++) {
			zeichen2[i] = s2.valueOf(s2.charAt(i));// Speichern des Strings an der Stelle i
		}

		// For Schleife zum Lesen des Arrays zeichen1
		for (int i = 0; i < zeichen1.length; i++) {
			System.out.println(zeichen1[i]);
		}

		// For Schleife zum Lesen des Arrays zeichen2
		for (int i = 0; i < zeichen2.length; i++) {
			System.out.println(zeichen2[i]);
		}
	}
}

Zusammenfassung:

  • Mit der Methode charAt() kannst du aus einem Java String ein bestimmtes Zeichen extrahieren.
  • Diese Zeichen werden dir als char-Wert zurückgegeben.
  • Du kannst jedes einzelne Zeichen in einer Variablen vom Datentyp Character speichern.
    Oder du wandelst diesen char-Datentyp mit der Methode valueOf() in ein String-Objekt um.
  • Du kannst den kompletten String mit einer For-Schleife durchlaufen lassen und den String in einzelne char-Werte zerlegen.
  • Außerdem kannst du diese Char-Werte in einem Char Array oder in einem String Array abspeichern.

Ähnliche Beiträge

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 die Java Codeblöcke zur Automatisierung

Java Codeblöcke

In diesem Beitrag geht es um den Einsatz von Java Codeblöcken oder Initialisierungsblöcken. Viele Wege führen nach Rom. Oder Alle Wege führen nach Rom. Heißt es in einem alten Sprichwort. Und so ähnlich ist es bei der Java Programmierung. In diesem Beitrag möchte ich dir einen weiteren Weg vorstellen, wie du Variablen eines Java Objektes […]

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

Die sechs Bestandteile von Java Methoden

Java Methoden Bestandteile

Java Methoden hauchen deinem Java Programm Leben ein. Ohne eine Methode würde deine Java Klasse ein starres Konstrukt sein. Deine Objekte hätten Eigenschaften. Aber sie könnten nichts machen. Und das wäre eine trostlose Welt. Java Methoden sorgen also dafür, dass Objekte interagieren. Methoden bestehen aus bestimmten Bausteinen. Und diese Bausteine bestimmen, was die Methode darf […]

So legst du Utility Klassen in Java an

Java Utility Klassen

Utility Java Klassen – was ist das? Man nennt diese auch Hilfsklassen von Java. Diese Utility Klassen sind Java Klassen, welche lediglich Methoden und Konstanten anbieten. Am Beispiel: Die Klasse Math ist so eine klassische Utility Klasse. Wozu braucht man solche Klassen? Diese Klassen sind so etwas wie ein Werkzeugkoffer für jedes Java Programm. Hier […]

Java Duales Zahlensystem – Binäre Zahlen in Java umwandeln

Java Dual System

Das duale Zahlensystem hat viele Bezeichnungen. Oft wird auch es Dualsystem oder Binärsystem genannt. Es besteht aber immer aus 2 Zahlen. Man verwendet oft die Zahlen 0 und 1. Es können aber auch sämtliche anderen Zahlenpaare sein. Zum Beispiel 7 und 175 sind für sich genommen, auch ein normales Zahlenpaar und somit ein Dualsystem. Mit […]

Lexikalik, Syntax und Semantik in Programmiersprachen

Programmiersprachen Semantik Programmiersprachen Syntax Programmiersprachen Lexikalik Java

Java ist eine Programmiersprache. Und wie jede andere Programmiersprache ist auch Java, lediglich eine künstliche Sprache.   Normalerweise bieten künstliche Projekte immer jede Menge Spielraum für Eigenkreationen. Bei der Programmierung ist dies nicht ganz so. Denn Programmiersprachen sind auch immer sehr exakt.   Jede Programmiersprache und auch jede gesprochene Sprache folgt immer einer Abstraktionsreihenfolge, welche […]

3 Möglichkeiten – Java Strings verketten und zusammenfügen

Java Strings verketten

Kennst du dieses Relikt längst vergangener Tage? 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 […]

Java Übung 11 – Java Objekte in Java Methoden übergeben

Java Übung Java Methoden Objekte

In dieser Java Übung möchte ich dir zeigen, dass du auch in Klassenmethoden auf Objekte und deren Instanzvariablen zugreifen kannst. Schau dir dazu einmal diesen Java Code an. public class Umwandlung { private int x; public int getX() { // getter Methode return x; } public void setX(int x) { // setter Methode this.x = […]

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.

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