Array

1. Definition

Containerobjekte sind in Java im weitesten Sinn Objekte, die andere Objekte speichern und verwalten können. Dazu stellen sie bestimmte Methoden bereit, um auf die gespeicherten Objekte zuzugreifen. So können Objekte hinzugefügt, entfernt, gesucht oder verändert werden. Auch das Sortieren der Objekte ist bei manchen Containerobjekten möglich.

2. Merkmale von Arrays

Arrays sind die einfachsten Containerobjekte. Hier werden keine Methoden zur Verfügung gestellt, für das Hinzufügen und Löschen, das Suchen und Sortieren etc. müssen eigene Methoden entwickelt werden. Es sei denn, man hat die große Klasse Arrays studiert. Diese Klasse stellt sehr viele Methoden zum Umgang mit Arrays zur Verfügung. In der Schule oder Hochschule (zumindest in den ersten beiden Semestern) sollte man aber lernen, die wichtigsten Array-Methoden selbst zu implementieren, daher gehen wir hier nicht auf die Klasse Arrays ein, sondern auf die Datenstruktur Array. Übrigens heißt es im Deutschen "das Array" und nicht "der Array". Zwei dieser Arrays-Methoden werden unten auf dieser Seite unter Punkt 10 kurz besprochen.

Feste Größe:

Die Zahl der Arrayelemente wird bei der Initialisierung festgelegt und kann nicht mehr geändert werden.

int[] zahlen = new int[20];

Dieser Array mit dem Namen "zahlen" kann maximal 20 Elemente des Datentyps int speichern.

Homogener Typ:

Alle Elemente eines Array müssen den gleichen Datentyp besitzen. Dies kann ein primitiver Datentyp wie int oder double sein, es können aber auch Objekte von Klassen gespeichert werden.

Circle[] kreise = new Circle[100];

das Array kreise speichert bis zu 100 Objekte der Klasse Circle.

Indizierter Zugriff:

Die Elemente eines Arrays werden über einen sogenannten Index angesprochen.

kreise[5].changeColor("yellow");

Diese Anweisung ändert die Farbe des sechsten Kreis-Elementes. Das erste Element eines Array hat immer den Index 0, das letzte Element den Index N-1, wenn N die Zahl der Elemente ist.

3. Deklaration und Initialisierung von Arrays

Der folgende Quelltext zeigt verschiedene Möglichkeiten der Deklaration und Initialisierung von Arrays - alle am Beispiel von int-Arrays:

Initialisierung von int-Arrays

Dieses Bild zeigt verschiedene Arten der Deklaration und Initialisierung von int-Arrays.

In der Zeile 3 wird ein int-Array mit dem Namen zahlen deklariert. Die eckigen Klammern befinden sich hinter dem Bezeichner: int zahlen[]; Allerdings ist diese Art der Deklaration ungewöhnlich und recht selten - aber möglich.

In der Zeile 4 finden wir die "klassische" Variante der Deklaration, der eckigen Klammern hinter dem Datentyp int[] werte;.

In der Zeile 5 wird das Array primzahlen deklariert, initialisiert und gleichzeitig mit Werten gefüllt, den ersten Primzahlen bis 29. Die Größe des Arrays wird hier automatisch durch die Anzahl der in den Klammern {} stehenden Elemente bestimmt. Diese letzte Variante ist eine sehr bequeme Art, kleinere Arrays in "einem Rutsch" zu deklarieren, zu initialisieren und mit Werten zu befüllen.

Initialisierung mit Schleifen

Wenn die Werte eines int-Array bestimmten Regeln folgen, beispielsweise eine arithmetische oder geometrische Reihe bilden, aus den Quadratzahlen der Indices bestehen oder auf andere Weise leicht aus der Laufvariablen einer Schleife berechnet werden können, dann werden meistens for-Schleifen für das Befüllen des Arrays eingesetzt, seltener while-Schleifen.

int[] quadratZahlen = new int[10];
for (int i = 0; i < quadratZahlen.length; i++) 
    quadratZahlen[i] = i * i;

4. Typische Methoden mit Arrays

In diesem Abschnitt wollen wir ein paar typische Methoden kennenlernen, mit denen man in der Schule oder Hochschule am Anfang konfrontiert wird.

