Du liest:
Das Java Array: Alles was du wissen musst

Das Java Array: Alles was du wissen musst

von Pero
19.05.2020
Das Java Array

Ein Java Array ist im Grunde eine benannte Sammlung von Daten.
Wie eine normale Variable enthält es Daten und hat einen Typ, aber im Gegensatz zu einer regulären Variablen kann es mehr als nur einen Wert enthalten.
Es ist nicht skalar, während eine reguläre Variable skalar ist.

Der Begriff Skalar stammt aus der Mathematik, genauer gesagt aus der linearen Algebra, wo der Begriff zur Unterscheidung einer Zahl von einem Vektor oder einer Matrix verwendet wird. Die Art und Weise, wie wir Skalar hier verwenden, ist ähnlich.
Eine normale Variable hat eine Eins-zu-Eins-Beziehung mit den Daten, die sie enthält. Eine Aussage wie diese

int anzahlZimmer = 10;

bedeutet, dass die Variable anzahlZimmer nur einen Datenpunkt enthält, es ist der ganzzahlige Wert 10; anzahlZimmer ist also eine skalare Variable.
Kann sich eine Variable auf mehr als einen Datenpunkt beziehen?
Ja. Genau das ist bei dem Array der Fall. Eine Array-Variable bezieht sich auf mehrere Datenpunkte.

1. Die Grundlagen

Stell dir ein Array als einen Container mit Daten vor – denn genau das ist es.
Es speichert eine Folge von Werten desselben Typs.
Zwar kann es verschiedene Werte enthalten, aber sie müssen alle vom gleichen Typ sein, wie hier zum Beispiel:

int zahlen[] = {1, 2, 3};

Eine Reihe von Datenpunkten, wie der eben dargestellte Schnipsel zeigt, ist in Ordnung.
Ein Array von Strings wie das folgende Beispiel:

String obst[] = {"Apfel", "Orange", "Pfirsich", "Bananen"}; 

ist auch in Ordnung.
Was nicht in Ordnung ist, ist das Mischen von Datentypen in einer Array-Deklaration, wie im folgenden Codebeispiel.

String gemischt[] = {"John", "Doe", 5}; // gemischte Datentypen sind nicht zulässig

2. Ein Java Array deklarieren

Um ein Array zu erstellen, müssen wir eine Variable deklarieren, die auf das Array zeigt.
In dieser Deklaration müssen wir den Datentyp des Arrays angeben.
Beispielsweise ob es sich um ein Array aus Ints, Bytes, Strings usw. handelt.
Die Deklaration sieht wie folgt aus:

int meineZahlen[];

Du wirst feststellen, dass die Array-Variable ein Paar eckiger Klammern hat, ebenso unterscheiden wir sie von regulären Variablen.
Übrigens müssen eckige Klammern nicht immer rechts vom Namen der Variable stehen, sondern können auch auf die linke Seite geschrieben werden, in etwa so:

int []meineZahlen;

Meistens aber wirst du die Klammern auf der rechten Seite des Namen der Variable finden. Jeder Entwickler hat dabei seine eigene Vorliebe und du wirst wahrscheinlich auch deine eigene früher oder später entwickeln. Um alles einheitlich zu halten, werden wir im Laufe des Beitrages jedoch die Klammern auf die rechte Seite schreiben.

Jetzt, da wir wissen, wie man Array-Variablen deklariert, können wir das Array selbst definieren. Arrays können auf 2 Arten definiert werden. Wir können Array-Literale verwenden, die du in den vorherigen Beispielen gesehen hast, oder wir können das new Schlüsselwort verwenden. Schauen wir uns die Array-Literale genauer an.

Wir können ein Array-Literal konstruieren, indem wir ein Paar geschweifte Klammern verwenden und dann den Inhalt des Arrays innerhalb der geschweiften Klammern deklarieren, indem wir sie durch Kommata trennen.
Das ganze sieht dann so aus:

