Lernpfad:Objektorientierte Programmierung mit Java/Arrays

Diese Seite ist auch erreichbar unter link.ngb.schule/arrays

Systematisch Fehler suchen

Komplexe Arrays

Arrays (im Deutschen auch Felder genannt) erlauben es, Gruppen von Daten gleichen Typs in einer Variablen zu speichern. Bei der Initialisierung wird der Datentyp und die Anzahl der Werte (Größe des Arrays) festgelegt. Der Interpreter reserviert dann den nötigen Speicherplatz. Ein Integer-Array der Größe 3 belegt 96 Bit (3 x 32 Bit) plus 16 Bit für Statusinformationen (zum Beispiel die Größe des Arrays).

Deklaration

Ein neues Array kann mit dem Schlüsselwort new erzeugt werden:

// Deklaration eines Integer-Arrays der Größe 8
int[] zahlen = new int[8];

// String-Array der Größe 11
String[] worte = new String[11];

Sind die Elemente des Arrays fest und bekannt, dann kann eine Kurzform zur Deklaration genutzt werden:

// Deklaration eines Integer-Arrays der Größe 4 mit den Werten 5,6,7 und 8
int[] zahlen = {5, 6, 7, 8};

// String-Array der Größe 5
String[] worte = {"a", "b", "c", "d", "e"};

Soll das Array nicht in einer Variablen gespeichert werden, sondern zum Beispiel nur als Parameter in einem Methodenaufruf genutzt werden, dann kann diese Form genutzt werden:

taschenrechner.addiere(new int[]{5, 6, 7, 8});

Die Größe eines Arrays kann jederzeit über das length Attribut abgefragt werden.

int[] zahlen = new int[7];

zahlen.length; // 7

Zugriffe und Zuweisungen

Der Zugriff auf die Elemente eines Arrays erfolgt über einen Index. Dabei bekommt das erste Element den Index 0, das Zweite den Index 1, und so weiter. In einem Array der Größe n hat das letzte Element also den Index n-1.

Man könnte auch sagen, dass jedes Element in einem Array durch seinen Abstand zum ersten Element beschrieben ist.

Adressierung in einem Array mit Namen "feld"

Element	1	2	3	...	i	...	n-1	n
Index	0	1	2	...	i-1	...	n-2	n-1
Zugriff	feld[0]	feld[1]	feld[2]	...	feld[i-1]	...	feld[feld.length-2]	feld[feld.length-1]

Zuweisungen und Zugriffe erfolgen auch mit eckigen Klammern, wie bei der Deklaration.

int[] zahlen = new int[8];

zahlen[0] = 133; // Zuweisung zum ersten Element mit dem Index 0
zahlen[1] = 501; // Zuweisung zum zweiten Element mit dem Index 1

zahlen[0] + zahlen[1]; // Zugriff auf die Elemente mit Index 0 und 1

Zugriffe mit Indizes außerhalb des gültigen Bereichs (also i < 0 oder i > length) produzieren einen Fehler.

Arbeitsauftrag

Notiere in der ersten Zeile jeder Tabelle die Werte, die nach Ausführung des gezeigten Quelltextes im Array gespeichert sind. Das Ergebnis jedes Schrittes dient als Ausgangssituation für den nächsten.
Wichtig: Falls der Quelltext irgendwo einen Fehler enthält, dann wird der gesamte Code nicht ausgeführt (auch korrekte Zeilen nicht). Das Array ändert sich in dem Fall also nicht.

int[] zahlen = new int[6];

Inhalt	0()	0()	0()	0()	0()	0()
Index	0	1	2	3	4	5

zahlen[4] = 4;

Inhalt	0()	0()	0()	0()	4()	0()
Index	0	1	2	3	4	5

zahlen[5] = 5;
zahlen[6] = 6;

Inhalt	0()	0()	0()	0()	4()	0()
Index	0	1	2	3	4	5