4.1 Ausgabe aller Arrayelemente in der Konsole

Fast alle Klassen, die Daten in Arrays speichern, benötigen eine Methode zur Ausgabe aller Arrayelemente. Da man in der Schule und Hochschule meistens nur mit Konsolenausgaben arbeitet, konzentrieren wir uns auf die formatierte Ausgabe eines Arrays in der Konsole.

    public void anzeigen()
    {
        for (int i=0; i < zahlen.length; i++)
        {
           System.out.printf("%6d",zahlen[i]);
           if ( (i+1) % 10 == 0) System.out.println();
        }
    } 

Mit zahlen.length erhalten wir die Anzahl der Arrayelemente. Bei einem Array der Größe 100 hat das letzte Element den Index 99, daher dürfen wir in der Schleifenbedingung nicht i <= zahlen.length schreiben, denn dann würde versucht, auf das Element mit dem Index 100 zuzugreifen, was zu einem Array-out-of-bounds-error führen würde.

Mit dem printf()-Befehl werden die Zahlen mit einer Breite von 6 Stellen nebeneinander ausgegeben, und immer wenn der Index (die Laufvariable i) durch 10 teilbar ist, wird ein Zeilenvorschub produziert.

4.2 Berechnung des Durchschnittswerts aller Zahlen in einem Array

Auch dies ist eine beliebte Aufgabe, die Schülern und Studenten immer wieder begegnet.

    public double gibDurchschnitt()
    {
        double sum = 0; 
        for (int i=0; i < zahlen.length; i++)
            sum += zahlen[i];
        return sum / zahlen.length;   
    }

4.3 Ermittlung der kleinsten Zahl des Arrays

    public int gibMini()
    {
        int mini = zahlen[0]; 
        for (int i=1; i < zahlen.length; i++)
            if (zahlen[i] < mini)
               mini = zahlen[i];
               
        return mini;       
    }

Etwas steigern kann man das Anspruchsniveau dieser Aufgabe, wenn man nicht die kleinste Zahl, sondern den Index der kleinsten Zahl ermitteln soll:

    public int gibMiniPos()
    {
        int mini = zahlen[0]; 
        int miniPos = 0;
        
        for (int i=1; i < zahlen.length; i++)
            if (zahlen[i] < mini)
            {
               mini = zahlen[i];
               miniPos = i;
            }   
               
        return miniPos;       
    }

Diese Methode lässt sich noch etwas kürzer gestalten:

public int gibMiniPos()
{
    int miniPos = 0;

    for (int i = 1; i < zahlen.length; i++)
        if (zahlen[i] < zahlen[miniPos])
            miniPos = i;

    return miniPos;
}

In dieser Version entfällt die lokale Variable mini vollständig, statt mini wird direkt zahlen[miniPos] verglichen.

5. Nicht vollständig gefüllte Arrays

Ein Array der Länge 100 oder 1000 muss nicht vollständig mit Werten gefüllt sein. Wenn man beispielsweise einen abstrakten Datentypen wie Stack, Queue oder List implementieren will, der direkt nach der Initialisierung noch leer ist, legt man zwar einen großen Array mit 50, 100 oder mehr Elementen Kapazität an, setzt aber einen internen Zähler, beispielsweise eine lokale Variable anzahl, auf den Wert 0. Diese Zähler verwaltet dann die Anzahl der tatsächlich vorhandenen Arrayelemente.

5.1 Einfügen eines weiteren Elements

    public void insert(int zahl, int index)
    {
        if (anzahl >= zahlen.length || index < 0 || index > anzahl)
            return;

        for (int i = anzahl; i > index; i--)
            zahlen[i] = zahlen[i - 1];

        zahlen[index] = zahl;
        anzahl++;
    }

5.2 Löschen eines Elements

    public void delete(int index)
    {
        if (index < 0 || index >= anzahl)
            return;

        for (int i = index; i < anzahl - 1; i++)
            zahlen[i] = zahlen[i + 1];

        zahlen[anzahl - 1] = 0;
        anzahl--;
    }  

