Arrays Flashcards
Arrays
° Sammlung gleichartiger Elemente
° Zugriff erfolgt über einen Index
° Listen mit fester Größe
° Abstrahieren von einem zusammenhägenden Speicherbereich mit indiziertem Zugriff auf die Speicherzellen
Arrays für Bilddaten
° Bilder sind zweidimensionale Strukturen einzelner Bildpunkte
° Bildgröße (Zeilen und Spalten) ist statisch
° Informationen über Bildpunkte müssen für Bildverarbeitung schnell zugreifbar sein
Arrays in Java
° geordnete Reihung gleichartiger Elemente
° Elementtypen können Basistypen oder Referenztypen sein (auch Referenzen auf andere Arrays)
° Die Länge eines Array wird erst beim Erzeugen festgelegt
° Jeder Zugrigg über den Index wird automatisch geprüft
Arrays Objekte
° Array in Java immer eine Objekt (Arrays haben alle Eigenschaften, die in der Klasse Object definiert sind)
° Array-Variable ist immer eine Referenzvariable ( Typ ist Array von Elementtyp)
° Deklaration eines Array von integer-Werten:
int[] intArray;
-> Länge/Größe des Arrays wird in Deklaration nicht angegeben
Array Deklaration
° Type [] Identifier
° // Array-Variable mit primitivem Elementtyp (Array von int)
int[] numbers;
° // Array-Variable mit einem Objekttyp als Elementtyp (Array von Person)
Person[] people;
Array Erzeugung
° Array-Objekte müssen explizit erzeugt werden ( wie alle Objekte mit new)
new Type [ LengthExpression]
° Länge wird definiert oder berechnet und bleibt unverändert
intArray = new int [8];
° Deklaration und Erzeugung können zusammengefasst werden:
int[] intArray = new int [8];
° // Erzeugung eines Arrays mit primitivem Elementtyp
new int[10]
° // Erzeugung eines Arrays mit einem Objekttyp als Elementtyp
new Person[x]
Initialisieren von Array-Zellen
° Bei Array- Erzeugungen erhalten die Zellen eines Arrays in Java die Default-Werte des Elementtyps
° Neben der normalen Zuweisung von Werten kann ein Array auch implizit erzeugt und direkt initialisiert werden
° implizite Erzeugung und Initialisierung mit geschweiften Klammern ist ausschließlich bei der Deklaration erlaubt!
int[] intArray = {1,2,3,4,5,6,7,8};
Indizierung bei Arrays
° beginnend bei 0
° Gültiges Indiz: ganzzahlig von 0 bis length -1
° Beispiel: Array mit Größe 8 hat gültiges Indiz von 0…7
Schreibender und lesender Zugriff auf Array-Zellen
° Auf die Array-Zellen wird mit eckigen Klammern [] zugegriffen:
float element = temperatures [0]; // lesender Zugriff temperatures[3] = 21.2f; //schreibender Zugriff temperatures[0] = temperatures [1]; //lesender Zugriff
° Array-Zellen speichern Werte oder Referenzen auf Objekte genau wie andere Variablen auch
Typische Fehler
° Array der Größe
- System.out.println(temperatures[8]);
- > Fehlermeldung: ArrayIndexOutOfBoundsException: 8
° Array als Exemplarvariable deklariert: private int[] _numbers;
° Im Konstruktor als erstes: _numbers[0] = 42;
-> Fehlermeldung: NullPointerException
-> Erzeugung des Arrays fehlt: _numbers = new int [8];
° Array mit Objekttyp als Elementtyp deklariert und initialisiert:
- Konto[] konten = new Konto [4];
° direkt danach:
- konten[0].einzahlen(123);
-> Fehlermeldung: NullPointerException
° Erzeugung der Elemente des Arrays fehlt
For-Schleifen und Arrays
° Einsetzung von For-Schleifen, um alle Elemente eines Arrays zu bearbeiten
° die öffentliche Exemplarkonstante length wird dabei benutzt
° Standardbenutzung einer For-Schleife für Arrays wird als Programmiermuster bezeichnet
public void printArray(int[] intArray)
{
for (int i = 0; i < intArray.length; ++i)
{
System.out.println(intArray[i]);
}
}
Erweiterte For-Schleife für Arrays
° erspart den Zugriff auf length
° ist nicht geeignet, wenn an der Belegung der Zellen etwas geändert werden soll. Im Schleifenrumpf steht kein Schleifenindex zur Verfügung.
public void printArray(int[] intArray)
{
for (int k: intArray)
{
System.out.println(k);
}
}
Zuweisungen mit Arrays
° Zuweisung einer Array-Variable kopiert nur eine Referenz!
int[] intArray1 = {1, 2, 3};
int[] intArray2 = intArray1;
° Beide Referenzen verweisen nun auf dasselbe Array-Objekt
° Für eine Kopie des Array-Objektes gibt es zwei Möglichkeiten:
- Elementenweise in ein neues Array-Objekt kopieren
- Methode clone verwenden
Kopieren von Array-Objekten
° Neues Array-Objekt selbst erzeugen und elementweise kopieren:
int[] intArray1 = {1, 2, 3};
int[] intArray2 = new int [intArray1.length];
for (int i = 0; i< intArray1.length; ++i)
{
intArray2[i] = intArray1[i];
}
° mit der Methode clone:
int[] intArray1 = {1, 2, 3};
int[] intArray2 = intArray1.clone();
Zweidimensionale Arrays
° Zweidimensionale Arrays in Java sind Arrays von eindimensionale Arrays
° a [3][1]
- a eine Referenz auf ein Array von Zeilen
- Der erste Index benennt die Zeile, der zweite de Spalte
Zweidimensionale Arrays erzeugen
° Mit new ist es möglich zweidimensionale Arrays direkt zu erzeugen. new int [5][4]
int[] [] a;
a = new int[5] [];
for ( int i = 0; i < 5; ++i)
{
a[i] = new int[4];
}
Zugriff auf zweidimensionale Arrays
// Alle Array-Element auf den Wert 7 setzen
for (int row=0; row < a.length; ++row)
{
for (int column=; column < a[row].length; ++column)
{
a[row][column] = 7;
}
}Kopieren von mehrdimensionalen Arrays
° Manuell kopieren
° mit der Methode clone
- ist für Arrays nicht rekursiv implementiert
- d.h., bei einem Aufruf von clone auf einer Array-Variablen für ein mehrdimensionales Array wird nur das Array auf der obersten Ebene kopiert
-> Wenn vollständige Kopie gewünscht, muss man manuell für alle Dimensionen geklont werden
Vorteile von Arrayas
° Effizienzvorteile durch speichernahe Implementation:
- Elementzugriff kann direkt auf einen Index-Zugriff abgebildet werden; sehr effizient
- Effiziente Kopiervorgänge von Arrays
° Arrays in Java haben gegenüber den dynmaischen Sammlungen den Vorteil, dass sie auch elementare Typen als Elementtyp zulassen
Nachteile von Arrays
° Array hat nach der Erzeugung eine fest Maximalkapazität
° Auf einem Array gibt es außer dem indizierten Zugriff keine höherwertigen Operationen (z.B. einfügen, entfernen, anfügen, testen auf Enthaltensein)