int meineZahlen[] = {35, 60, 79};

Die Variable meineZahlen zeigt nun auf ein Array von 3 ganzen Zahlen.
Übrigens, du hast vielleicht bemerkt, dass ich in den vorherigen Code-Snippet das Array in derselben Zeile deklariert und definiert habe.
Du kannst das bei Arrays, genauso wie bei normalen Variablen, auch tun.

Der zweite Weg um ein Java Array zu deklarieren, ist das new Schlüsselwort zu verwenden.

int meineZahlen[] = new int[3];

Auf das Schlüsselwort new folgt der Typ des Arrays, in diesem Fall int, unmittelbar gefolgt von der Klammernotation.
In diesem Beispiel bedeutet new int[3], dass wir ein Array mit 3 Elementen erstellen.
Elemente nennen wir die einzelnen Datenpunkte eines Arrays.
Diese Elemente sind in folgender Reihenfolge angeordnet:

meineZahlen[0]
meineZahlen[1]
meineZahlen[2]

Ist dir was aufgefallen?
Das erste Elemente eines Arrays ist nicht an Stelle 1, sondern an Stelle 0.
Du musst dich an diese Schreibweise gewöhnen, denn das führt bei Anfängern häufig zu Fehlern!
Um also auf das erste Element eines Arrays zuzugreifen, musst du den 0ten Index verwenden.
Um auf das Zweite Element zuzugreifen, musst du den Index 1 verwenden, und so weiter.

An diesem Punkt sind wir aber noch nicht fertig.
Wir haben das Array zwar initialisiert, aber noch nicht mit Daten bestückt.
Zu diesem Zeitpunkt hat das Array 3 Elemente welche alle mit dem Wert 0 initialisiert worden sind, da dieser der Java Standardwert für den Datentyp int ist.
Um jetzt unser Java Array mit eigenen Werten zu befüllen, müssen wir uns nun auf jedes Element einzeln beziehen.

Um auf ein bestimmtes Element im Array zu verweisen, verwenden wir den Namen des Arrays und seinen Index.
Das Ganze sieht dann beispielsweise so aus:

meineZahlen[2] = 79;

Dabei steht meineZahlen für den Namen des Arrays und [2] für die Indexnummer.
Die Indexnummer stimmt nicht mit der Ordinalposition des Elements überein, da die Indexnummer, wie zuvor erwähnt, bei 0 und nicht bei 1 beginnt.
In diesem Fall ist also die Indexnummer 2 das dritte (und letzte) Element unseres Arrays.

Um also unser Java Array nun mit Werten zu befüllen, können wir folgendes machen:

meineZahlen[0] = 35;
meineZahlen[1] = 60;
meineZahlen[2] = 79;

Du könntest das gleiche Ergebnis auch mit folgender Schreibweise erreichen:

int meineZahlen[] = {35, 60, 79};

Beide Codebeispiele deklarieren ein Array bestehend aus 3 Integer Werten und befüllt diese mit den 3 ganzzahligen Werten 35, 60 und 79.

3. Die einfache Nutzung von einem Java Array

Was ist, wenn wir dem meineZahlen Array ein weiteres Element hinzufügen wollen?
Die Antwort ist, wir können es nicht. Ein Array hat eine feste Größe.
Sobald es einmal deklariert ist, können wir keine Elemente hinzufügen oder entfernen, ohne ein weiteres Array zu erstellen.
Wir können die Werte der vorhandenen Elemente ändern, aber wir können seine Größe weder verkleinern noch vergrößern.
Es ist einer der Typen in Java, die als unveränderlich bezeichnet werden – einmal erstellt, kann es nicht mehr geändert werden.
Wenn du eine Datenstruktur benötigst, die ihre Größe dynamisch ändern kann, würde ich dir raten, die robusteren Klassen wie z.B. ArrayList in Betracht zu ziehen.
Aber das ist nicht Teil des aktuellen Beitrags.

