Wenn wir Daten in Form einer Text-Datei in Processing einlesen, müssen wir diesen Text in der Regel erst verarbeiten. Wenn ich zum Beispiel eine Liste mit Highscore-Daten einlese, dann liegen diese Daten zunächst als Text bzw. String vor. Eigentlich handelt es sich aber um Punkte in Form von Zahlen. Wir müssen den String beim einlesen also zunächst verarbeiten und in eine Form bringen, mit der wir sinnvoll weiterarbeiten können. 

String-Methoden

Wenn man mehrere Zeichen zusammensetzt, hat man eine Zeichenkette, auch genannt String. Ist dir schonmal aufgefallen, dass der Datentyo String am Anfang groß geschrieben wird? Im Verlgeich dazu werden int, float, boolean und. Co klein geschrieben. Das liegt daran, dass es sich beim Datentyp String um einen Objekttypen handelt. Ein Objekttyp ist eine etwas komplexere Form des Datentyps, die wir ausführlich im Modul Objektorientierte Programmierung behandeln werden - keine Sorge. Aber aus diesem Grund kannst du auf das Objekt (also den String) Methoden anwenden. Methoden sind eigentlich nichts anderes als Funktionen. Es sind aber nicht irgendwelche, sondern Funktionen, die zu einer bestimmten Datentyp gehören (in unserem Fall String) und nur von einem Objekt dieses Datentyps aufgerufen werden können. Das geschieht, indem du die Methode mit einem Punkt an die String-Variable bzw. den String ranhängst. So kannst du auf die Methoden zugreifen, die zur Klasse String gehören.

Um  die Länge eines Strings zu bekommen, gibt es z.B. die Methode length(). Diese können wir einfach an unsere Variable mit einem Punkt ranhängen:

String message = "hallo";
println(message.length());

5

Etwas gewöhnungsbedürftig - aber korrekt - ist das Ausführen von Methoden auf dem String direkt, ohne dass eine Variable definiert wird:

println("hallo".length());

5

Diese Form wird tatsächlich empfohlen für den Fall, dass eine String-Variable null sein könnte, wie in dem folgenden Fall:

void testFoo(String s) {
   if ("foo".equals(s))
      println("Foo!");
   else
      println("Bar!"); 
}

Da Strings aus Zeichen (character) zusammengesetzt sind, kannst du die einzelnen Zeichen auch rausziehen, und zwar mit der String-Methode
charAt() :

String message = "hallo";
println(message.charAt(0));
println(message.charAt(1));
println(message.charAt(2));
println(message.charAt(3));
println(message.charAt(4));

Ausgabe:

h
a
l
l
o

Hinweis: Schau dir die Zahlen oben genau an - was fällt dir auf? Richtig, die Zahlen beginnen bei 0! Denke immer daran, dass der vorderste Buchstabe (also der an 1. Stelle) den Index 0 hat!

Übersicht über häufige String-Methoden

Mithilfe von String-Verarbeitungs-Methoden kannst du deine Zeichenfolgen be- und verarbeiten. Zum Beispiel kannst du deinen String durchsuchen nach einzelnen Buchstaben oder Wörtern, du kannst deinen String in mehrere Teile aufteilen, Worte bzw. Buchstaben austauschen etc. Es gibt sehr viele dieser Methoden. Unten siehst du eine Tabelle derjenigen Methoden, welche du für dieses Modul kennen sollst.

String txt = "Hello World!";
println(txt.charAt(6)); // Ausgabe: W

String txt = "Hello World!";
println(txt.contains("ello")); // Ausgabe: true

String txt = "Hello World!";
println(txt.indexOf("ello")); // Ausgabe: 1

String txt = "Hello World!";
println(txt.length()); // Ausgabe: 12

String txt = "I love you as much as I love ice cream";
println(txt.replace("love", "hate"));
// Ausgabe: I hate you as much as I hate ice cream

String txt = "I love you";
String [] parts = txt.split(" "); // Leerzeichen
printArray(parts);

// Ausgabe:
// [0] "I"
// [1] "love"
// [2] "you"

String txt = "Hello World!";
println(txt.startsWith("Hello")); // Ausgabe: true

String txt = "Hello World!";
println(txt.substring(2, 4)); // Ausgabe: ll

String txt = "Hello World!";
println(txt.toLowerCase()); // Ausgabe: hello world!

String txt = " Hello World! ";
println(txt.trim()); // Ausgabe: Hello World!

In der Dokumentation für die Klasse String findest du alle Methoden, die zu Strings gehören. Du musst sie nicht alle können - schau sie dir aber mal an, damit du weißt was alles mit Strings möglich ist.

Hinweis: Unterschiede Processing und Java

