In Java werden Arrays durch eine bereits vordefinierte Klasse namens Arrays auf dem Paket java.util unterstützt. Einige der praktischen Methoden der Klasse sehen wir uns nun einmal genauer an.
Die Klasse Arrays einbinden
In Java werden Arrays durch eine bereits vordefinierte Klasse namens Arraysunterstützt. Die Klasse liegt im Paket java.util und wird entsprechend in unser Programm importiert:
import java.util.Arrays;Arrays stellt einige sehr nützliche statische Methoden zur Verfügung, die wir direkt auf unserem Array anwenden können. Etwa zum Sortieren, Durchsuchen, Vergleichen etc.
Alle Methoden sind für Arrays der einzelnen primitiven Datentypen sowie für Object mehrfach überladen.
Arrays in Strings umwandeln mit toString()
Sehen wir uns die erste praktische Methode an: Um alle Elemente eines Arrays unkompliziert auf der Konsole auszugeben, wenden wir die statische Methode toString() an und übergeben in Klammern ein Array als Argument. So erhalten wir eine String-Repräsentation der einzelnen Array-Elemente. Diese Methode ist besonders für Testzwecke nützlich:
int[] zahlen = {1, 2, 3, 4, 5};
System.out.println(Arrays.toString(zahlen));Auf der Konsole erscheint:
[1, 2, 3, 4, 5]
Sortieren mit sort()
Die Methode sort() sortiert die Elemente eines Arrays (Quicksort). Für ein Array aus Zahlen bedeutet das die Sortierung in aufsteigender Reihenfolge:
double[] meinArray = {2.3, 1.1, 2.2};
Arrays.sort(meinArray);
System.out.println(Arrays.toString(meinArray)); // [1.1, 2.2, 2.3]Ein Array aus Strings wird mit sort() in die alphabetisch aufsteigende Ordnung gebracht:
String[] liste = {"Brutus", "Augustus", "Caesar"};
Arrays.sort(liste);
System.out.println(Arrays.toString(liste)); // [Augustus, Brutus, Caesar]Sortierung von Objekttypen
Auch Objekttypen lassen sich mittels sort() in die gewünschte Reihenfolge bringen. Hierzu muss allerdings das Inferface Comparable mit der Methode compareTo() implementiert werden. Wir zeigen euch in diesem Blog-Beitrag, wie das funktioniert.
Durchsuchen mit binarySearch()
Unterschied lineare Suche und binäre Suche
Natürlich können wir nach einem Array-Element auch mithilfe einer Schleife suchen, indem wir jedes Element nach einem bestimmten Suchkriterium prüfen und es bei Übereinstimmung zurückliefern. Diese lineare Suche ist jedoch recht ineffizient. Die Suche kann so nämlich relativ lange dauern, wenn sich das gesuchte Element etwa erst am Ende des Arrays befindet oder garnicht exisitiert.
Wie funktioniert die binäre Suche?
Schneller - und damit besser! - ist es daher, auf die binäre Suchmethodezurückzugreifen.
- Achtung: Die binäre Suche funktioniert nur, wenn sich das Array in einem sortierten Zustand befindet.
Die binäre Suche durchsucht nicht Element für Element, sondern vergleicht das Element in der Mitte des Arrays mit dem gesuchten Wert. Ist der gesuchte Wert kleiner, wird die linke Hälfte des Arrays weiter durchsucht, andernfalls die rechte Hälfte. Auf diese Weise wird der Suchbereich mit jedem Schritt halbiert.
Für die binäre Suche stellt die Klasse Arrays die Methode binarySearch() zur Verfügung. Die Methode verlangt zwei Argumente: Das zu durchsuchende Array und das gesuchte Element. Die Methode liefert den Index des gesuchten Elements zurück. Wird das Element nicht gefunden, wird eine negative Zahl zurückgeliefert:
int[] zahlen = {1, 3, 7, 11}; // Array ist sortiert
System.out.println(Arrays.binarySearch(zahlen, 7)); // 2Vergleichen mit equals()
Mit der statischen equals()-Methode können wir prüfen, ob zwei Arrays gleich sind. Zwei Arrays sind gleich, wenn sie a) die gleiche Länge haben und b) paarweise gleich sind.
Die Methode equals() erhält die zu vergleichenden Arrays als Argumente und liefert bei Gleichheit true zurück:
String[] array1 = {"red", "green", "blue", "yellow"};
String[] array2 = {"red", "green", "blue", "yellow"};
String[] array3 = {"red", "orange", "blue", "yellow"};
String[] array4 = {"red", "green", "blue", "yellow", "black"};
System.out.println(Arrays.equals(array1, array2)); // true
System.out.println(Arrays.equals(array1, array3)); // false, 2. Paar ungleich
System.out.println(Arrays.equals(array1, array4)); // false, ungleiche LängeArray füllen mit fill()
Das gesamte Array füllen
Um alle Positionen eines Arrays mit einem bestimmten Wert zu füllen, können wir die Methode fill() einsetzen. Diese erwartet zunächst zwei Parameter: Das zu füllende Array und der Wert, mit dem gefüllt werden soll:
int[] meinArray = new int[10];
Arrays.fill(meinArray, 2);Alle Array-Elemente haben nun den Wert 2.
Die Methode ist recht praktisch, um die Werte eines Arrays unkompliziert in einen bestimmten Ausgangszustand zurückzuversetzen.
Ausgewählten Bereich füllen
Mit der fill()-Methode ist es auch möglich, einen bestimmten Bereich eines Arrays zu füllen. Hierzu benötigt die Methode zwei weitere Parameter: Einen, um die Startposition (inklusive) und einen anderen, um das Ende der Range (exklusive) zu markieren:
char[] letters = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H'};
Arrays.fill(letters, 2, 7, 'X');Das Array hat nun folgende Werte:
[A, B, X, X, X, X, X, H]
Array kopieren mit copyOf() und copyOfRange()
Das gesamte Array kopieren
Die Methode copyOf() kopiert ein Array. Um eine vollständige Kopie aller Array-Elemente durchzuführen, benötigt die Methode bei der Ausführung zwei Argumente: Den Namen des zu kopierenden Arrays (das Original) und anschließend dessen Länge:
int[] original = {1, 2, 3, 4, 5};
int[] kopie = Arrays.copyOf(original, original.length);Einen Teilbereich kopieren
Wenn wir nur einen Teilbereich kopieren möchten, nutzen wir die Methode copyOfRange(). Um die zu kopierende Range festzulegen, geben wir als zweites Argument die Startposition (inklusive) und die Endposition (exklusive) des Originals an:
int[] original = {1, 2, 3, 4, 5};
int[] kopie = Arrays.copyOfRange(original, 0, 3); // 1, 2, 3Array vergrößern
Arrays sind statische Datenstrukturen, das heißt, dass die Größe nach der Erzeugung (anders als dynamische Datenstrukturen wie der ArrayList) nachträglich nicht mehr geändert werden kann (Unterschied Array vs. ArrayList). Was tun wir also, wenn wir merken, dass unser Array zu klein erzeugt wurde?
In solch einem Fall können wir die Methode copyOfRange() so einsetzen, dass wir eine Kopie eines Arrays erzeugen, die Größe der Kopie aber neu festzulegen:
int[] original = {1, 2, 3, 4, 5};
System.out.println(original.length); // 5
int[] kopie = Arrays.copyOfRange(original, 0, 20);
System.out.println(kopie.length); // 20Array von Objekttypen kopieren
Beim Kopieren eines Arrays von Referenzentypen müssen wir gut aufpassen. Es werden mit copyOf() nämlich nicht die Objekte kopiert, sondern lediglich die darauf zeigenden Referenzen.
Tiger one = new Tiger();
Tiger two = new Tiger();
Tiger three = new Tiger();
Tiger[] original = {one, two, three};
Tiger[] kopie = Arrays.copyOf(original, original.length);Die Kopie hat nun insgesamt die Größe von 20.
Für unser Beispiel bedeutet das, dass wir nach dem Kopieren immer noch nur drei Tiger-Objekte haben. Denn es wurden nicht die Tiger-Objekte, sondern die darauf zeigenden Referenzen kopiert:
