4 Zeichen und Zeichenketten

Zum vorigen Kapitel Zum Inhaltsverzeichnis Zum nächsten Kapitel


Texte bestehen aus Sätzen, Sätze bestehen aus Worten, Worte bestehen aus Buchstaben. Für welche dieser Objekte brauchen wir nun entsprechende Datentypen, wenn wir Texte mit dem Computer bearbeiten wollen?

Ein Wort ist zunächst mal eine geordnete Reihe von Buchstaben. Wenn in einem Satz mehrere Worte hintereinander aufgereiht erscheinen, dann können wir diesen gesamten Satz ebenfalls als eine (geordnete) Reihe von Buchstaben auffassen. Dazu ist es allerdings nötig, dass wir den Begriff des Buchstabens etwas erweitern: auch das Leerzeichen und die Interpunktionszeichen (Komma, Punkt, Ausrufungszeichen, Anführungszeichen...) müssen als "Buchstaben" aufgefasst werden. Dann lassen sich aber auch größere Textmengen wie Absätze, Kapitel, oder sogar ganze Bücher als geordnete Reihe von Buchstaben auffassen.

Informatiker reden statt von "Buchstaben" lieber von "Zeichen" und meinen damit zunächst einmal all die Dinge, die in der ASCII-Tabelle (oder einer anderen Zeichentabelle) auftauchen. Sämtliche Reihen solcher Zeichen, also Wörter, Sätze, ganze Texte, usw. können dann als Ketten aus diesen Zeichen, kurz "Zeichenketten", aufgefasst werden. Alle gängigen Programmiersprachen stellen nun entsprechende Datentypen für "Zeichen" und "Zeichenketten" zur Verfügung.
In Delphi gibt es für einzelne Zeichen den Variablentyp CHAR. Eine Variable vom Typ CHAR belegt im Speicher 1 Byte. Ist mit var c : CHAR eine "Zeichenvariable" c deklariert, dann legt die Zuweisung c := 'A' ein großes A in der Variablen c ab. Im Speicher finden wir dann das Bitmuster '0100 0001'. Interpretieren wir dies numerisch, so bedeutet es die Zahl '65', was die ASCII-Nummer von 'A' ist. Zeichen werden also durch ihre ASCII-Nummern dargestellt - was Sie nicht mehr so sehr verwundern sollte.

Für Zeichenketten stellt Delphi den Type STRING zur Verfügung. Eine Variable vom Typ STRING belegt im Speicher 256 Byte und kann einen Text mit maximal 255 Zeichen aufnehmen. Dabei werden die einzelnen Zeichen des Textes hintereinander in den Speicher geschrieben, wodurch die sozusagen "durchnummeriert" sind. Man kann damit auch auf die einzelnen Zeichen eines Textes zugreifen: steht in einer String-Variablen s der Text "Informatik", dann enthält s[3] das Zeichen 'f'. Und nach der Zuweisung s[2] := 'm' steht in der Variablen s der Text "Imformatik".

Zur Ermittlung der Länge einer Zeichenkette sollten Sie immmer die Funktion Length benutzen: nach der Zuweisung text := "Delphi ist cool!" dann liefert LENGTH(text) den Wert 16.

In den 32-Bit-Versionen von Delphi gibt es inzwischen eine unübersehbare Menge an verschiedensten Datenstrukturen für die Darstellung von Zeichenketten. Der hier beschriebene Typ "STRING" heißt in Delphi 6 eigentlich "ShortString". Einen Typ "String" gibt es in Delphi 6 auch, und er kann weit mehr als der oben beschriebene "STRING".
Sie dürfen trotzdem immer "var s : String;" verwenden, wenn Sie eine Zeichenkettenvariable brauchen: glücklicherweise merkt man im Alltag von den Unterschieden zwischen den verschiedenen Zeichenketten-Typen kaum etwas. (Und der Compiler unterscheidet bei Typ-Bezeichnern auch nicht zwischen Groß- und Kleinschreibung...)


Im folgernden Beispiel wird die Zeichenkette in Edit1 in Großbuchstaben umgewandelt:
     TForm1.Button1Click(Sender: TObject);
       var  zk : STRING;
            i  : Integer;   { lokale Laufvariable !!! }
       begin
       zk := Edit1.Text;
       i := 1;
       While i <= Length(zk) do begin
         zk[i] := Upcase(zk[i]);
         i := i + 1;
         end;
       Edit1.Text := zk;
       end;