zahlen[2] = zahlen[4] + 6;
zahlen[1] = zahlen[2] - 1;
zahlen[0] = zahlen[1] - 1;

Inhalt	8()	9()	10()	0()	4()	0()
Index	0	1	2	3	4	5

if( zahlen[3] == 0 && zahlen[0] == 0 ) {
    zahlen[5] = zahlen[2] / 2;
} else {
    zahlen[5] = zahlen[0] + zahlen[3];
}

Inhalt	8()	9()	10()	0()	4()	8()
Index	0	1	2	3	4	5

zahlen[3] = zahlen.length;

Inhalt	8()	9()	10()	6()	4()	8()
Index	0	1	2	3	4	5

Lösung

1.

Inhalt	0	0	0	0	0	0
Index	0	1	2	3	4	5

2.

Inhalt	0	0	0	0	4	0
Index	0	1	2	3	4	5

3. Das Array hat die Größe 6 und gültige Indizes für die Elemente sind 0,1,2,3,4,5. Die Zuweisung zahlen[6] = 6 erzeugt einen Fehler, da 6 kein gültiger Index ist.

4.

Inhalt	8	9	10	0	4	0
Index	0	1	2	3	4	5

5.

Inhalt	8	9	10	0	4	8
Index	0	1	2	3	4	5

6.

Inhalt	8	9	10	6	4	8
Index	0	1	2	3	4	5

Über ein Array iterieren

Da man oft die Größe eines Arrays im Vorfeld nicht kennt, muss man häufig mit einer Zählschleife über das Array iterieren, um Aktionen auf oder mit den Elementen auszuführen. Iterieren bedeutet hier, auf die Elemente des Arrays vom ersten bis zum letzten Schritt für Schritt zuzugreifen (es zu "durchlaufen"). Dazu kann man jedes Schleifenkonstrukt benutzen, üblich ist aber eine Zählschleife, da sie direkt einen Zähler für den Index bereitstellt.

// Zählschleife von 0 bis zahlen.length
// Die Zählvariable i durchläuft alle Indizes des Arrays
// Das Attribut "length" eines Arrays enthält seine Größe
for( int i = 0; i < zahlen.length; i += 1 ) {
	System.out.println(zahlen[i]);
}

Arbeitsauftrag

Notiere in der ersten Zeile jeder Tabelle die Werte, die nach Ausführung des gezeigten Quelltextes im Array gespeichert sind. Das Ergebnis jedes Schrittes dient als Ausgangssituation für den nächsten.
Falls der Quelltext irgendwo einen Fehler enthält, dann wird der gesamte Code nicht ausgeführt (auch korrekte Zeilen nicht). Das Array ändert sich also nicht.

Inhalt	8	9	10	6	4	8
Index	0	1	2	3	4	5

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

Inhalt	18()	19()	20()	16()	14()	18()
Index	0	1	2	3	4	5

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

Inhalt	10()	11()	12()	13()	14()	15()
Index	0	1	2	3	4	5

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

Inhalt	12()	13()	14()	17()	18()	19()
Index	0	1	2	3	4	5

for( int i = zahlen.length; i > 0; i-- ) {
    zahlen[i-1] = zahlen[i];
}

Inhalt	12()	13()	14()	17()	18()	19()
Index	0	1	2	3	4	5

for( int i = 1; i < zahlen.length; i += 2 ) {
    zahlen[i] = zahlen[i-1];
}

Inhalt	12()	12()	14()	14()	18()	18()
Index	0	1	2	3	4	5

for( int i = zahlen.length-1; i > 0; i -= 1 ) {
    zahlen[i] = zahlen[i]/2;
}

Inhalt	12()	6()	7()	7()	9()	9()
Index	0	1	2	3	4	5

Lösung

1.

Inhalt	18	19	20	16	14	18
Index	0	1	2	3	4	5

2.

Inhalt	10	11	12	13	14	15
Index	0	1	2	3	4	5

3.

Inhalt	12	13	14	17	18	19
Index	0	1	2	3	4	5