Die Methode entfernt das Element an der angegebenen Position aus dem Array. Zunächst wird geprüft, ob der Index gültig ist. Danach verschiebt eine for-Schleife alle nachfolgenden Elemente um eine Position nach links, sodass das gelöschte Element überschrieben wird. Das letzte benutzte Array-Element wird anschließend auf 0 gesetzt, um den alten Wert zu löschen. Abschließend wird die Variable anzahl, die die aktuelle Belegung des Arrays beschreibt, um 1 verringert.

6. Zweidimensionale Arrays

Während es in Programmiersprachen wie C oder C++ "echte" zweidimensionale Arrays gibt (im Sinne eines zusammenhängenden rechteckigen Speicherblocks), kann man in Java einen zweidimensionalen Array nachbilden, indem man ein Array deklariert, dessen Elemente ebenfalls Arrays sind.

6.1 Beispiel 1

Hier ein einfaches Beispiel für ein Array, dessen Elemente Arrays aus int-Zahlen sind:

public class MatrixDemo
{
    private int[][] matrix;

    public MatrixDemo()
    {
        matrix = new int[3][4];    // 3 Zeilen, 4 Spalten
    }

    public void befuelle()
    {
        for (int zeile = 0; zeile < 3; zeile++)
            for (int spalte = 0; spalte < 4; spalte++)
                matrix[zeile][spalte] = (zeile + 1) * (spalte + 1);
    }

    public void ausgeben()
    {
        System.out.println("Inhalt der 3x4-Matrix:");
        for (int zeile = 0; zeile < 3; zeile++)       
        {
            for (int spalte = 0; spalte < 4; spalte++)
                System.out.printf("%4d", matrix[zeile][spalte]);

            System.out.println();
        }
    }
}

Erläuterung

Die Klasse MatrixDemo demonstriert den Umgang mit zweidimensionalen Arrays in Java. Im Konstruktor wird ein Array der Größe 3×4 angelegt, das also aus drei Zeilen und vier Spalten besteht. Jede Zelle dieses Arrays kann einen ganzzahligen Wert aufnehmen.

Die Methode befuelle() initialisiert die Matrix, indem sie jede Speicherzelle mit dem Produkt aus Zeilenindex und Spaltenindex (jeweils um 1 erhöht) füllt.

Die Methode ausgeben() gibt die Matrix anschließend zeilenweise auf der Konsole aus. Dabei durchläuft sie alle Zeilen und Spalten und formatiert die Ausgabe so, dass eine übersichtliche tabellenartige Darstellung entsteht.

Einzelheiten zur Deklaration und Initialisierung

Deklaration

Bei der Deklaration eines zweidimensionalen Arrays werden hinter dem Typbezeichner (z. B. int) zwei Paar eckige Klammern notiert:

private int[][] matrix;

Initialisierung

Bei der Initialisierung wird angegeben, wie viele Arrays das äußere Array enthalten soll und wie groß diese inneren Arrays sind:

matrix = new int[3][4];

Das Array matrix besitzt somit drei Elemente, und jedes dieser Elemente ist wiederum ein int-Array mit je vier Elementen. Auf diese Weise entsteht eine Matrix mit drei Zeilen und vier Spalten.

6.2 Beispiel 2

Hier sehen wir ein etwas komplexeres Beispiel für die Anwendung "zweidimensionaler" Arrays.

Die Tabelle habe ich mir übrigens von ChatGPT generieren lassen, die Namen habe ich mir also nicht ausgedacht, die Fächer dagegen habe ich vorgeschlagen.

Allerdings kann man diese schöne Tabelle nicht unmittelbar in einen zweidimensionalen Array übertragen. Die Tabelle enthält nämlich unterschiedliche Datentypen. Die Namen der Schüler(innen) werden als String gespeichert, die Bezeichnungen der Fächer ebenfalls, während die Noten als int-Zahlen gespeichert werden. Unterschiedliche Datentypen können aber nicht in einem Array gespeichert werden.

Würde man sich auf die reinen Noten beschränken, könnte man dagegen einen zweidimensionalen Array erstellen. Der "Hauptarray" würde die laufenden Nummern der Schüler(innen) enthalten, die untergeordneten Arrays dann die Noten der fünf Fächer:

int[][] noten = new int[12][5];

