Arrays

Dieses Kapitel basiert auf dem Arbeitsblatt "Arrays". Dort werden Arrays als durchnummerierte Sammlung gleichartiger Elemente eingefuehrt und in mehreren Stufen aufgebaut: Deklaration, Erzeugung, Initialisierung, mehrdimensionale Strukturen und Inhaltsvergleiche.

Grundidee von Arrays

Ein Array speichert mehrere Werte desselben Typs unter einem gemeinsamen Namen. Auf einzelne Elemente wird per Index zugegriffen:

array[5]

Wichtige Regel aus dem Blatt:

• In Java beginnt der Index bei 0.

Das bedeutet: Bei Laenge n sind gueltige Indizes 0 bis n - 1.

Deklaration und Erzeugung

Das Arbeitsblatt trennt zwei Schritte klar:

1. Deklaration

int[] a;
Kreis[] b;

2. Erzeugung eines konkreten Array-Objekts

a = new int[5];
b = new Kreis[10];

Bei a entstehen 5 Integer-Slots, bei b 10 Referenz-Slots auf Kreis-Objekte.

Initialwerte direkt nach der Erzeugung

Ein zentrales Detail aus dem Arbeitsblatt:

• primitive Zahlenwerte starten mit 0 bzw. 0.0
• boolean startet mit false
• Referenztypen starten mit null

Beispiel:

a[3] = 2;
b[4] = new Kreis(10, 20, 30);
b[5] = new Kreis(100, 200, 10);
b[6] = null;

Gerade bei Referenzarrays ist null wichtig, weil sonst beim Zugriff schnell NullPointerException entsteht.

Kurzschreibweise bei Initialisierung

Direkt bei der Deklaration geht eine kompakte Form:

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

Das Blatt erklaert, dass diese Form intern auf eine entsprechende Array-Erzeugung hinauslaeuft.

Wichtige Einschraenkung:

• Die reine Form {...} ist nur bei Initialisierung erlaubt.
• Spaeter braucht man:

x = new int[]{1, 2, 3};

length und Indexgrenzen

Jedes Array hat das Feld length.

System.out.println(x.length);

Greifst du ausserhalb des gueltigen Bereichs zu, wirft Java eine ArrayIndexOutOfBoundsException.

Das Arbeitsblatt stellt diesen Schutz bewusst heraus: Java erkennt solche Fehler zur Laufzeit klarer als manche Sprachen, die ungueltige Speicherzugriffe stillschweigend tolerieren.

Arrays sind Objekte

Ein Kernpunkt des Arbeitsblatts:

• Array-Variablen sind Referenzen auf Array-Objekte.

Das erklaert viele Verhaltensweisen:

1. Zuweisung kopiert nicht automatisch Inhalte, sondern Referenzen.
2. == vergleicht bei Arrays standardmaessig Referenzen, nicht Elemente.

Beispiel:

int[] a = {1, 2, 3};
int[] b = {1, 2, 3};
System.out.println(a == b); // false

Obwohl Inhalte gleich aussehen, sind es zwei verschiedene Objekte.

Inhaltsvergleich von Arrays

Sollen Inhalte verglichen werden, muss komponentenweise geprueft werden.

Typisches Muster:

1. beide null?
2. genau einer null?
3. Laengen gleich?
4. alle Komponenten gleich?

Erst dann ist "inhaltlich gleich" sinnvoll beantwortet.

Mehrdimensionale Arrays

Das Arbeitsblatt erklaert mehrdimensionale Arrays als "Arrays von Arrays".

int[][] matrix = new int[3][4];

Interpretation:

• 3 Zeilen (aeussere Dimension)
• 4 Spalten pro Zeile (innere Dimension)

Auch "jagged arrays" sind moeglich:

int[][] a = new int[3][];
a[0] = new int[2];
a[1] = new int[5];
a[2] = new int[8];

Innere Arrays duerfen unterschiedliche Laengen haben.

Typische Aufgaben aus dem Blatt

Aufgabe 1: Basisarrays aufbauen

• int[] der Laenge 5 mit Werten 1 bis 5 fuellen
• Kreis[] der Laenge 3 erzeugen und mit drei Kreisobjekten belegen

Aufgabe 2: 2D- und Referenzarrays

• double[3][4] mit Zufallszahlen fuellen
• Array von int[] mit inneren Laengen 1,2,3,4,5 aufbauen

Was hier trainiert wird:

• Schleifen ueber length
• sichere Initialisierung
• korrektes Denken in Referenzen

Beispielmethoden zur Vertiefung

