• Felder (arrays) sind Beispiele für Datenstrukturen
• ein Array ist ein Container; enthält
  • festgelegte Anzahl von Werten
  • eines definierten Typs
• Elemente sind durchnummeriert
• Arrays dienen zur Darstellung/ Verarbeitung z.B. von Listen

• nummerierte Liste fester Größe bestehend aus Elementen gleichen Typs
• Zugriff durch ganzzahligen Indizes beginnend bei 0
• Index implizit -> braucht keinen Speicher

<datentyp>[] <Variable-Name>;

Erläuterung:

• deklariert mit eckigen Klammern nach dem Datentyp
• Array-Deklaration bestehend aus 2 Teilen:
  • Datentyp
  • Name des Arrays
• unmittelbar nach der Deklaration kann noch nicht auf die Array-Variable zugegriffen werden -> Datenfeld mit fester Länge muss noch im Speicher erzeugt werden

Beispiel:

int[]    arrayOfInt;
String[] wordList;
float[]  prices; 

Reservieren des notwendigen Speichers (Festlegen der Länge)

<Array-Variable> = new <Datentyp>[<Laenge>];

Erläuterung:

• Erzeugung mittels Operator new
• : Zeigervariable
• : kann auch komplexer Ausdruck sein mit Ergebnis: ganze Zahl
  • Arrays mit Länge 0 sind möglich

Beispiel:

int laenge = 10;
int[]    a;
String[] s;

a = new int[5];
s = new String[laenge * 5 + 1];

Hinweis: Typen müssen paarweise übereinstimmen!

<Variablen-Name> [<Indes-Wert>]

Erläuterung:

• Nummerierung der Elemente:
  • beginnt bei 0
  • endet bei Array-Länge -1
• <Indes-Wert: kann auch komplexer Ausdruck sein (Ergebnis davon muss ganzzahliger Wert sein)

Beispiel:

float[] prices;

...
float price = prices[3]    // lesender Zugriff

int a = 2;
price = prices[4 * a +7];  // komplexer Ausdruck als Index

prices[5] = 2.3f           // Zuweisung eines Wertes

fehlerhafter Zugriff:

• zulässiger ganzzahliger Index: 0 <= Index-Wert < Array-Länge
• bei Zugriff auf unzulässigem Index -> Programmabbruch mit Fehlermeldung

gespeichert in Instanzvariable length

Beispiel:

int[] a = new int[5];    // Array mit Länge 5 angelegt
int laenge = a.length;

a[laenge - 1] = 2;      // OK
a[laenge]     = 15;     // liefert Laufzeitfehler

• bei Erzeugung wird den einzelnen Elementen der Standardwert des Datentyps zugewiesen
• verschiedene Formen der Generierung möglich

Beispiel:

String[] s = new String[5];  // Erzeugung eines Arrays bei der Deklaration der Array Variable

int[] primes = { 2, 3, 5, 7, 11};  // Erzeugung durch Angabe der Elementenmenge in geschweiften Klammern {}
                                   // Werte können beliebige Konstanten, Variablen oder beliebige Ausdrücke sein
                                   // Länge wird automatisch ermittelt
int[] prime = new int[] { 2, 3, 5, 7, 11}; 

• bei Deklaration einer Variable vom Array Typ wird nur eine Referenz auf das Datenobjekt festgelegt
• durch Operator new wird Speicherplatz für das Feld angefordert/ reserviert
  • Element erhalten zunächst einen Initialwert (wenn keine Werte explizit durch eine Initialisierung zugewiesen wurden)
• mit einer expliziten Initialisierung werden Werte an Feldelemente zugewiesen
• Initialisierung müssen gleichzeitig mit Deklaration oder Generierung durch den Konstruktor erfolgen

Beispiel:

int[] binom;
binom = new int[] {1, 4, 6, 4, 1};

oder

int[] binom = {1, 4, 6, 4, 1};

Verhalten der Referenz für Array und für normale Variablen identisch:

-> Sie sind nach der ersten Zuweisung verwendbar

Beispiel:

int[] list;
int arg,
    len;

len = list.length;  // ergibt Compiler-Fehler: list existiert nicht

list = new int[3]
list[0] = arg;      // ergibt Compiler-Fehler: arg besitzt keinen Wert

Verweis auf Speicherstellen

• eine Array-Variable enthält nicht das Array selbst, sondern nur einen Verweis auf eine Stelle im Speicher, an der sich das eigentliche Array befindet
  • Array-Variable hat immer eine feste Größe
  • Array selbst kann mit beliebiger Größe angelegt werden
  • Arrays können nicht dynamisch wachsen
• Referenzvariablen: Variablen, die einen Zeiger auf ein Objekt enthalten

int[] list = new int[7];

list [5] = 12;

int[] list;
int[] b = new int[12];

list = b; 

Erläuterung:

• mit Array-Variable list existiert ein Zeiger auf ein Array mit 7 Elementen
• an das 6. Element des Arrays wird der Wert 12 zugewiesen

• Zuweisung einer Array Variable an eine andere Array-Variable -> beide Variablen verweisen auf dasselbe Array Objekt

Mit der Allokation eines Arrays mit einer definierten Anzahl von Elementen werden diese implizit mit einem Default Wert initialisiert.

• Datentyp -> Standardwert
• byte -> (byte) 0
• short -> (short) 0
• int -> 0
• long -> 0L
• float -> 0.0f
• double -> 0.0d
• char -> (char) 0
• boolean -> false
• Referenzdatentyp -> null