4.

Inhalt	12	13	14	17	18	19
Index	0	1	2	3	4	5

5.

Inhalt	12	12	14	14	18	18
Index	0	1	2	3	4	5

6.

Inhalt	12	6	7	7	9	9
Index	0	1	2	3	4	5

Übungen

Arbeitsauftrag

1. Erstelle eine Klasse Zufall mit einem Attribut zufallszahlen, das ein Integer-Array speichert. Das Array soll im Konstruktor initialisiert werden, wobei die Größe des Arrays dem Konstruktor als Parameter übergeben wird.
2. Implementiere eine Methode public void zahlenGenerieren(), die das Array mit Zufallszahlen zwischen 1 und 100 befüllt.
3. Implementiere eine Methode public void ausgeben(), die über das Array iteriert und die Elemente auf der Kommandozeile ausgibt.
4. Implementiere eine Methode public boolean suchen(int pZahl), die prüft, ob pZahl im Array enthalten ist.

Lösung

import java.util.Random;

public class Zufall {
    // Deklaration des Integer-Arrays
    private int[] zufallszahlen;

    /**
     * Konstruktor der Klasse Zufall.
     * @param pAnzahl Größe des Zufallszahlen-Speichers.
     */
    public Zufall( int pAnzahl ) {
        // Initialisierung des Integer-Arrays mit der
        // im Parameter übergebenen Größe.
        // Ist die Anzahl negativ wird sie durch 
        // multiplikation mit -1 positiv gemacht.
        if( pAnzahl > 0 ) {
            zufallszahlen = new int[pAnzahl];
        } else {
            zufallszahlen = new int[pAnzahl * -1];
        }
    }

    /**
     * Befüllt den Speicher mit Zufallszahlen.
     * @see java.util.Random
     */
    public void zahlenGenerieren() {
        // Instanziieren der Random-Klasse.
        Random r = new Random();
        // Mit einer Zählvariablen i für den Index der
        // Array-Elemente über das Array iterieren.
        for( int i = 0; i < zufallszahlen.length; i++ ) {
            // Generieren einer Zufallszahl zwischen 0 und 100.
            // Da 100 nicht eingeschlossen wird, wird durch Addition
            // von 1 der Bereich von 1 bis 100 (inklusive) verschoben.
            zufallszahlen[i] = r.nextInt(100) + 1;
        }
    }

    /**
     * Gibt die Zufallszahlen im Speicher auf die Konsole aus.
     */
    public void ausgeben() {
        // Mit einer Zählvariablen i für den Index der
        // Array-Elemente über das Array iterieren.
        for( int i = 0; i < zufallszahlen.length; i++ ) {
            System.out.printf("Zufallszahl %d: %d\n", i, zufallszahlen[i]);
        }
    }
    
    /**
     * Sucht im Speicher nach einer Zahl und gibt zurück,
     * ob die Zahl vorhanden ist.
     * @param pZahl Die Zahl, nach der gesucht werden soll.
    * @return Wahr, wenn die Zahl gefunden wurde.
     */
    public boolean suchen( int pZahl ) {
        // Mit einer Zählvariablen i für den Index der
        // Array-Elemente über das Array iterieren.
        for( int i = 0; i < zufallszahlen.length; i++ ) {
            if( zufallszahlen[i] == pZahl ) {
                // Zahl gefunden
                return true;
            }
        }
        // Wenn der Algorithmus hier ankommt heißt das:
        // Zahl nicht gefunden
        return false;
    }
}

Klassen und Objekte | Compiler und Interpreter | BlueJ | Syntax und Semantik | Datentypen und Variablen | Objektvariablen | Methoden | Parameter und Rückgaben | Objekte erstellen | Der Konstruktor | Referenzen | Klassenmethoden | Klassen der Java-Bibliothek | Systematisch Fehler suchen | Arrays | Komplexe Arrays | Vererbung | Abstrakte Klassen | Interfaces | Generische Typen | Fehlerbehandlung