Eine Datenstruktur, wie ein Array, hat viele Vorteile gegenüber der Verwendung einfacher Variablen.
Stell dir für einen Moment vor, wir verwalten ein Motelsystem, und wir müssen die Belegungen für jedes Zimmer im Auge behalten.
Wenn wir normale Variablen verwenden würden, wie würdest du 5 Zimmer im Code darstellen? Einige werden wahrscheinlich so etwas wie das Folgende tun:

int raumEins = 0; 
int raumZwei = 3; 
int raumDrei = 2; 
int raumVier = 0; 
int raumFuenf = 5; 

Die Werte für jeden Raum sind willkürlich gewählt, ich habe sie nur für den Zweck dieses Beispiels erfunden.
Wie du siehst hat unser 5-Zimmer-Motel einige Bewohner.
Zimmer 1 und Zimmer 4 sind jedoch nicht belegt.
Wenn wir die Gesamtzahl der Bewohner herausfinden wollten, könnten wir folgendes machen:

int gesamteBelegung = raumEins + raumZwei + raumDrei + raumVier + raumFuenf;
System.out.printf("Gesamtbelegung: %d", gesamteBelegung); 

Das mag zwar für ein 5-Zimmer-Motel funktionieren, aber was wäre, wenn wir 100 Zimmer hätten? Was dann? Deklarieren wir 100 Variablen?
Sicherlich können wir es effizienter machen, und das mit Hilfe von Arrays.
Schauen wir, wie eine Lösung funktionieren könnte.

/*
* In diesem Beispiel werden wir das Array durch Array Literale deklarieren
* Im echten Leben würden die Daten des Arrays aber wahrscheiinlich von einem 
* Eingabesystem kommen.
*/

int zimmer[] = {0, 3, 2, 0, 5};

int gesamtBelegung = 0;
for(int i = 0; i < zimmer.length; i++) { 
  gesamtBelegung += zimmer[i];
}

System.out.printf("Gesamtbelegung: %d", gesamtBelegung);

Die aktuelle Version unserer Lösung mag zwar nicht kürzer erscheinen als die erste Variante, bei der wir 5 Variablen zur Berechnung der Summe verwendet haben, aber es geht hier nicht um die Anzahl von Codezeilen.
Wenn wir 100 Räume verwalten würden, würde die Berechnung der Gesamtsumme die Erstellung und Verwaltung von 100 Variablen erfordern.
Wenn wir Arrays verwenden würden, würde sich an unserer For-Schleife nicht viel ändern. Die aktuelle Lösung mit Arrays ist skalierbar, egal ob für 5, 100 oder Tausende Räume müssten wir keine Änderung an der For-Schleife vornehmen.

Die For-Schleife die wir im vorherigen Beispiel genutzt haben, bedarf, im Gegensatz zu ein paar anderen Codezeilen, keiner großer Erklärung.
Wir iterieren durch das Array mit dem Iterator i und erhöhen diesen pro Durchlauf um +1.

Der Ausdruck rooms.length ist treffend benannt, weil er genau das tut was er sagt.
Er gibt dir die Länge des Arrays zimmer zurück.
length ist eine Eigenschaft eines jeden Arrays und gibt einen Typ int zurück. Der Ausdruck

gesamtBelegung += zimmer[i];

kriegt den Wert von dem was in zimmer[i] ist und summiert diesen in der Variable gesamtBelegung.
Warum wir nun Arrays anstatt normalen, einfachen Variablen verwenden ist nun eindeutig.
Arrays erlaubt es uns skalierbar mit größeren Mengen von Daten desselben Typen zu arbeiten und ist dabei perfekt in Kombination mit einer For-Schleife.

4. Auf jedes Element eines Arrays zugreifen