<Datentyp>[] arr = new <Datentyp>[<Integer-Ausdruck>];

...          // notwendige Initialisierung
for (int i = 0; i < arr.length; i++) { 
...         // Verarbeitung des Elements arr[i]
}

schematischer Ablauf:

• Index-Variable wird mit 0 initialisiert
  • Arrays beginnen stets mit Index 0
  • Array-Variable wird hier mit arr bezeichnet
• Array hat feste Länge
  • mit Instanzvariable .length abgelesen
• letztes Element des Array steht an Position arr.length - 1
• Elemente des Arrays werden nacheinander sequentiell durchlaufen

Summation von Elementen (Addition aller Werte in einem Array)

double sum = 0;
for (int i = 0; i < arr.length; i++) { 
   sum = sum + arr[i];
}

Zählen von Elementen (zählen aller Elemente mit negativen Wert -> wenn neg. Wert auf Null setzen)

int count = 0;
for (int i = 0; i < arr.length; i++) { 
   if (arr[i] < 0.0) {
      arr[i] = 0.0;
      count++;
   }
}

Zählen von Elementen (zählen aller Paare benachbarter Elemente mit gleichem Wert)

int count = 0;
for (int i = 0; i < arr.length; i++) { 
    if (arr[i] == arr[i+1]) {
       count++;
    }
}

Finden des größten Elements

double maxVal = arr[0];
for (int i = 0; i < arr.length; i++) { 
   if (arr[i] > maxVal)
      maxVal = arr[i];
}

Kopieren eines Arrays

double[] B = new double[arr.length];
for (int i = 0; i < arr.length; i++) { 
    B[i] = arr[i];
}

double[] B = new double[arr.length];
System.arraycopy(arr, 0, B, 0, arr.length);

Hinweis: Java biete eine vordefinierte Funktion, die in der Klasse System deklariert ist und für beliebigen Objekte deren Element kopiert.

public static void arraycopy (Object sourceArray, int SourceStartIndex, 
                              Object destArray, int destStartIndex, int count)

for (<Basis-Typ> item : anArray ) {
   ...      // Verarbeitung von item
}

Erläuterung:

• item: Kontroll-Variable der Schleife
  • Hinweis: Kontroll-Variable muss in einer for-each Anweisung in der Schleife definiert werden!
• : Basistyp des Arrays

Beispiel:

double[] arr = new double[512];

double sum = 0;
for ( double item : arr ) {
   if ( item > 0 )
     sum = sum + item;
 }

<datentyp>[][] <Variablen-Name>;

Erläutertung:

• : Vereinbarung einer Zeigervariable

Beispiel:

int[][] mat;

 mat = new int[3][4];

Hinweis: Deklaration und Generierung kann wieder zusammen gefasst werden

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

• Anweisung mat = new int[3][4] generiert ein Datenobjekt
  • ein Array von Arrays von int Werte
• Elemente des Datenobjekts mit Wert 0 initialisiert
• Datenstruktur/Verweise = Matrix/Gitter

Die Initialisierung muss gleichzeitig mit der Deklaration oder der Generierung durch den Konstruktor erfolgen. Dabei werden die Werte für jede weiter Dimension erneut in geschweiften Klammern geschlossen.

Beispiel:

int[][] multiDim;

// Initialisierung entspricht int[3][2]
multDim = new int[][] { {5 , 7}, {3 , 6}, {7 , 9} }; 

Beispiel:

int[][] mat = new int [] { { 1,   0, 12, -1},
                           { 7,  -3,  2,  5},
                           { -5, -2,  2, -9} };

Direktzugriff auf ein Element: mat[i][j], 0 <= i < 3 und 0 <= j < 4

mat[0][0]  mat[0][1]  mat[0][2]  mat[0][3]
mat[1][0]  mat[1][1]  mat[1][2]  mat[1][3]
mat[2][0]  mat[2][1]  mat[2][2]  mat[2][3]

• jede Zeile als Array repräsentiert
  • Zugriff auf das Array oder seine Elemente möglich
• 2D Arrays sind Arrays von Arrays
• können Zeilen mit unterschiedlicher Länge besitzen
  • d.h. jede Zeile kann unterschiedlich viele Elemente enthalten

Beispiel:

int[][] multiDim = new int[][] { {5 , 7},
                                 {8 , 9, 10, 0},
                                 {1},
                                 {6 , 9} };

int[][][] cube;

Folge von eckigen Klammern entsprechen der Dimension

Beispiel: Dimension 5

 int[][][][][] structure;

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

Hinweis: Ohne explizite Zuweisung von Werten werden die Elemente mit default Werten (hier:0) initialisiert

structure = new int[3][4][3][][]

Erläuterung: Es werden Zeigervariablen generiert, die letzten Dimensionen werden hier noch nicht angelegt

Um alle Elemente zu durchlaufen, werden häufig geschachtelte Schleifen verwendet

Beispiel:

int[][][] arr = new int [4][5][6];

double sum = 0.0d;

for (int i = 0; i < 4; i++) {
   for (int j = 0; j < 5; j++) {
      for (int k = 0; k < 6; k++) {  // Achtung: Array-Länge

          // Achtung: Index-Variablen in der richtigen Reihenfolge
          sum += arr[i][j][k];
      }
   }
}