Grundlagen: Arrays

Arrays sind eine Ansammlung von Werten des gleichen Datentyps. Dabei werden die Werte innerhalb einer Variablen gespeichert. Man könnte sagen, dass ein Array eine Liste ist. Wir werden jedoch später ein Objekt namens List kennenlernen, mit welchem wir ein „besseres“ Array erzeugen können. Wichtig zu wissen ist, dass ein Array nicht vergrößert werden kann. Ein Array hat immer die Anzahl x an Werten, weshalb es auch als statisches Array bezeichnet wird.
Bei den zumeist eingesetzten Arrays handelt es sich um sogenannte eindimensionale Arrays, d. h. sie besitzen nur eine Dimension (eine Spalte mit mehreren Zeilen). Um ein Array zu deklarieren, müssen wir bei der Variablendeklaration hinter dem Datentyp die eckigen Klammern ([]) notieren. Bei der Variableninitialisierung benötigen wir nun das Schlüsselwort new, welches vor dem Datentyp notiert wird. Die genaue Bedeutung von new werden wir im Thema Objektorientierung genauer kennenlernen. In den Klammern notieren wir nun die Anzahl der Elemente. Um auf die einzelnen Elemente zugreifen zu können, benötigen wir die Indexierung. Hierbei wird der Variablenname mit den eckigen Klammern notiert, in welcher der Index angeben wird. Der Index ist also ein Zähler. Die Zählweise beginnt bei 0 und entspricht dem 1. Element. Über die Eigenschaft Length können wir die Anzahl der Elemente abrufen.
Um ein Array zu verändern oder darin etwas zu suchen, gibt es die Klasse Array. Mit der Funktion Sort() können wir ein Array sortieren. Dabei wird es mit Hilfe des sogenannten Standard-Vergleichs aufsteigend sortiert (numerisch bei Zahlen, alphabetisch bei Zeichenketten). Die Funktion Reverse() kehrt die Reihenfolge aller Array-Elemente um. Mit der Funktion IndexOf() und LastIndexOf() können wir das erste bzw. letzte Vorkommen einer Zahl, eines Zeichens oder einer Zeichenkette im Array suchen. Die Funktionen geben den Index zurück und sind somit ebenfalls null-basierend.
Ein zweidimensionales Array hat x Spalten und y Zeilen. Diese Angabe wird bei der Variableninitialisierung in den eckigen Klammern angegeben. Dabei werden die Werte durch ein Komma getrennt. Bei Variablendeklaration muss innerhalb der eckigen Klammern ebenfalls das Komma notiert werden. Die Anzahl darf jedoch, wie beim eindimensionalen Array auch, nicht angegeben werden. Bei der Indexierung muss nun ebenfalls die Spalte und Zeile angegeben werden (durch Komma getrennt). Das zweidimensionale Array erinnert also an eine Tabelle. Über die Funktion GetLength() können wir die Anzahl der Elemente der gewünschten Ebene abrufen. Dazu müssen wir als Parameter den Index der Ebene übergeben: 0 = 1. Ebene = Spalte, 1 = 2. Ebene = Zeile.
Natürlich ist es auch möglich, Arrays mit mehr als 2 Dimensionen zu erstellen. Grundsätzlich spricht man von mehrdimensionalen Arrays. Es müssen dementsprechend weitere Kommas und Zahlen bei der Deklaration, Initialisierung und Indexierung angegeben werden. Meistens werden Arrays mit mehr als 3 Dimensionen nicht eingesetzt, da diese sehr unübersichtlich sind.
In C# gibt es noch einen weiteren Array-Typ: verzweigte Arrays. Ein verzweigtes Array ähnelt einem zweidimensionalen Array. Jedoch gibt es einen entscheidenden Unterschied: Die Anzahl der Elemente der 2. Ebene müssen nicht gleich groß sein. Dies kommt daher, dass ein verzweigtes Array nicht mehrere Dimensionen hat, sondern verschaltet ist, d. h. das Array besteht z. B. aus 10 untergeordneten Arrays. Die Anzahl der Elemente dieser 10 ungeordneten Arrays interessiert das ursprüngliche Array daher nicht. Bei der Deklaration werden 2 eckige Klammern-Paare nacheinander notiert. Bei der Initialisierung wird in den eckigen Klammern der 2. Ebene keine Anzahl festgelegt. Dies ist notwendig, da wir bei der Wertezuweisung (im Beispiel durch die Schleifen) den Arrays der 2. Ebene unterschiedliche Größen zuweisen. Bei der Indexierung müssen wir ebenfalls die 2 Klammern-Paare nacheinander notieren.
Nun wollen wir noch eine weitere Schleife kennenlernen: die foreach-Schleife. Die foreach-Schleife wird eingesetzt, wenn wir auf die Elemente eines Arrays zugreifen wollen. Die foreach-Schleife kennzeichnet sich durch das Schlüsselwort foreach, gefolgt von runden Klammern. In den runden Klammern deklarieren wir nun eine Variable (ohne Semikolon). Dahinter folgt das Schlüsselwort in und dann der Name des Arrays. Über die „temporäre“ Variable, welche in der Schleife deklariert wurde, können wir nun den Wert abrufen. Eine Wertzuweisung ist mit der foreach-Schleife nicht möglich. Die foreach-Schleife kann auch dazu verwendet werden, ein verzweigtes Array „durchzugehen“ (siehe Beispiel).