Sie haben also die folgenden "Werkzeuge" zur Verfügung:
  • Mit "Length(zk)" können Sie die Anzahl der Zeichen in einem String zk ermitteln.
  • Mit "zk[k]" können Sie sowohl lesend als auch schreibend auf das k-te Zeichen des String zk zugreifen. Dabei hat (erfreulicherweise) das 1. Zeichen die Nummer "1". (Leider ist dieser Zugriff bei der Variablen "Edit.Text" nicht möglich, weshalb die "Zwischenspeicherung" in der lokalen Variablen zk nötig wird. Eine ganz richtige Zeichenkette ist die Text-Eigenschaft der Edit-Komponente also doch nicht!)
  • Um einen kleinen Buchstaben in den entsprechenden Großbuchstaben zu verwandeln, können Sie die Funktion "UpCase(z)" verwenden.
  • Darüberhinaus gibt es noch die Möglichkeit, an einen String s1 ein Zeichen c oder einen anderen String s2 anzuhängen, und zwar einfach mit dem Pluszeichen: "s := s1 + c" bzw. "s := s1 + s2" liefern den gewünschten Gesamt-String s.
Die zuletzt angeführte "Verkettung" von Strings wurde oben noch nicht verwendet, kann aber hilfreich sein für die folgenden
In Java gibt es für einzelne Zeichen den Variablentyp char. Eine Variable vom Typ char belegt im Speicher 2 Byte. Ist mit char c; eine "Zeichenvariable" c deklariert, dann legt die Zuweisung c = 'A' ein großes A in der Variablen c ab. Im Speicher finden wir dann das Bitmuster "0000 0000 0100 0001". Interpretieren wir dies numerisch, so bedeutet es die Hex-Zahl '0041', wobei wir im niederwertigen Byte die ASCII-Nummer von 'A', nämlich (dezimal) 65 wiederfinden. Zeichen werden also durch ihre ASCII-Nummern dargestellt - was Sie nicht mehr sehr wundern sollte. Der verwendete Zeichensatz ist aber ein "Doppel-Byte-Zeichensatz", der den Zeichenvorrat von ASCII um sehr viele zusätzliche Zeichen erweitert.

Für Zeichenketten stellt Java den Type String zur Verfügung. Eine Variable vom Typ String belegt im Speicher doppelt soviele Bytes, wie der Text, mit dem sie initialisiert wird, Zeichen hat. Dabei werden die Doppelbytes der einzelnen Zeichen des Textes hintereinander in den Speicher geschrieben, wodurch die Zeichen sozusagen "durchnummeriert" sind. Man kann damit auf die einzelnen Zeichen eines Textes zumindest lesend zugreifen: steht in einer String-Variablen s der Text "Informatik", dann schreibt "c = s.charAt(2)" das Zeichen 'f' in die char-Variable c. Beachten Sie, dass die Nummerierung der Zeichen dabei mit Null beginnt: das Auslesen des ersten Zeichens eines Strings geschieht also mit "s.charAt(0)". Leider ist ein schreibender Zugriff auf ein einzelnes Zeichen eines Strings in Java nicht möglich.

Zur Ermittlung der Länge einer Zeichenkette sollten Sie immmer die Funktion String.length() benutzen: nach der Zuweisung text := 'Java ist cool!' schreibt "int n = text.length(text)" den Wert 14 in die Variable n.

Java stellt noch einige andere Datentypen für Zeichenketten zur Verfügung, wie z.B. den "StringBuffer". Für unsere einfachen Beispiele genügt jedoch der oben beschriebene Typ "String".

Im folgernden Beispiel wird die Zeichenkette im Textfeld textField1 in Großbuchstaben umgewandelt:
     public void button1_ActionPerformed(ActionEvent evt) {
       /* Eingabe */
       String zk = textField1.getText();        /* Quell-String */
       char z = ' ';    /* mit einem Leerzeichen inizialisieren */
       String zk2 = ""; /* Ziel-String, als leer inizialisieren */

       /* Verarbeitung */
       int i = 0;                        /* lokale Laufvariable */
       while (i < zk.length() ) {
         z = zk.charAt(i);
         z = Character.toUpperCase(z);
         zk2 = zk2 + z;
         i = i + 1;
       }

       /* Ausgabe */
       textField2.setText(zk2);
     }