Um durch Arrays zu iterieren, eignet sich die For-Schleife perfekt.
Du könntest zwar auch die while-Schleife verwenden, aber du wirst häufiger der For-Schleife in Kombination mit Java Arrays begegnen.
Du musst allerdings das Indexsystem eines Arrays im Auge behalten, denn nicht vergessen das erste Element eines Array entspricht dem 0ten Index.
Ich weiß, langsam kannst du das auch nicht mehr hören, aber glaub mir es ist wirklich wichtig!

int zimmer[] = {0, 3, 2, 0, 5};

int gesamtBelegung = 0;
for(int i = 0; i <= zimmer.length; i++) {
  gesamtBelegung += zimmer[i];
}

System.out.printf("Gesamtbelegung: %d", gesamtBelegung);

Dieser Code ist dem vorherigen Beispiel sehr ähnlich, enthält jedoch eine kleine, aber wichtige, Änderung. Siehst du den Unterschied?
Richtig gesehen, der zweite Ausdruck der For-Schleife ist anders.
Zuvor hatten wir anstelle von i <= zimmer.length, i < zimmer.length stehen gehabt.
Warum ist das so wichtig fragst du dich eventuell?
Die aktuelle Schreibweise ist die richtige, denn die Schreibweise vom ersten Beispiel führt zur einer ArrayIndexOutOfBoundsException Fehlermeldung.
Arrays haben einen null-basierten Index, also fangen wir von 0 an zu zählen und nicht von 1.
Wenn du nun versuchst auf ein Element des Arrays zuzugreifen was garnicht existiert, erhältst du eine OutOfBounds Fehlermeldung.

Zum Glück für uns stellt uns Java eine verbesserte, erweiterte for-Schleife zur Verfügung, die uns von Out-of-Bounds-Fehlern fernhält.
In Java 1.5 (Tiger) wurde eine neue Art von For-Schleife eingeführt, die die Verarbeitung von Arrays (und Sammlungen) vereinfachen soll.
Wenn sie mit einem Array verwendet wird, hat die erweiterte for-Schleife die folgende Syntax:

for (datentyp bezeichner : arrayName) {
  // Dein Code
}

Der datentyp identifiziert den Typ des Arrays, ziemlich genau wie bei der Deklaration eines Arrays. Der bezeichner ist ein Platzhalter für jedes Element des Arrays, während wir durch das Array iterieren. Der arrayName ist der Name des Arrays, das wir verarbeiten wollen.
Das Neuschreiben unseres Motelzimmer-Beispiels sieht also wie folgt aus:

int zimmer[] = {0, 3, 2, 0, 5};
int gesamtBelegung = 0;

for (int einZimmer : zimmer) {
	gesamtBelegung += einZimmer;
}
System.out.printf("Gesamtbelegung: %d", gesamtBelegung);

5. Wie geht es weiter? – java.util.Arrays !

Jedes komplexere Programm wird Dinge erfordern, die über das hinausgehen, was wir hier getan haben. Sicherlich ist unsere Fähigkeit, Arrays zu erstellen, durch sie zu iterieren und die Summe aller Elemente zu erhalten, schon beeindruckend, aber für Probleme in größeren, realen Anwendungen wirst du noch mehr tun müssen.
Sehr schnell in deinem Abenteuer als Entwickler wirst du feststellen, dass du für viele Echtwelt-Anwendungen Arrays miteinander vergleichen musst, diese sortieren musst oder prüfen ob ein Element in einem Array enthalten ist.
Du kannst zwar deinen eigenen Code schreiben um genau das zu erreichen, aber ist wird nicht so leicht.
Glücklicherweise kommt Java mit eingebauten Libraries die uns den Großteil der Arbeit abnehmen.
Die Arrays-Klasse im java.util-Paket ist Teil des Java Collection Framework, das die Arbeit mit Arrays erheblich erleichtert.
Vorausgesetzt du hast das JDK korrekt installiert und die PATH Variable korrekt gesetzt, kannst du folgenden Befehl ausführen:

