Array

Das Array ist eine der wichtigsten Datenstrukturen in der Informatik.

Was ist ein Array?

Ein Array (engl. für "Feld") kann benutzt werden, um Daten des gleichen Typs so abzuspeichern, dass ein schneller Zugriff mittels Indizes ermöglicht wird. Ein Array ist sozusagen ein Schrank mit Schubladen. Jede dieser Schubladen hat eine Nummer, den Index, und in jeder Schublade ist ein Inhalt.

Deklaration

Typ[] Name;

Bei der Deklaration wird zuerst der Typ des Arrays angegeben, z.B. int[] für ein Integer-Array. Danach wird das Array benannt.

Bsp. 1:

int[] arr;

arr ist ein Integer-Array, in dem ganze Zahlen gespeichert werden können.

Bsp. 2:

char[] arr2;

arr2 ist ein Character-Array, in dem Zeichen gespeichert werden können.

Initialisierung

Bei der Deklaration wird noch kein Speicher für das Array belegt, dies geschieht erst mit der Initialisierung. Es gibt mehrere Arten und Weisen, die Initialisierung eines Arrays vorzunehmen.

Direkte Initialisierung

Ein Array kann direkt mit Werten gefüllt werden, um es zu initialisieren. Dadurch wird sowohl der Inhalt als auch die Größe des Arrays direkt bestimmt. Seine Größe kann danach nicht mehr geändert werden.

Typ[] Name = {Inhalt};

Bsp 1:

int[] arr = {2, 6, 8, 9, 1}

Dieses Array ist vom Typ Integer. Es beinhaltet die Zahlen 2, 6, 8, 9, 1 in dieser Reihenfolge. Dementsprechend beträgt die Länge dieses Arrays 5.

Bsp 2:

char[] arr2 = {'d', 'e', 'a'}

Dieses Array ist vom Typ Character. Es beinhaltet die Zeichen d, e, a in dieser Reihenfolge. Die Länge beträgt 3.

Bsp 3:

String[] arr3 = {"hello", "world", "foo", "bar"}

Dieses Array ist vom Typ String. Es beinhaltet die Zeichenketten hello, world, foo und bar.

Initalisierung mit new

Mit dem new-Operator kann ein Array auch initialisiert werden. Wenn man so das Array deklariert, muss seine maximale Länge angegeben werden.

Typ[] Name = new Typ[Länge]

Bsp:

int[] arr = new int[10];

Dieses Integer-Array besitzt die maximale Länge 10. Die Werte der Zellen des Feldes werden mit 0 gefüllt.

Verwendung

Speichern von Werten in einem Array

Einer Zelle des Arrays kann ein Wert zugewiesen werden, indem der Name des Arrays und der Index der Zelle in eckigen Klammern notiert wird, gefolgt von der eigentlichen Zuweisung mit =.

Name[Index] = Wert

Bsp:

arr[1] = 5;

Aufbau der Indizes des Arrays

Jedes Element eines Arrays hat einen Index. Die Zählung beginnt mit 0.

Länge eines Arrays

Die Länge eines Arrays kann durch Name des Arrays .length rausgefunden werden. Dieser Wert kann als Variable verwendet werden.

Laenge = arr.length;

Der Variable Laenge wird die Länge des Arrays arr zugewiesen.

Arraybefüllung mittels Schleife

Ein Array kann auch mit Hilfe von Schleifen gefüllt werden. Sowohl Indizes als auch Werte können Variablen sein. Wichtig hierbei ist, dass die Länge n ist, die Indizes aber von 0 bis n-1 gehen.

Bsp:

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

Jedem Element dieses Arrays wird der doppelte Indexwert zugewiesen.

Mehrdimensionale Arrays

Allgemeine Informationen

Arrays können, theoretisch, unendlich viele Dimensionen besitzen. Mehrdimensionale Arrays werden ähnlich deklariert, initialisiert und verwendet wie die hier bisher behandelten eindimensionalen Arrays.

Zweidimensionales Array

Ein zweidimensionales Array kann man sich als Matrix vorstellen. Jedes Element hat nun zwei Indizes.

Deklaration eines 2D-Arrays

Typ[][] 2arr;

Initalisierung eines 2D-Arrays

Typ[][] 2arr = { {Wert 1, Wert 2} , {Wert 1, Wert 2}}

oder

Typ[][] 2arr = [5][4];

Verwendung eines 2D-Arrays

Name[Index x][Index y] = Wert;

Weitere Beispiele

Eine n x n-große Matrix soll programmiert werden. Dabei soll der Wert der Elemente die Summe der verdoppelten Indizes sein.

public static int[][] rechne(int n){
int[n][n] erg;

for(int i = 0; i < n; i++){
   for(int j = 0; j < n; j++){
       erg[i][j] = 2*i+2*j;
   } 
}

return erg;
}

Auch hier soll eine n x n große Matrix programmiert werden:

pulbic static int[][] rechne2(int n){
int[n][n] erg;

for (int i = 0; i < n; i++){
    for(int j = 0; j < n; j++)
       if(i == 0 && j == 0){
          erg[0][0] = 1;
       }
       else if(i == 0){
            erg[0][j] = 2*j;
            }
            else if(j == 0){
                 erg[i][0] = 2*i;
                 }
                 else{
                      erg[i][j] = erg[i-1]+erg[j-1];
                     }
     }
}
}