Jetzt anmelden...

Login
Passwort
Registrieren

Java Tutorial #24

Die Klasse java.util.Arrays

In Java werden Arrays durch eine bereits vordefinierte Klasse namens Arrays auf dem Paket java.util unterstützt. Einige der praktistischen Methoden der Klasse sehen wir uns nun einmal genauer an.

Kommentare [0] 71 Views

Stefan 11.08.2020

Infos zum Artikel

Kategorie Java
Autor Stefan
Datum 11.08.2020

Thema in Kurzform

int[] meinArray = {5, 2, 1, 4, 3};

// Array in String zurückliefern
System.out.println(Arrays.toString(meinArray)); // [5, 2, 1, 4, 3]

// Array sortieren
Arrays.sort(meinArray); // 1, 2, 3, 4, 5

// Binäre Suche
Arrays.binarySearch(meinArray, 1); // 0

// Array füllen
Arrays.fill(meinArray, 1); // 1, 1, 1, 1, 1

// Array kopieren
int[] kopie = Arrays.copyOf(meinArray, meinArray.length);

// Arrays vergleichen
Arrays.equals(meinArray, kopie); // true

    Inhaltsverzeichnis

  1. Die Klasse Arrays einbinden
  2. Arrays in Strings umwandeln mit toString()
  3. Sortieren mit sort()
  4. Durchsuchen mit binarySearch()
  5. Vergleichen mit equals()
  6. Array füllen mit fill()
  7. Array kopieren mit copyOf() und copyOfRange()
  8. Übungen

Die Klasse Arrays einbinden

In Java werden Arrays durch eine bereits vordefinierte Klasse namens Arrays unterstü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 linare 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 linerare 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 Suchmethode zurü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, adernfalls 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 Argument: 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)); // 2

Vergleichen 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änge

Array füllem 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ültt 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 Wert:

[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, 3

Array 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); // 20

Array 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:

Java Array Objekte copyOf

Übungen

einfach

Sortieren Sie mit einer geeigneten Methode der Klasse Arrays das folgende Array:

int[] zahlen = {1, 4, -2, -2, 2, 0};
Lösung ein-/ausblenden

mittel

Bereiten Sie das folgende Array für eine binäre Suche vor. Suchen Sie anschließend mit sort() nach dem Element "Marc" und geben Sie den gefundenen Index am Bildschirm aus.

String[] namen = {"Peter",
                  "Klaus",
                  "Anton",
                  "Gabriel",
                  "Montana",
                  "Isabella",
                  "Monika",
                  "Fredric",
                  "Marc"};
Lösung ein-/ausblenden

schwer

Was wird mit folgendem Code am Bildschirm ausgegeben?

package p1;

public class A {

    private int v = 0;


    public int getV() {
        return v;
    }

    public void setV(int v) {
        this.v = v;
    }
}
package p1;
import java.util.Arrays;

public class Startklasse {

    public static void main(String args[]) {

        A[] a = {new A(), new A(), new A(), new A()};
        A[] b = Arrays.copyOfRange(a, 1, 3);

        a[2].setV(1);
        System.out.println(b[2].getV());

    }

}

A. 0
B. 1
C. 2
D. Exception zur Laufzeit

Lösung ein-/ausblenden

Falconbyte unterstützen

Kommentar schreiben

Nur angemeldete und aktivierte Benutzer können kommentieren.

Alle Kommentare

Es gibt bislang noch keine Kommentare zu diesem Thema.

Objektinteraktion

Wie interagieren Objekte in einem Programm miteinander?

Objekte löschen

Wir wissen, wie wir Objekte erstellen können. Aber wie werden wir sie wieder los?

Der Konstruktor

Was ist eigentlich ein Konstruktor?

FALCONBYTE.NET

Handmade with 🖤️

© 2018-2020 Stefan E. Heller

Impressum | Datenschutz

facebook programmieren lernen twitter programmieren lernen youtube programmieren lernen