So lassen sich Java Strings in Einzelzeichen (char) zerlegen
![java programmierung strings zerlegen](https://sciodoo.de/wp-content/uploads/2022/11/java-programmierung-strings-zerlegen-300x158.jpg)
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.
Inhalt
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.
Über den Autor
![wissen](https://sciodoo.de/wp-content/uploads/2019/08/wissen-hut.png)