Wollte man auch die Namen der Schüler(innen) speichern, müsste man zunächst eine Klasse Schueler anlegen mit folgenden Instanzvariablen:

public class Schueler
{
   private String name, vorname;
   private int[] noten = new int[5];
   ...

In einer anderen Klasse könnte man dann einen Array aus Schueler-Objekten anlegen:

public class Noten
{
   private String klasse;
   private Schueler[] sch;
   ...

6.3 Beispiel 3

Das folgende Bild zeigt - in etwas abstrakter Weise - ein Schachbrett mit Spielfiguren:

"wB" ist zum Beispiel ein weißer Bauer, während "sK" für den schwarzen König steht.

Ein solches Schachbrett mit Figuren ist ein zweidimensionales Gebilde, im Grunde eine Tabelle, die man leicht mit Hilfes von "Arrays von Arrays" darstellen kann.

Deklaration

private String[][] brett;

Initialisierung und Befüllen

public void initialisiere()
{
    brett = new String[8][8]
    {
        // Reihe 8
        {"sT","",  "",  "",  "sK","",  "sS",""},
        // Reihe 7
        {"sB","sB","sL","",  "",  "",  "sB","sB"},
        // Reihe 6
        {"",  "",  "",  "wS","",  "sL","",  ""},
        // Reihe 5
        {"",  "",  "wB","wB","wB","",  "",  ""},
        // Reihe 4
        {"",  "",  "",  "",  "wS","wL","",  ""},
        // Reihe 3
        {"",  "wB","",  "",  "",  "",  "wB","wB"},
        // Reihe 2
        {"wB","",  "wD","wL","",  "",  "",  ""},
        // Reihe 1
        {"wT","wS","",  "",  "wK","",  "",  "wT"}
    };
}

Hier sehen wir eine einfache Initialisierung

brett = new String[8][8] { }

die aber mit einer recht komplexen "Befüllung" des Arrays verknüpft ist. Da sich die Positionen der einzelnen Spielfiguren nicht aus Laufvariablen von Schleifen berechnen lassen, ist diese Art der Befüllung die einzige Möglichkeit, die zur Verfügung steht.

Alternativ könnte man natürlich eine Methode schreiben

public void setze(int zeile, int spalte, String figur)
{
   brett[zeile][spalte] = figur;
}

Dann könnte man diese Methode für jede Figur einzeln aufrufen, was die Sache aber auch nicht unbedingt übersichtlicher macht.

7. Dreidimensionale Arrays

7.1 Beispiel farbiges Bild

Ein farbiges Bild, beispielsweise eine PNG-Datei, besteht aus einer zweidimensionalen Anordnung von Pixeln. Für ein schwarz-weiß-Bild ohne Graustufen würde tatsächlich ein zweidimensionaler Array ausreichen. Jedes Arrayelement wäre dann für einen weißen oder für einen schwarzen Pixel des Bildes verantwortlich.

Bei einem farbigen Bild sieht die Sache aber anders aus. Der zweidimensionale Array ist vielleicht 1600 x 1200 Pixel groß, aber jeder Pixel wiederum besteht aus drei Komponenten, nämlich dem Rot-Anteil, dem Grün-Anteil und dem Blau-Anteil. Im Grunde haben wir es hier schon mit einem dreidimensionalen Array zu tun.

Eine 12 x 12 Pixel große Graphik
Autor: Ulrich Helmich 11/2025, Lizenz: Public domain

Dieses Bild zeigt ein Bild, das aus 12 x 12 Pixeln besteht. Jedes Pixel wiederum setzt sich aus drei Werten zusammen, einem Rot-, einem Grün- und einem Blauwert. Zum Speichern eines solchen Bildes benötigt man einen dreidimensionalen Array. Die erste Dimension steht für die Zeilen des Bildes, die zweite für die Spalten und die dritte für die R-G-B-Farbanteile.

Die Deklaration und Initialisierung dieses dreidimensionalen Arrays könnte so aussehen:

int[][][] pixel;
pixel = new int[12][12][3];

7.2 Beispiel Notenliste

Die oben bereits erwähnte Notenliste aus 6.2 könnte um eine dritte Dimension erweitert werden, wenn zum Beispiel die zeitliche Entwicklung der einzelnen Noten dokumentiert werden soll:

Für jeden Schüler und jedes Fach die erste mündliche Note, die erste Klausurnote, die zweite mündliche Note und die zweite Klausurnote, das wäre dann ein Array aus vier int-Zahlen, der als Element des zweidimensionalen Arrays auftritt:

int noten[][][];

noten = new int[12][5][4];

das Array ist also für 12 Schüler(innen), 5 Fächer und 4 Noten pro Fach geeignet.

7.3 Beispiel CT-Scan

Ein CT-Scan besteht aus vielen Schichten (Slices). Jede Schicht ist ein Pixelbild mit verschiedenen Graustufen. Stapelt man alle Schichten übereinander, entsteht ein dreidimensionales Bild.

8. Typische Fehler beim Umgang mit Arrays

Bei der Arbeit mit Arrays kommt es gerade am Anfang leicht zu typischen Fehlern. Die folgenden Beispiele zeigen häufige Probleme und wie man sie vermeiden kann.

8.1 IndexOutOfBoundsException

Java-Arrays beginnen immer mit dem Index 0. Der letzte gültige Index ist array.length - 1.

Hier ein einfaches Beispiel:

public class FehlerBeispiel1
{
   private int[] zahlen = {10, 20, 30};