Sie haben also die folgenden "Werkzeuge" zur Verfügung:
  • Mit "zk.length()" können Sie die Anzahl der im String zk enthaltenen Zeichen ermitteln.
  • Mit der Methode "zk.charAt(k)" können Sie das Zeichen an der Stelle k des Strings zk auslesen; beachten Sie aber, dass das 1. Zeichen die Nummer "0" hat. (Welche Nummer hat dann das letzte Zeichen eines beliebigen Strings s?)
  • Um einen kleinen Buchstaben in den entsprechenden Großbuchstaben zu verwandeln, können Sie die Funktion "Character.toUpperCase(z)" verwenden.
  • Um schließlich an einen vorhandenen String s1 ein Zeichen c oder einen anderen String s2 anfügen, können Sie das Pluszeichen verwenden: "s = s1 + c" bzw. "s = s1 + s2" liefert den gewünschten Gesamt-String s.
Die hier angeführten Operationen sollten nun ausreichend sein für die folgenden


Aufgaben:


  1. Das GROSSE Problem:

    Ein Programm soll in einer Textbox einen Text entgegennehmen und ihn auf Knopfdruck in einer anderen Textbox in Großbuchstaben ausgeben. Dabei kann die Schleifenvariable hoch- oder runtergezählt werden.

    Schreiben Sie ein Programm mit 3 Textboxen und 2 Knöpfen, in denen beide Möglichkeiten realisiert werden.
    Variieren Sie auch die Formulierung der Bedingung:
    • Geht's auch mit "<" anstatt "<=" bzw. ">" statt ">=" ?
    • Kann man im Schleifenkörper auch zuerst  die Schleifenvariable hoch- bzw. runterzählen und erst danach "upcasen"?
    Lösungsvorschlag: [Delphi] [Java]



  2. Das Vokal-Problem:

    Ein Programm soll einen Text entgegennehmen und auf Knopfdruck einen veränderten Text ausgeben, in dem alle Vokale durch 'a' bzw. 'A' ersetzt sind.

    Schreiben Sie ein Programm mit 2 Edit-Feldern: im ersten erscheint der eingegebene Text unverändert, im zweiten der "ver-a-te" Text.
    (Ein Tip: Sie dürfen hier mit vielen ineinander verschachtelten IF-Anweisungen arbeiten. Sie können aber auch mehrere Fälle mit "oder" verknüpfen:
    In Delphi:
         If (zk[i] = 'e') or (zk[i] = 'i') or .... then
           ...........
         else
    
    Es gibt aber eine elegantere Möglichkeit, nämlich mit Hilfe der "POS"-Funktion. Lesen Sie in der Online-Hilfe nach, was diese Funktion tut, und überlegen Sie sich, wie Sie sie gewinnbringend für eine elegantere Formulierung des Algorithmus einsetzen können!)
    In Java:
         if ((zk.charAt(i) == 'e') || (zk.charAt(i) == 'i') || .... ) {
           .............
         }
    
    Es gibt aber eine elegantere Möglichkeit, nämlich mit Hilfe der "zk.indexOf(z)"-Methode. Lesen Sie in der Online-Hilfe nach, was diese Funktion tut, und überlegen Sie sich, wie Sie sie gewinnbringend für eine elegantere Formulierung des Algorithmus einsetzen können!
    Lösungsvorschlag: [Delphi] [Java]



  3. Das  g e s p e r r t e  Problem:

    Ein Programm soll einen Text entgegennehmen und ihn auf Knopfdruck gesperrt ausgeben, d.h.: zwischen je zwei Buchstaben wird ein Leerzeichen eingefügt. Schreiben Sie ein Programm mit 2 Edit-Feldern und einem Knopf: im ersten wird der Text eingegeben, im zweiten erscheint er auf Knopfdruck gesperrt.

    Lösungsvorschlag: [Delphi] [Java]



Zum vorigen Kapitel Zum Inhaltsverzeichnis Zum nächsten Kapitel