Program.cs

int[] aZahlenreihe = new int[10];
int[,] aZahlenreihe2Dimensionen = new int[3, 9];        // dieses Array ist zweidimensional (3 Spalten, 9 Zeilen)
int[][] aZahlenreiheVerzweigt = new int[10][];          // dieses Array ist "verzweigt"

for (int i = 0; i < aZahlenreihe.Length; i++)
{
	// cast (Typumwandlung) notwendig, da Math.Pow() standardmäßig mit Kommazahlen (double) arbeitet
	aZahlenreihe[i] = (int)Math.Pow(i, 2);
}

// Variable i wird neu deklariert (1. Deklaration in 1. Schleife oben)
//  --> dies ist nur möglich, da i nur innerhalb der Schleife verfügbar ist
for (int i = 0; i < aZahlenreihe.Length; i++)
	Console.WriteLine(i + "² = " + aZahlenreihe[i]);

Console.WriteLine();

// Index des angegebenen Wertes ausgeben
Console.WriteLine(Array.IndexOf(aZahlenreihe, 9));
Console.WriteLine(Array.LastIndexOf(aZahlenreihe, 9));      // gibt das Gleiche wie IndexOf() auf, da 9 nur einmal im Array vorhanden ist

Console.WriteLine();

// Array umkehren
Array.Reverse(aZahlenreihe);

// Zahlen erneut ausgeben
for (int i = 0; i < aZahlenreihe.Length; i++)
	Console.WriteLine("index " + i + ": " + aZahlenreihe[i]);

Console.WriteLine();

// Werte des zweidimensionalen Arrray füllen
for (int i = 0; i < aZahlenreihe2Dimensionen.GetLength(0); i++)
	for (int j = 0; j < aZahlenreihe2Dimensionen.GetLength(1); j++)
		aZahlenreihe2Dimensionen[i, j] = (i * 10) + j;

// Werte des zweidimensionalen Array ausgeben
for (int i = 0; i < aZahlenreihe2Dimensionen.GetLength(0); i++)
	for (int j = 0; j < aZahlenreihe2Dimensionen.GetLength(1); j++)
		Console.WriteLine("array[{0},{1}] = {2}", i, j, aZahlenreihe2Dimensionen[i, j]);

Console.WriteLine();

// Werte des verzweigten Arrays füllen
for (int i = 0; i < aZahlenreiheVerzweigt.Length; i++)
{
	aZahlenreiheVerzweigt[i] = new int[i * 2];  // die Länge der untergeordneten Array kann sich unterscheiden
	for (int j = 0; j < aZahlenreiheVerzweigt[i].Length; j++)
		aZahlenreiheVerzweigt[i][j] = (i * 10) + j;
}

// Werte des verzweigten Arrays ausgeben (mit foreach)
foreach (int[] aZahlen in aZahlenreiheVerzweigt)
{
	foreach (int iZahl in aZahlen)
		Console.Write(iZahl + " ");
	Console.WriteLine();
}

Console.ReadKey();