   public void testZugriff()
      System.out.println(zahlen[3]); 
}

Es soll die dritte Zahl des Array ausgegeben werden, diese hat aber nicht den Index 3, sondern den Index 2!

Oft treten solche Fehler auf, wenn eine for-Schleife den Array ausgeben oder auswerten soll:

public class FehlerBeispiel2
{
   private int[] zahlen = {1, 2, 3, 4, 5};

   public void ausgeben()
   {
      for (int i = 0; i <= zahlen.length; i++) 
			System.out.println(zahlen[i]);
	}
}

Hier wurde bei der Formulierung der Abbruchbedingung in der for-Schleife nicht aufgepasst. Der Wert von zahlen.length ist 5, das letzte Arrayelement hat aber den Index 4. Es hätte also heißen müssen: i < zahlen.length und nicht i <= zahlen.length.

8.2 NullPointerException bei Arrays von Objekten

Ein Array von Objekten enthält nach der Initialisierung nur null-Referenzen, keine fertigen Objekte.

public class FehlerBeispiel3
{
   private String[] namen = new String[3];

   public void testLaenge()
   {
      System.out.println(namen[0].length());  
   }
}

das Array wurde zwar korrekt deklariert und initialisiert, aber in dem Arrayelement mit dem Index 0 ist noch keine Referenz auf ein existierendes Objekt eingetragen, sondern nur der Wert null. Während die Adresse eines Objekts mit dem System.out.println()-Befehl ausgegeben werden kann (in völlig kryptischer Form allerdings), streikt der Befehl bei der Ausgabe eines null-Wertes.

Hätte man vor dem println()-Befehl folgende Zeile hinzgefüt:

namen[0] = "Otto";

dann würde tatsächlich "Otto" ausgegeben.

Einen solchen Fehler kann man aber auch bei einfachen Arrays machen. Schauen Sie sich dazu folgendes Code-Beispiel an:

   int[] zahlen;
	...
	zahlen[0] = 5;

das Array wurde zwar deklariert, aber noch nicht initialisiert. Daher existiert das Element zahlen[0] noch gar nicht und die Zuweisung führt zu einem Laufzeitfehler.

Das "Gemeine" an diesem Fehler ist, dass der Compiler ihn noch nicht bemerkt - zumindest bei BlueJ wird ein Quelltext mit einem solchen Fehler problemlos übersetzt. Erst wenn man die Methode mit diesem Fehler ausführen möchte, kommt eine lange Fehlermeldung: "java.lang.NullPointerException: Cannot store to int array because 'this.fehler' is null".

8.3 Verwechslung von Indizes bei 2D-Arrays

Ein Fehler, die selbst erfahrenen Entwicklern oft passiert, ist die Verwechslung der Zeilen und Spalten in einem zweidimensionalen Array. Als mathematisch geprägter Mensch ist man immer geneigt, bei den Positionsangaben von Objekten zuerst die x-Koordinate und dann die y-Koordinate anzugeben: (x,y).

Bei Tabellen ist es aber genau umgekehrt. Man gibt zuerst die Zeilennummer an, und dann die Spaltennummer - also erst die y-Koordinate, und dann die x-Koordinate.

Klar, dass das dann oft zu Fehlern im Umgang mit 2D-Arrays führt.

Im folgenden Beispiel enthält das Array zwei Zeilen mit jeweils drei Spalten:

public class FehlerBeispiel4
{
   private int[][] matrix = 
	{
      {1, 2, 3},    // Zeile 0
      {4, 5, 6}     // Zeile 1
   };

