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 Inhalt als auch Größe des Arrays direkt bestimmt. Seine Größe kann 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. Das Array wird mit Initialwerten gefüllt.

Verwendung

Speichern von Werten in einem Array

Name[Index] = Wert

Bsp:

arr[1] = 5;

Aufbau der Indexe 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 Indexe als auch Werte können Variablen sein. Wichtig hierbei ist, dass die Länge n ist, die Indexe aber von 0 bis n-1 geht.

Bsp:

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

Jedem Element dieses Arrays wird der doppelte Indexwert zugewiesen.

Mehrdimensionale Arrays

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 2-Dimensionales Array kann man sich als Matrix vorstellen. Jedes Element hat nun zwei Indexe.

Deklaration eines 2-d Arrays

Typ[][] 2arr;

Initalisierung eines 2-d Arrays

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

oder

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

Verwendung eines 2-d 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 Indexe 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];
                     }
     }
}
}