Bei der Verarbeitung von Strings gibt es kleine Unterschiede zwischen Java und Processing. Darauf musst du achten, wenn du programmierst. Bei Processing ist das erstmal egal, da Processing beides versteht: den Processing- und den Java-Code. Später, wenn du allerdings nur noch in Java programmierst, funktioniert der Processing-Code nicht mehr. Daher empfehlen wir: Verwende direkt die Java-Schreibweise (so wie hier im Skript auch verwendet).

Die Funktionen für die String-Verarbeitung heißen in Processing und Java gleich, nur werden sie manchmal anders verwendet.

Hier ein Beispiel für die Funktion trim(). Trim entfernt Leerzeichen am Anfang und am Ende eines Strings:

// Code für Processing
String textInProcessing = "     Hier sind Leerzeichen am Anfang!";
println(trim(textInProcessing));  // In Processing wird der String als Parameter übergeben
 
// Code in Java
String textInJava = "Hier sind Leerzeichen am Ende!     ";
println(textInJava.trim());      // In Java wird die Methode direkt auf den String angewendet 

Die Funktionen/Methoden, die in diesem Abschnitt erläutert werden, werden in Java erklärt.

Beispiele

Oben haben wir die wichtigsten und häufigsten Methoden einmal aufgelistet. Im Folgenden findest du nochmal etwas ausführlichere Beispiele zu den einzelnen Methoden.

Die Methode equals() vergleicht zwei Strings und gibt true oder false zurück. Man beachte, dass Groß- und Kleinschreibung bedeutungsunterscheidend ist!

String message = "hallo";
String name = "bob";
 
if (message.equals("hallo"))
  println("guten tag");
else
  println("wie bitte?");
 
println(name.equals("Bob")); 

guten tag
false 

Die Methoden toLowerCase() und toUpperCase() wandeln einen String in Kleinbuchstaben (lower) bzw. Großbuchenstaben (upper) um.

String message = "Hallo";
String name = "Bob";
 
println(message.toLowerCase());
println(name.toUpperCase()); 

hallo
BOB 

Tipp: Groß-/Kleinschreibung ignorieren. Wenn man feststellen möchte, ob zwei Strings "gleich" sind und dabei Groß-/Kleinschreibung ignorieren will, der verwende z.B. toLowerCase() wie folgt:

String message = "hAllo BOB";
 
if (message.toLowerCase().equals("hallo bob"))
  println("erkannt");
else
  println("nicht erkannt"); 

erkannt

Wichtig zu verstehen ist hier, dass die Methode toLowerCase() wieder ein String-Objekt zurückgibt (nämlich den String in Kleinbuchstaben) und dass man auf diesem Objekt direkt weiterarbeiten kann: in unserem Fall mit equals().

Die Methode indexOf() erlaubt es, einen String a in einem anderen String b zu suchen. Die Methode gibt eine Zahl zurück. Bei -1 wurde der String a nicht gefunden. Eine nicht-negative Zahl n besagt, dass String a an Stelle n in b beginnt.

String a = "all";
String b = "hallo";
 
println(b.indexOf(a)); // suche a in b 

1

Im Beispiel suche ich String a = "all" in String b = "hallo". Dann bekomme ich n = 1 zurück, weil "all" an Stelle 1 in "hallo" beginnt. Nicht vergessen, dass die erste Stelle bei 0 beginnt.

String message = "Hallo Bob";
 
println(message.indexOf("foo"));
println(message.indexOf("Bob"));
println(message.indexOf("Ha"));
println(message.indexOf("ha")); 

-1
6
0
-1 

Auch hier ist Groß-/Kleinschreibung bedeutungsunterscheidend. Kannst du den Trick von oben anwenden, wenn du einen String durchsuchen willst und dabei Groß-/Kleinschreibung ignorieren möchtest?

Die Methode substring() erlaubt dir das gezielte Zerschneiden eines Strings. Willst du die Zahl aus dem String "Heidi (24)" herausschneiden, dann gibst du die Startposition an, das wäre die 7, und die exklusive Endposition, d.h. die Position, die nicht mehr rausgeschnitten werden soll, also die 9.

String message = "Heidi (24)";
println(message.substring(7, 9)); // zweite Position exklusive 

24

substring() gibt es auch mit einem Argument. Dann wird nur vorn abgeschnitten und nach hinten raus der ganze Rest genommen:

String message = "Hallo Bob";
println(message.substring(6)); // nur ein Argument 

Bob 

Strings umwandeln

Wie wir noch im Abschnitt Dateien erzeugen und lesen sehen werden, bekommen wir Daten, die wir einlesen, in Form von Strings. Das heißt, auch Zahlen oder Wahrheitswerte werden zunächst als Strings eingelesen.

