1. Ein Array ist ein Container für Elemente
Wahrscheinlich haben Sie schon gehört, dass Computer gewaltige Datenmengen verarbeiten können. Kontrollstrukturen (if-else) und Schleifen (for, while) helfen dabei natürlich. Aber weit kommt man damit allein nicht, denn die verarbeiteten Daten müssen irgendwo gespeichert werden.
Für diesen Fall gibt es in Java, wie praktisch in allen Programmiersprachen, eine großartige Sache: Arrays (Array). Man nennt sie auch Felder.
Ein Array ist ein spezielles Objekt, in dem man nicht nur einen Wert, sondern mehrere speichern kann.
Wenn wir früher eine Variable mit einer Schachtel verglichen haben (in der man irgendeinen Wert aufbewahren kann), dann ist ein Array eher eine Schachtel, die innen in Fächer unterteilt ist. Jedes Fach in der „Array-Schachtel“ hat seine Nummer. Die Nummerierung beginnt selbstverständlich bei null …
Oder wir ziehen noch eine andere Analogie. Vergleichen wir ein normales Wohnhaus mit einem Mehrfamilienhaus. Ein gewöhnliches Haus wird von einer Familie bewohnt, ein Mehrfamilienhaus ist in Wohnungen unterteilt. Um einer Familie zu schreiben, die in einem normalen Haus lebt, muss man seine eindeutige Adresse angeben. Um einer Familie zu schreiben, die in einer Wohnung lebt, muss man die eindeutige Adresse des Hauses und zusätzlich die Wohnungsnummer angeben.
So ist eine Array-Variable wie ein Mehrfamilienhaus. In ihr kann man nicht einen, sondern mehrere Werte aufbewahren. In einer solchen Variable gibt es mehrere „Wohnungen“ (Zellen), auf die man jeweils über ihre Nummer (den Index) zugreifen kann.
Dafür muss man nach dem Variablennamen in eckigen Klammern den Index der Zelle angeben, auf die man zugreifen möchte. Das ist ziemlich einfach:
array[index] = value;Dabei ist array der Name der Array-Variable, index die Nummer der Zelle im Array und value der Wert, den wir in die angegebene Zelle eintragen möchten.
Aber klären wir zunächst, wie man Arrays erstellt.
2. Ein Array in Java erstellen
Angenommen, Ihr Programm muss irgendwo 100 Ganzzahlen speichern. Dafür eignet sich sehr wahrscheinlich ein Array. Und wie erstellt man es?
Wenn wir eine einzige Ganzzahl speichern wollten, würde der Typ int genügen, und wenn wir 100 Ganzzahlen speichern wollen, benötigen wir wahrscheinlich ein Array vom Typ int. So sieht der Code zu seiner Erstellung aus:
int[] array = new int[100];Schauen wir uns an, was hier steht.
Wie Sie vielleicht schon vermutet haben, steht links vom Gleichheitszeichen die Deklaration einer Variablen namens array mit dem Typ int[]. Auf den Typ int folgen eckige Klammern, die andeuten, dass in „Schachteln“ dieses Typs nicht ein, sondern mehrere Werte gespeichert werden können.
Rechts vom Gleichheitszeichen steht die „Objekterzeugung“ (das Wort new) mit 100 Elementen (Zellen) des Typs int. Auch nicht besonders kompliziert.
Wenn wir zum Beispiel ein Array mit 20 Zellen zur Speicherung von Gleitkommazahlen erstellen wollten, sähe der Code ungefähr so aus:
double[] vals = new double[20];Die Anzahl der Zellen in einem Array nennt man Arraygröße oder Arraylänge. Aufgrund der Fähigkeit, viele Werte zu speichern, werden Arrays auch Container genannt.
Wichtige Tatsache: Die Größe des Array-Containers kann nach der Erstellung nicht geändert werden.
Man kann einen neuen erstellen, aber die Länge eines bereits erzeugten Containers kann nicht geändert werden.
3. Arbeiten mit Array-Elementen
Gut, Arrays erstellen können wir jetzt – aber wie arbeitet man korrekt mit ihnen?
Fast genauso wie mit gewöhnlichen Variablen, nur dass nach dem Namen der Array-Variable unbedingt die Nummer der Zelle angegeben werden muss, mit der wir arbeiten.
Die Nummerierung der Array-Zellen beginnt immer bei null. Wenn wir ein Array mit 10 Elementen haben, dann sind die Nummern (Indizes) seiner Zellen 0..9; wenn das Array 200 Elemente hat, dann 0..199. Und so weiter.
Beispiele:
int[] a = new int[10]; // Wir erstellen ein Array mit 10 Elementen vom Typ int.
a[2] = 4; // In die Zelle mit Index 2 schreiben wir den Wert 4.
a[7] = 9; // In die Zelle mit Index 7 schreiben wir den Wert 9.
a[9] = a[2] + a[5]; // In die Zelle mit Index 9 schreiben wir die Summe der Werte,
// die in den Zellen 2 (dort steht 4) und 5 (dort steht 0) gespeichert sind.
Das wird nach der Ausführung dieses Codes im Speicher stehen:
Die Spalte links vom Array (grau) sind die Nummern (Indizes) der Zellen. In den Zellen stehen die eingetragenen Werte: 4, 9 und 4. Unmittelbar nach der Erstellung sind die Zellen eines Arrays mit Nullen gefüllt.
Wichtig. Alle Zellen eines Arrays haben den gleichen Datentyp. Wenn wir ein String-Array String erstellt haben, können in seinen Zellen nur Strings gespeichert werden. Der Datentyp des Arrays wird bei seiner Erstellung festgelegt. Weder den Datentyp noch die Länge des Arrays kann man später ändern.
4. Arrays im Speicher
Die Abbildungen in den vorherigen Beispielen sind etwas ungenau.
Bei der Erstellung von Arrays (wie auch bei der Erstellung von Strings) werden im Speicher zwei Blöcke reserviert: einer zur Speicherung des Arrays (des Containers) selbst und einer für die Variable, die seine Adresse speichert. Die präzisierte Situation ist auf dem folgenden Bild dargestellt:
Grün dargestellt ist ein Array mit 10 Elementen vom Typ int und eine Variable vom Typ int[], die die Adresse (Referenz) des Arrays vom Typ int im Speicher speichert.
Zum Vergleich ist eine gewöhnliche Variable vom Typ int, die den Wert 199 speichert, blau markiert.
Erinnert irgendwie an die Speicherung von Strings im Speicher, nicht wahr?
Richtig, Strings. Und wie bei der Arbeit mit Strings kann man „Variablen vom Typ Array“ einander zuweisen:
int[] a = new int[10]; // Wir erstellen ein Array mit 10 Elementen vom Typ int.
a[2] = 4; // In die Zelle mit Index 2 schreiben wir den Wert 4.
a[7] = 9; // In die Zelle mit Index 7 schreiben wir den Wert 9.
int[] b = a; // In die Variable b speichern wir die Adresse, die in der Variablen a steht.
// Jetzt zeigen a und b auf dasselbe Array-Objekt im Speicher.
a[9] = b[2] + a[7]; // In die Zelle mit Index 9 des Array-Objekts schreiben wir die Summe der Werte,
// die in den Zellen 2 (dort steht 4) und 7 (dort steht 9) gespeichert sind.
Das Array-Objekt bleibt dabei dort, wo es ist, und die Variablen a und b speichern identische Adressen (Referenzen) auf ein und dasselbe Objekt. Siehe Abbildung:
5. Arrays detaillierter verwenden
Ein Array kann aus absolut jedem Typ erstellt werden. Dazu muss man nur nach dem Typnamen eckige Klammern schreiben. Die allgemeine Form der Erstellung eines Arrays ist folgende:
type[] name = new type[count];Dabei ist type der Typ der Elemente (Zellen) des Arrays, die wir im Array speichern werden. name ist der Name der Variablen, über die wir auf das Array zugreifen, und count ist die Anzahl der Zellen im Array.
Im obigen Beispiel ist die kanonische Form gezeigt: Erzeugung der Array-Variablen und Erzeugung des Array-Objekts. In Wirklichkeit sind das zwei unabhängige Konstruktionen. Man kann die Array-Variable und das Array-Objekt getrennt erstellen:
type[] name;
name = new type[count];Und noch ein wichtiger Punkt
Als Index eines Arrays und als Anzahl der Elemente eines Arrays können Variablen und sogar ganze Ausdrücke dienen.
Beispiele:
int n = 100;
int[] a = new int[n]; // Erzeugung eines Arrays mit n Elementen
int n = 100;
int[] a = new int[n * 2 + 3]; // Erzeugung eines Arrays mit 203 Elementen
int n = 100;
int[] a = new int[n];
a[n-1] = 2; // a[99] = 2;
a[n-2] = 3; // a[98] = 3;
a[n/5] = a[n-1] + a[n-2] // a[20] = a[99] + a[98];
Arraygrenzen überschreiten
Übrigens: Wenn Sie versuchen, auf eine Array-Zelle über einen Index zuzugreifen, den es im Array nicht gibt (in unserem Fall sind das alle ganzen Zahlen außer 0..99), wird das Programm mit dem Fehler ArrayIndexOutOfBoundsException – Index außerhalb der Array-Grenzen – abstürzen.
6. Länge eines Arrays
Wie wir im vorherigen Beispiel gesehen haben, kann man eine Variable vom Typ Array separat erstellen und ihr später irgendwo im Code einen Wert (eine Referenz auf ein Array-Objekt) zuweisen. Man kann es sogar so machen:
int[] array; // Wir erstellen eine Array-Variable vom Typ int[]
if (a < 10) // Wenn die Variable a kleiner als 10 ist,
array = new int[10]; // dann ein Array aus 10 Elementen erstellen.
else // Andernfalls
array = new int[20]; // ein Array aus 20 Elementen erstellen
Und wie arbeitet man weiter mit einem solchen Array? Wie erfährt man, wie viele Elemente es enthält?
Dafür hat ein Array eine spezielle Eigenschaft (Variable) – length. Die Länge des Arrays kann man mit folgendem Ausdruck ermitteln:
array.length;Dabei ist array der Name der Array-Variable und length der Name der Eigenschaft des Array-Objekts. Den Wert in der Eigenschaft length kann man nicht ändern: Die Eigenschaft length kann man anderen Variablen zuweisen, aber ihr selbst kann man nichts zuweisen (das Programm wird einfach nicht kompiliert).
So kann man das vorherige Beispiel fortsetzen:
int[] array; // Wir erstellen eine Array-Variable vom Typ int[]
if (a < 10) // Wenn die Variable a kleiner als 10 ist,
array = new int[10]; // dann ein Array aus 10 Elementen erstellen.
else // Andernfalls
array = new int[20]; // ein Array aus 20 Elementen erstellen
for (int i = 0; i < array.length; i++) // Schleife über alle Array-Elemente: von 0 bis array.length – 1
{
System.out.println(array[i]);
}
7. Fakten über Arrays in Java
Fassen wir die bekannten Fakten über Arrays zusammen:
- Fakt 1. Ein Array besteht aus vielen Zellen.
- Fakt 2. Der Zugriff auf eine konkrete Zelle erfolgt über ihre Nummer.
- Fakt 3. Alle Zellen sind vom gleichen Typ.
- Fakt 4. Anfangswerte für alle Zellen sind 0 und null (wenn in der Zelle eine Adresse gespeichert wird), false (für den Typ boolean).
- Fakt 5. String[] list ist lediglich die Deklaration einer Variablen: Der Container selbst (das Array-Objekt) ist noch nicht erstellt. Damit man mit ihm arbeiten kann, muss man das Array (den Container) erstellen und in diese Variable legen und es erst dann verwenden. Siehe Beispiel unten.
- Fakt 6. Wenn wir ein Array-Objekt (Container) erstellen, müssen wir angeben, wie lang es ist – wie viele Zellen es enthält. Das geschieht mit einem Befehl der Form: new TypeName[n];
- Fakt 7. Die Länge eines Arrays kann man über die Eigenschaft .length ermitteln.
- Fakt 8. Nach der Erstellung eines Arrays kann man weder den Typ seiner Elemente noch deren Anzahl ändern.
String s; // s ist gleich null
String[] list; // list ist gleich null
list = new String[10]; // Die Variable list speichert eine Referenz auf ein Objekt – ein String-Array mit 10 Elementen.
int n = list.length; // n ist gleich 10
list = new String[0]; // Jetzt enthält list ein Array mit 0 Elementen.
// Das Array existiert, aber es kann keine Elemente speichern.
list = null;
System.out.println(list[1]); // Es wird ein Programmfehler ausgelöst – das Programm wird abstürzen.
// list enthält eine leere Referenz – null
list = new String[10];
System.out.println(list[10]); // Es wird ein Fehler ausgelöst – Überschreitung der Array-Grenzen.
// Wenn list 10 Elemente/Zellen enthält, sind die erlaubten Indizes: 0 1 2 3 4 5 6 7 8 9 – insgesamt 10 Stück.
GO TO FULL VERSION