javap java.util.Arrays

Dieser Befehl gibt die Methodenköpfe der Arrays-Klasse aus.
Du wirst zwar nicht in der Lage sein, die gesamte Dokumentation zu lesen, aber du wirst die API-Signatur der Klasse sehen können.
Lass uns nun zusammen paar Anwendungsfälle der Arrays-Klasse an.

5.1. Java Array ausgeben lassen

Wenn du alle Werte eines Arrays auf den Bildschirm ausgegeben bekommen möchtest, würdest du eventuell auf die Versuchung kommen folgenden Code dafür zu schreiben:

String fruechte[] = {"Apfel","Banane","Orange"};
System.out.print(fruechte); // prints [Ljava.lang.String;@31b7dea0

Das wird nicht funktionieren, denn es wird nur die Adresse des Arrays gedruckt.
Du kannst schnell eine kleine for-loop-Schleife erstellen, die durch das Array läuft und dann den Wert der einzelnen Elemente ausdruckt.
Das könnte beispielsweise so aussehen:

for(String obst: fruechte)
  System.out.println(obst);

Nicht schlecht oder? Das war ziemlich einfach und hat auch nicht wirklich lange gedauert.
Alternativ könntest du auch die Arrays-Klasse benutzen, in etwa so:

import java.util.Arrays;

public class ArraySample {
  public static void main(String args[]) {
    String fruechte[] = {"Apfel","Banane","Orange"};
    System.out.println(Arrays.toString(fruechte));
  }
}

Achte nur darauf, dass du die Arrays Klasse importiert bevor du diese nutzt!

5.2. Java Array sortieren

Um Java Arrays zu sortieren können wir beispielsweise das folgende machen:

int zahlen[] = {0, 3, 2, 0, 5};
Arrays.sort(zahlen);
System.out.println(Arrays.toString(zahlen)); // prints [0,0,2,3,5]

Wie du siehst, werden durch die sort Funktion alle ganzzahligen Werte des Arrays mit den Namen zahlen sortiert.

5.3. Java Arrays vergleichen

Falls du Arrays miteinander vergleichen willst, könntest du das unter Anderem so machen:

int ersteZahlenreihe[] = {0, 3, 2, 0, 5};
int zweiteZahlenreihe[] = {3, 2, 0, 0, 5};

Arrays.sort(ersteZahlenreihe);
Arrays.sort(zweiteZahlenreihe);

Arrays.compare(ersteZahlenreihe, zweiteZahlenreihe);

Die compare Methode liefert als Rückgabewert einen Integer der entweder 0, eine positive oder eine negative Ganzzahl ist.
Hier hast du eine Übersicht was die Rückgabewerte bedeuten:

  • 0 wird als Rückgabewert geliefert, wenn beide Arrays gleich sind und die gleichen Elemente in der gleichen Reihenfolge enthalten – Das ist übrigens der Grund warum wir beide Arrays vor dem Vergleichen sortiert haben
  • Eine negative Zahl wird zurückgeliefert, wenn der erste Array lexikographisch weniger als der zweite Array ist
  • Eine positive Zahl wird zurückgeliefert, wenn der zweite Array lexikographisch weniger als der erste Array ist

6. Fazit

In Java geben uns Array eine vielfältige Möglichkeit um mit größeren Wertenmengen desselben Datentyps zu arbeiten.
So ist es besonders zu empfehlen mit Arrays zu arbeiten, wenn die Anzahl der einzelnen Elemente relativ hoch ist.

Hat dir der Beitrag gefallen oder fehlt dir noch was?
Lasst es uns in den Kommentaren wissen!
Auch falls dir der Beitrag weitergeholfen hat 🙂



Bislang gibt es keine Kommentare. Markier dein Revier und sei der Erste!

Schreibe einen Kommentar

Das könnte dich auch interessieren