Für Processing/Java ist der String "401" keine Zahl, sondern eine Folge von drei Zeichen. Da der String "401" keine Zahl ist, kann er auch nicht für Berechnungen verwendet werden. Daher gibt es Funktionen, um den String einer Zahl in eine "echte" Zahl (z.B. int oder float) umzuwandeln. Dasselbe gibt es auch für Wahrheitswerte, die in einen boolean umgwandelt werden sollen. Man nennt das auch Konvertieren bzw. "Parsen" (engl. to parse = analysieren). Beim Parsen wird der String gelesen, analysiert, interpretiert und dann in den entsprechenden Datentyp konvertiert.

Diese Funktionen heißen in Processing int(), float() und boolean():

int zahl = int("401");
println(zahl + 20);
 
float dez = float("-1.5");
println(dez * 10);
 
println(boolean("true")); 

421
-15.0
true

Eine weitere wichtige Funktion in Processing ist nf(). Diese Funktion macht im Endeffekt genau das Gegenteil: Sie wandelt Zahlen in Strings um. Dabei kann man an die Funktion verschiedene Parameter übergeben, wie der String formatiert sein soll bzw. auch ein Arrays an Zahlen, die formatiert werden sollen:

int a = 500;
println( nf(a, 5) );      // 5 steht dafür wieviele Stellen die Zahl haben soll
println( nf(a, 5, 4) );   // 4 steht hier dafür, wieviele Stellen nach dem Komma sein sollen 

00500
00500,0000

Java

In Java gibt es die oben genannten Funktionen nicht. Hier verwendet man die Methoden Integer.parseInt(), Float.parseFloat() und Boolean.parseBoolean(). Die Macher von Processing wollen dir offenbar diese sperrige Syntax ersparen.

println(Integer.parseInt("401"));
println(Float.parseFloat("-1.5"));
println(Boolean.parseBoolean("false"));  

401
-1.5
false

Fällt dir bei Integer, Float und Boolean irgendwas auf? Richtig, sie werden anders geschrieben. Bisher haben wir immer int, float und boolean verwendet. Was ist hier nun der Unterschied? Bei Integer, Float und Boolean handelt es sich (wie bei String auch) um Klassen. Daher werden sie auch groß geschrieben. Und aus diesem Grund können wir auch hier auf die Methoden der jeweiligen Klassen zugreifen (z.B. Integer.parseInt()). Es gibt in Java also einmal int, float und boolean als primitive Datentypen bzw. Wertetypen und weiteres mal als Integer, Float und Boolean als Klassen bzw. Objekttypen.

Zusammenfassung

String-Methoden

In Java und in Processing gibt es die Möglichkeit einen String mithilfe der Methoden (Funktionen) der String-Klasse zu ver- bzw. bearbeiten. In Java werden diese Methoden mit einem Punkt an den String bzw. die String-Variable rangehängt. In Processing gibt es hierfür eigene Befehle. Sie heißen meist gleich, haben aber teilweise andere Parameter.

Eine Liste der wichtigsten String-Methoden

• charAt(int index): Liefert den Buchstaben an der angegeben Stelle. Index beginnt bei 0 
• split(String trennzeichen): Trennt einen String anhand eines Trennzeichens auf und liefert einen Array zurück (Typ String[]).
• contains(String part); Liefert true zurück, wenn der String den angegebenen String enthält
• startsWith(String start): Überprüft, ob der String mit dem angegeben String beginnt. Das Gegenteil hiervon ist endsWith()
• indexOf(String part): Liefert den Index des ersten Vorkommens des angegeben Strings
• substring(int start, int end): Liefert einen Teil-String zurück, der mit start beginnt und vor end endet.
• length(): Liefert die Länge des Strings
• toLowerCase(): Konvertiert einen String in Kleinbuchstaben. Das Gegenteil hiervon ist toUpperCase()
• replace(String find, String replace): Tauscht jedes Vorkommen von find mit replace aus.
• trim(): Entfernt Leerzeichen am Anfang und am Ende des Strings.

Strings umwandeln

Außerdem können Strings in andere Datentypen umgewandelt bzw. konvertiert werden. Dies wird als Konvertieren oder auch Parsen bezeichnet. In diesem Abschnitt haben wir das Parsen eines Strings in int, float und boolean angesehen. Hierfür gibt es bei Java und Processingen unterschiedliche Funktionen:

• Processing: int(), float(), boolean()
• Java: Integer.parseInt(), Float.parseFloat(), Boolean.parseBoolean()

Mithilfe der Funktion nf() kann ich Processing eine Zahl in einen String umgewandelt und formatiert werden.