(letzte Änderung an dieser Seite: 15.02.2013)
(letzte Synchronisation der PDF-Präsentation: 02.08.2017)
Falls keine PDF-Präsentation zu sehen ist, klicken Sie zum Download hier: Direktdownload PDF-Präsentation
Wir haben ein Guthaben von 100 Euro, das wir mit einem Zinssatz von 10% pro Jahr verzinsen. Jedes Jahr verändert sich das Guthaben also so:
Wir könnten hier auch eine Index-Schreibweise wie in der Mathematik verwenden (z.B. jahr1 ...) oder mit Indizes in eckigen Klammern arbeiten:
Zum Speichern in Variablen hätten wir die Möglichkeit, für jedes Jahr eine Variable anzulegen, z.B. jahr0 = 100.00, jahr1 = 110.00 ...
Das hat signifikante Nachteile - so ist es schwer herauszubekommen, welche Variablen alle zum Sparplan gehören. Sortieren oder die Anzahl Bestimmen ist ebenfalls nicht einfach.
Deshalb benutzt man Feldvariablen (oder auch: Arrays). Die Variable nimmt verschiedene Werte des gleichen Datentyps auf, über den Index kann man auf die einzelnen Werte zugreifen. Im folgenden Beispiel drei Elemente vom Typ double:
Das erste Element besitzt immer den Index 0. Bei einem Array, das die Monate enthält, wird der Dezember also durch den Index 11 angezeigt (monate[11]).
Die Größe wird bei der Erzeugung angegeben und ist nachträglich nicht mehr veränderbar!
Außerdem handelt es sich um Referenztypen, s.u.
Arrays können durch new erzeugt werden; möglich ist auch die sofortige Initialisierung mit Werten.
Mit new:
Java-Codedouble[] guthaben = new double[3]; // Definition + Erzeugung Array // Größe des Arrays wird in der Klammer angegeben! guthaben[0] = 100.00; guthaben[1] = 110.00; guthaben[2] = 121.00; // Initialisierung des Arrays mit Werten
Achtung: Im obigen Beispiel hat das dritte Element den Index 2 (da das erste Element den Index 0 hat!).
Definition, Erzeugung und Initialisierung in einem Schritt:
Java-Codedouble[] guthaben = {100.00, 110.00, 121.00};
Hier wird die Größe durch die Anzahl der Werte festgelegt. Bei String-Arrays kommen die Werte natürlich in Anführungszeichen:
Java-CodeString[] namen = {"John", "Heinrich", "Mary"};
Wer bis hier mitgekommen ist, kann unten Aufgabe 1 bearbeiten ("Java_30-Arrays-1: Array definieren, einfach").
Arrays sind Referenztypen, d.h. sie verweisen lediglich auf die enthaltenen Werte.
Wir nehmen folgende zwei Definitionen:
Java-Codeint[] guthaben = {20, 40}; int[] geld = {100, 139};
Damit haben wir zwei Arrays, die wir uns so vorstellen können:
Wenn wir nun das eine Array in das andere kopieren, z.B. durch
Java-Codegeld = guthaben;
dann erhalten wir zwei verschiedene VERWEISE (Referenzen) auf ein und dasselbe Array - beide Arrayvariablen (geld und guthaben) verweisen darauf.
Änderung in der einen Variablen betreffen auch die andere! geld[1] = 100
führt dazu, dass auch
guthaben[1] == 100
ist!
Wenn Sie bis hierhin mitgekommen sind, können Sie unten Aufgabe 2 ("Java_30-Arrays-2: Array duplizieren") bearbeiten.
Um Inhalte von Arrays auszugeben oder zu manipulieren, benutzt man Schleifen. Dazu muss man die Länge des Arrays kennen, diese kann man mit .length eruieren:
Java-Codeint[] wetterdaten = {1,4,2,6} int anz = wetterdaten.length; System.out.println("Anzahl der Elemente: " + anz);
Für Ausgabe und Verändung von Arraywerten kann man die klassische for-Schleife benutzen:
Java-Code// Beispiel 1 String[] name = {"Heinrich","Margarete","Joe"}; for(int i = 0;i < name.length; i++) { System.out.println("Name " + i + ": " + name[i]); }
Hier werden alle Elemente des Arrays durchlaufen und die Werte ausgegeben. Beachten Sie, dass die Schleife bei 0 startet, dafür aber nur bis < length läuft (und nicht bis <= length).
Mit for-Schleifen können auch Werte verändert werden:
Java-Code// Beispiel 2 int[] quadrat = new int[20]; for(int i = 0;i < quadrat.length; i++) { quadrat[i] = i * i; System.out.println(i+" zum Quadrat=" + quadrat[i]); }
Hier wird jeder Index ins Quadrat gesetzt, die Ausgabe ist entsprechend:
...
6 zum Quadrat = 36
7 zum Quadrat = 64
...
Die foreach-Schleife ist eine verkürzte Form der for-Schleife. Es können Werte nur AUSGEGEBEN werden, es kann NUR EIN Array durchlaufen werden:
Java-CodeString[] name = {"Heinrich","Margarete","Joe"}; for(String n : name) { System.out.println(n); }
Alle Elemente des Arrays werden eines nach dem anderen durchlaufen. Einer neuen Variablen wird der Wert des aktuellen Elements zugewiesen.
Sie sind jetzt bereit für Aufgabe 3 unten ("Java_30-Arrays-3: Array mit Schleifen durchlaufen")
Bei mehrdimensionalen Arrays enthält jedes Array-Element ein Array. Wichtig:
Beispiel: Ein einfaches Array String[] einfach = new String[2]
:
Hier hat einfach[0]
den Wert "wert 1", einfach[1]
den Wert "wert 2".
Nun erzeugen wir ein zweidimensionales Array, wo die einzelnen Arrayelemente (z.B. einfach[0]
) nicht mehr einfach nur einen Wert beinhalten, sondern ein neues Array. Dazu verwenden wir String[][] mehrfach = new String[2][3]
:
Hier enthält mehrfach[0][]
ein eigenes Array, so dass mehrfach[0][0]
= "wert a", mehrfach[0][1]
= "wert b" usw. Entsprechend hat natürlich mehrfach[1][0]
den Wert "wert d".
Oft verwendet man zweidimensionale Arrays, um Tabellen abzubilden (es kommen natürlich auch mehrdimensionale Strukturen vor, der Einfachheit halber beschränken wir uns auf zwei). Die erste Dimension kann dann für die Zeilen stehen, die zweite Dimension für die Spalten:
Zuerst definieren wir die Dimensionen:
Java-Code// Dimensionen definieren int anzahlZeilen = 2; int anzahlSpalten = 3; String[][] tabelle = new String[anzahlZeilen][anzahlSpalten];
Wir haben so eine Tabelle mit 2 Zeilen und 3 Spalten erzeugt. tabelle[0][2]
steht also für die erste Zeile, dritte Spalte.
Nun können wir die Anzahl der Elemente in den einzelnen Dimensionen ausgeben lassen:
Java-CodeSystem.out.println("Array-Länge: " + tabelle.length); // Ausgabe: 2 (denn in der ersten Dimension 2 Elemente) System.out.println("Länge der Dimension 0: "+tabelle[0].length); // Ausgabe: 3 (denn erstes Element enthält 3 Elemente)
Um die Tabelle zu füllen, müssen in einer verschachtelten Schleife die Zeilen und die Spalten durchlaufen werden:
Java-Code// Zeilen durchlaufen (= 1. Dimension) for(int zeile = 0;zeile < anzahlZeilen;zeile++) { // Spalten durchlaufen (= 2. Dimension) for(int spalte = 0;spalte < anzahlSpalten;spalte++) { tabelle[zeile][spalte] = "zeile " + zeile + ", spalte " + spalte"; } }
Für die Zeile 0 werden die einzelnen Spalten durchlaufen und gefüllt, anschließend für Zeile 1 usw.
Auf die gleiche Art und Weise können die Werte ausgegeben werden:
Java-Code// Zeilen durchlaufen (= 1. Dimension) for(int zeile = 0;zeile < anzahlZeilen;zeile++) { // Spalten durchlaufen (= 2. Dimension) for(int spalte = 0;spalte < anzahlSpalten;spalte++) { System.out.printf("Wert für Zeile %d, Spalte %d: %s%n", zeile, spalte, tabelle[zeile][spalte]); } }
Sie sind jetzt bereit für Aufgabe 4 ("Java_30-Arrays-4: Mehrdimensionales Array - Kalender")
Arrays können als Werte natürlich auch Objekte beherbergen (wie z.B. bei String-Array der Fall).
Wir nehmen eine Klasse Hund, die die Methode huepf() hat. Wenn der Hund jünger als 20 Jahre ist, hüpft er gern und hoch, wenn er älter ist, ächzt er nurmehr.
Java-Codepublic class Hund { public String name; public int alter; public Hund(String name, int alter){ this.name = name; this.alter = alter; } public void huepf(){ if(this.alter < 20){ System.out.println(this.name + " - HÜPF! bin erst " + this.alter); } else{ System.out.println(this.name + " - ächz! bin schon " + this.alter); } } }
Nun können wir einige Objekte der Klasse Hund erzeugen und sie in einem Array speichern. In den Arrayelementen sind diese Objekte nun gespeichert und wir können z.B. auf ihre Methoden zugreifen:
Java-CodeHund a = new Hund("Fifi", 10); Hund b = new Hund("Rex", 3); Hund c = new Hund("Hasso", 27); Hund[] hundeArray = {a,b,c}; hundeArray[0].huepf(); hundeArray[1].huepf(); hundeArray[2].huepf();
Das führt zur Ausgabe:
Fifi - HÜPF! bin erst 10
Rex - HÜPF! bin erst 3
Hasso - ächz! bin schon 27
Jetzt können Sie unten Aufgabe 5 lösen ("Java_30-Arrays-5: Array mit Objekten") und sich anschließend an Aufgabe 6 versuchen.