   public void testZugriff()
   {
      System.out.println(matrix[0][2]);  
      System.out.println(matrix[1][0]); 
   }
}

Ein Fehler wäre es beispielsweise, wenn man matrix[2][0] ausgeben wollte. Das hieße nämlich, dass man auf die dritte Zeile der Matrix zugreifen wollte. Es gibt aber nur zwei Zeilen, und der Index der zweiten Zeile ist 1. Der Index 2 ist also ungültig und würde zu einem Laufzeitfehler führen.

8.4 Falsche Arraygröße

Manchmal wird ein Array mit einer Größe initialisiert, die nicht ausreicht, um alle benötigten Elemente zu speichern, oder die zu groß ist und somit Speicherplatz verschwendet.

8.5 Verwechseln von Array-Referenzen

Wenn Sie ein Array A einer anderen Array-Variablen B zuweisen, kopieren Sie nicht die Inhalte des Arrays A, sondern lediglich die Adresse von A. Die Arrayvariable B zeigt dann auf den selben Speicherbereich wie die Arrayvariable A.

int[] arrayA = {1, 4, 7, 12};
int[] arrayB = {3, 5, 8};
...
arrayB = arrayA;
arrayB[0] = 2;
System.out.println(arrayA[0]);

Was wird hier passieren?

Obwohl das erste Element von ArrayA den Wert 1 hatte, wird die Zahl 2 ausgegeben.

Durch die Zuweisung arrayB = arrayA

wird jetzt in arrayB die gleiche Adresse gespeichert wie in arrayA. Wenn also arrayB[0] geändert wird, wirkt sich das auch auf arrayA[0] aus, den beide Arrayvariablen zeigen auf den gleichen Speicherbereich.

Dieses Phänomen wird als "flache Kopie" oder shallow copy bezeichnet.

Wenn Sie eine unabhängige Kopie eines Arrays erstellen möchten, die von Änderungen am Original nicht betroffen ist, müssen Sie eine "tiefe Kopie" oder deep copy durchführen. Das bedeutet, Sie erstellen einen neuen Array und kopieren die Elemente einzeln. Das würde am besten mit einer for- oder einer for-each-Schleife gehen. Aber auch die Java-Klasse Arrays stellt einige Methoden dafür zur Verfügung.

5.6 Verwechslung von Länge und Kapazität

Manchmal wird die Größe eines Arrays (die Anzahl der tatsächlich enthaltenen Elemente) mit seiner Länge (der maximalen Anzahl von Elementen, die es speichern kann) verwechselt. Dies ist besonders relevant, wenn man mit teilweise gefüllten Arrays arbeitet oder wenn man eine Datenstruktur (wie einen Stack) mit einem Array als zugrunde liegendem Speicher implementiert.

Im Oberstufenunterricht wird der Abstrakte Datentyp Stack häufig mit einem Array implementiert. Der Stack ist aber ein dynamischer Datentyp, seine Länge ist variabel und vor dem Übersetzen des Codes nicht bekannt. Daher nimmt man oft ein Array der Länge 100, 200 oder mehr. Wenn man aber nur fünf Stack-Elemente in dem Array gespeichert hat, die die effektive Größe des Arrays 5, während seine Länge 100, 200 oder mehr ist.

Wenn Sie jetzt also Code schreiben wie zum Beispiel

int[] stack;
stack = new int[100];
int groesse = 0;
...
stack[0] = 2;
stack[1] = 6;
stack[2] = 4;
groesse = 3;
...
for (int i=0; i < stack.length; i++)
   System.out.println(stack[i]);

dann erhalten Sie nicht die gewünschte Ausgabe, sondern der ganze Array wird ausgegeben. Bei einem int-Array würden dann die ersten drei Zahlen erscheinen, also 2, 6 und 4, und dann nur noch Nullen. Bei einem Objekt-Array würde dagegen das Element stack[2] noch ausgegeben, bei stack[3] würde aber ein Laufzeitfehler auftreten, da stack[3] und die folgenden Elemente noch keine brauchbare Adresse enthalten, sondern nur den Wert null.

9. Arrays als Parameter von Methoden

Man kann Arrays als Instanzvariablen von Klassen verwenden, so dass alle Methoden auf diesen Array zugreifen können.

Manchmal will man aber auch einfach eine unabhängige und universell einsetzbare Methode schreiben, die eine Operation auf einen beliebigen int- oder double-Array ausführt (oder auf Arrays mit anderen Elementtypen). Wenn eine solche Methode wirklich unabhängig von einer bestimmten Klasse sein soll, darf man innerhalb der Methode nicht auf ein Array mit einem konkreten Namen zugreifen. Die Methode weiß ja noch gar nicht, wie das Array heißt, den sie bearbeiten oder auswerten soll. Außerdem soll die Methode auf viele verschiedene Arrays mit unterschiedlichen Namen zugreifen können. Erst dann ist die Methode universell als Werkzeug einsetzbar. Betrachten wir einmal am Beispiel einer Suche nach der kleinsten Zahl, wie eine solche universelle Methode aufgebaut sein könnte:.