public static int[] arrayAufsteigend(int n) {
    int[] result = new int[n];
    for (int i = 0; i < n; i++) {
        result[i] = i + 1;
    }
    return result;
}

public static boolean gleicheInhalte(int[] a, int[] b) {
    if (a == b) return true;
    if (a == null || b == null) return false;
    if (a.length != b.length) return false;

    for (int i = 0; i < a.length; i++) {
        if (a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

Diese Muster decken den Kern der Arbeitsblattlogik direkt ab.

Haeufige Fehlerbilder

1. Indexstart bei 1 angenommen In Java ist erster Index 0.
2. x[3] = ... in einem 3er-Array Maximaler Index waere 2.
3. Referenzarray nicht mit Objekten belegtb[i].methode() fuehrt dann zu NullPointerException.
4. == fuer Inhaltsvergleich genutzt Vergleicht Referenzen, nicht Elemente.
5. Mehrdimensionale Arrays als starre Matrix missverstanden Bei int[][] sind ungleiche Zeilenlaengen moeglich.

Didaktischer Merksatz

Arrays sind einfach zu starten, aber sie trainieren frueh mehrere wichtige Informatikideen gleichzeitig:

• Speicherstruktur
• Typsicherheit
• Laufzeitfehleranalyse
• systematisches Iterieren

Deshalb sind sie im Kurs ein Schluesselthema zwischen Grundlagen und spaeteren Datenstrukturen.

Erweiterte Uebungen

1. Implementiere minimum(int[] a) und maximum(int[] a).
2. Implementiere mittelwert(int[] a) als double mit korrektem Cast.
3. Implementiere haeufigkeit(int[] a, int wert).
4. Implementiere transpose(int[][] m) fuer rechteckige Matrizen.
5. Implementiere istRechteckig(int[][] m) zur Pruefung gleicher Zeilenlaengen.

Zusammenfassung

Das Arbeitsblatt vermittelt fuer Arrays fuenf dauerhafte Regeln:

1. Deklaration und Erzeugung unterscheiden.
2. Indizes laufen von 0 bis length - 1.
3. Arrays sind Objekte und werden per Referenz verwaltet.
4. Inhaltsvergleiche muessen komponentenweise erfolgen.
5. Mehrdimensionale Arrays sind Arrays von Arrays.

Wer diese Punkte sicher beherrscht, kann im naechsten Schritt Schleifen- und Methodenaufgaben auf Arrays sauber loesen.

Abbildungen

In der zugeordneten Datei wurden keine eingebetteten Bildobjekte gefunden.

Speicherbild fuer Arrays lesen lernen

Ein didaktisch starker Schritt aus dem Arbeitsblatt ist die explizite Vorstellung von Arrays als Objekte mit referenzierten Komponenten. Diese Sicht hilft sofort bei typischen Fehlern.

Beispiel:

Kreis[] kreise = new Kreis[3];

Direkt danach gilt:

• kreise referenziert ein Arrayobjekt der Laenge 3
• kreise[0], kreise[1], kreise[2] sind jeweils null

Erst nach

kreise[0] = new Kreis(...);

ist das erste Element ein konkretes Objekt.

Iterationsmuster sicher aufbauen

Das Grundmuster fuer eindimensionale Arrays:

for (int i = 0; i < array.length; i++) {
    // arbeite mit array[i]
}

Regel:

• Start bei 0
• Abbruch bei < length

Die Bedingung <= length ist ein klassischer Off-by-one-Fehler.

Direktinitialisierung und ihre Grenzen

Das Blatt nennt den Unterschied sehr klar:

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

ist nur in Initialisierungssituationen erlaubt.

Spaeter:

a = new int[]{1, 2, 3};

Wer das nicht unterscheidet, bekommt den bekannten Compilerhinweis "Array constants can only be used in initializers".

Mehrdimensionale Arrays als verschachtelte Struktur

Bei

int[][] matrix = new int[3][4];

existieren 3 innere Arrays zu je 4 Elementen. Im Blatt wird ausserdem gezeigt, dass auch unregelmaessige Formen moeglich sind.

int[][] jagged = new int[3][];
jagged[0] = new int[1];
jagged[1] = new int[4];
jagged[2] = new int[2];

Das ist wichtig fuer Aufgaben, in denen Zeilen unterschiedliche Laengen haben.

Komponentenvergleich sauber implementieren

Das Arbeitsblatt deutet die Vergleichslogik an. Eine vollstaendige Methode koennte so aussehen:

public static boolean istGleich(int[] a, int[] b) {
    if (a == b) return true;
    if (a == null || b == null) return false;
    if (a.length != b.length) return false;

    for (int i = 0; i < a.length; i++) {
        if (a[i] != b[i]) {
            return false;
        }
    }
    return true;
}

Damit werden sowohl Referenz- als auch Inhaltsfragen korrekt behandelt.

Aufgabenaufbau fuer Unterricht und Selbststudium

Stufe 1: Erzeugen und Fuellen

1. int[] der Laenge 10 mit Werten 1 bis 10
2. double[] mit Zufallszahlen

Stufe 2: Auswerten

1. Summe
2. Mittelwert
3. Minimum und Maximum

Stufe 3: Strukturaufgaben

1. 2D-Array fuellen
2. Zeilensummen berechnen
3. diagonale Elemente ausgeben

Stufe 4: Robustheit

1. null-Pruefungen
2. leere Arrays
3. unregelmaessige 2D-Arrays

So wird das Blattmaterial zu einer abgestuften Lernsequenz.

Fehlerdiagnose fuer Arrayaufgaben

1. Ist das Array ueberhaupt erzeugt (new)?
2. Stimmen Start-/Endindex?
3. Wurde bei Referenzarrays jedes Element instanziiert?
4. Wird length korrekt verwendet?
5. Wird versehentlich == statt Inhaltsvergleich genutzt?

Diese fuenf Fragen decken den groessten Teil typischer Schuelerfehler ab.

Einfache Hilfsmethoden fuer Tests

public static void druckeArray(int[] a) {
    if (a == null) {
        System.out.println("null");
        return;
    }
    System.out.print("[");
    for (int i = 0; i < a.length; i++) {
        if (i > 0) System.out.print(", ");
        System.out.print(a[i]);
    }
    System.out.println("]");
}

Solche kleinen Hilfsmethoden machen viele Uebungen deutlich schneller ueberpruefbar.

Transfer zu spaeteren Datenstrukturen

Arrays sind die Basis fuer viele spaetere Strukturen:

• ArrayList nutzt intern Arrays
• Matrizenalgorithmen basieren auf 2D-Arrays
• Such-/Sortieralgorithmen starten fast immer auf Arrays

Eine saubere Beherrschung dieser Grundlagen zahlt direkt auf Algorithmik und OOP-II ein.

Mini-Projektvorschlag

Implementiere ein kleines "Notenmodul":

• int[] noten
• Methoden: mittelwert, besteNote, haeufigkeit(note), anzahlBestanden
• Ausgabe einer kompakten Statistik

Dieses Projekt deckt Erzeugen, Iterieren, Auswerten und Praesentation in einem Uebungsrahmen ab.

Fazit der Vertiefung

Das Arbeitsblatt "Arrays" ist mehr als Syntaxtraining. Es trainiert ein fundamentales Speicher- und Referenzverstaendnis, das fuer nahezu alle weiteren Java-Kapitel gebraucht wird.

Abschlussserie zu Arrays

Implementiere eine Klasse ArrayWerkzeuge mit folgenden Methoden:

1. int[] kopiere(int[] a)
2. int[] umkehren(int[] a)
3. int summeGeraderWerte(int[] a)
4. boolean istSortiert(int[] a)

Zusaetzlich:

• Teste alle Methoden mit leerem Array, Einzelelement und Standardfall.
• Dokumentiere bei jeder Methode, ob der Rueckgabewert ein neues Array ist oder das Original veraendert wird.

So wird das Speicher- und Referenzverhalten, das im Arbeitsblatt angelegt ist, konkret und pruefbar umgesetzt.

Pruefungsnahe Kurzfragen

1. Warum startet der erste gueltige Index bei 0?
2. Was ist der Unterschied zwischen a == b und inhaltlichem Vergleich zweier Arrays?
3. Worin besteht der Unterschied zwischen int[][] m = new int[3][4] und int[][] m = new int[3][]?
4. Welche zwei Fehler treten bei Arrays besonders haeufig auf?

Diese Fragen fokussieren die typischen Klausurfallen des Themas.

Weiterfuehrende Praxisaufgabe

Implementiere int[] haeufigkeiten0bis9(int[] daten), die zaehlt, wie oft jede Ziffer 0 bis 9 vorkommt.

Anforderungen:

1. Rueckgabearray hat Laenge 10.
2. Ungueltige Werte (<0 oder >9) werden separat gezaehlt und ausgegeben.
3. Ergebnis wird mit einer Hilfsmethode formatiert dargestellt.

Diese Aufgabe verbindet Arrayzugriff, Validierung und Auswertung in einem realistischen Mini-Szenario.

Mini-Reflexion

Wer das Referenzverhalten von Arrays versteht, loest viele Fehler bereits vor dem ersten Debugginglauf.