   public int mini(int[] zahlen)
   {
      int mini = zahlen[0];

      for (int i=1; i < zahlen.length; i++)
         if (zahlen[i] < mini)
            mini = zahlen[i];

      return mini;
   }

Der Kopf der Methode

public int mini(int[] zahlen)

hat einen formalen Parameter von Typ int[] namens zahlen, erwartet also beim Aufruf einen aktuellen Parameter ebenfalls vom Typ int[], dessen Name aber völlig egal ist.

Angenommen, wir haben in der Klasse oder in einer anderen Methode ein Array namens hundertZahlen deklariert und initialisiert und außerdem noch mit Zahlen gefüllt, dann können wir diese neue Methode wie folgt aufrufen:

int m = mini(hundertZahlen)

das Array hundertZahlen wird also als aktueller Parameter an die Methode übergeben. Die gefundene kleinste Zahl wird dann an die lokale Variable m überwiesen.

10. Methoden der Klasse Arrays

Die Klasse Arrays ist sehr groß. Daher sollen hier nur exemplarisch zwei Methoden vorgestellt werden.

10.1 Die Arrays.fill()-Methode

Die Klasse Arrays, die Java zur Verfügung stellt, bietet viele Methoden zum Umgang mit Arrays an. Zum Befüllen von Arrays wird die Methode fill() zur Verfügung gestellt. Diese Methode füllt ein Array mit gleichen Werten:

import java.util.Arrays;
...
int[] zahlen = new int[5];
Arrays.fill(zahlen, 9);

Die Klasse Arrays aus der Java-Bibliothek java.util muss erst noch importiert werden, das geschieht hier in der ersten Zeile. In der zweiten Zeile wird ein int-Array mit fünf Elementen deklariert und initialisiert, und in der letzten Zeile wird jedem der fünf Arrayelement der Wert 9 zugewiesen.

Die Methode Arrays.fill() ist sehr nützlich, wenn man einen großen Array mit einem bestimmten Initialwert befüllen will, ohne eine for-Schleife schreiben zu müssen.

10.2 Die Arrays.copyOf()-Methode

Wenn man die Inhalte eines Arrays in einen zweiten Array gleichen Typs kopieren will, kann man das mit einer for-Schleife machen, oder man benutzt die Methode copyOf() der Klasse Arrays:

int[] original = {1, 2, 3};
int[] kopie = Arrays.copyOf(original, 5); 

Die drei Zahlen des ersten Arrays werden in die drei ersten Elemente des zweiten Arrays hineinkopiert. Da der Parameter 5 in der copyOf()-Methode die Länge des zweiten Arrays aber auf 5 festgelegt hat, erhalten die beiden letzten Arrayelemente des zweiten Arrays die Werte 0.