In C# gibt es verschiedene Arten von Arrays. Hier eine umfassende Übersicht, inklusive einer neuen Betrachtung von verzweigten Arrays (oder auch "Zickzack-Arrays" genannt) und implizit typisierten Arrays.
Einfaches Array (Single-Dimensional Array)¶
Ein eindimensionales Array ist das grundlegendste Array. Es speichert eine Liste von Elementen des gleichen Datentyps in einer einzigen Dimension.
Deklaration und Initialisierung:
int[] zahlen = new int[5]; // Ein Array mit 5 Integer-Elementen
zahlen[0] = 1;
zahlen[1] = 2;
// Direkte Initialisierung
int[] zahlenDirekt = { 1, 2, 3, 4, 5 };
Console.WriteLine(zahlenDirekt);
Console.WriteLine(zahlenDirekt[3]);
System.Int32[] 4
Mehrdimensionales Array (Multi-Dimensional Array)¶
Mehrdimensionale Arrays speichern Daten in mehreren Reihen und Spalten.
Deklaration und Initialisierung:
int[,] matrix = new int[2, 3]; // Ein 2x3 Array (2 Zeilen, 3 Spalten)
matrix[0, 0] = 1;
// Direkte Initialisierung
int[,] matrixDirekt = { { 1, 2, 3 }, { 4, 5, 6 } };
Console.WriteLine(matrixDirekt);
Console.WriteLine(matrixDirekt[1,1]);
System.Int32[,] 5
Verzweigtes Array (Jagged Array)¶
Ein verzweigtes Array ist ein Array von Arrays, in dem jedes Unterarray unterschiedliche Längen haben kann.
Deklaration und Initialisierung:
int[][] verzweigt = new int[3][]; // Ein Array mit 3 "Reihen"
verzweigt[0] = new int[2]; // Erste Reihe hat 2 Elemente
verzweigt[1] = new int[3]; // Zweite Reihe hat 3 Elemente
verzweigt[2] = new int[1]; // Dritte Reihe hat 1 Element
// Direkte Initialisierung
int[][] verzweigtDirekt =
{
new int[] { 1, 2 },
new int[] { 3, 4, 5 },
new int[] { 6 }
};
Console.WriteLine(verzweigtDirekt);
Console.WriteLine(verzweigtDirekt[1]);
Console.WriteLine(verzweigtDirekt[1][1])
System.Int32[][] System.Int32[] 4
Implizit typisiertes Array¶
In C# können Arrays auch implizit typisiert werden, was bedeutet, dass der Typ des Arrays vom Compiler basierend auf den zugewiesenen Werten abgeleitet wird. Dies erfolgt mit dem var-Schlüsselwort.
Beispiel:
var zahlen = new[] { 1, 2, 3, 4, 5 }; // Compiler leitet ab, dass dies ein int[] ist
var namen = new[] { "Alice", "Bob", "Charlie" }; // Compiler erkennt string[]
Console.WriteLine(zahlen);
Console.WriteLine(namen);
Console.WriteLine(zahlen[1]);
Console.WriteLine(namen[1]);
System.Int32[] System.String[] 2 Bob
In implizit typisierten Arrays müssen alle Elemente denselben Typ haben, damit der Compiler den Typ korrekt ableiten kann. Gemischte Datentypen sind nicht erlaubt.
Vorteil von implizit typisierten Arrays:
- Erhöhte Lesbarkeit und Vereinfachung des Codes, da der Typ nicht explizit angegeben werden muss.
- Besonders nützlich in Situationen, in denen der Typ offensichtlich ist oder aus dem Kontext klar wird.
Wichtige Methoden für Arrays¶
C# bietet einige nützliche Methoden, um Arrays zu manipulieren:
Array.Sort(): Sortiert das Array.Array.Reverse(): Kehrt die Reihenfolge der Elemente um.Array.Find(): Findet ein bestimmtes Element im Array.
Beispiel:
int[] zahlen = { 5, 3, 8, 1, 2 };
Array.Sort(zahlen); // Sortiert das Array
Array.Reverse(zahlen); // Kehrt die Reihenfolge um
int gefunden = Array.Find(zahlen, x => x == 3); // Findet die Zahl
Console.WriteLine(zahlen[0]);
8
Kopieren von Arrays in C#¶
Es gibt mehrere Möglichkeiten, Arrays in C# zu kopieren. Der einfachste Ansatz ist die Verwendung der Methode Array.Copy(), oder für vollständige Kopien die Methode Clone(). Hier sind einige gängige Techniken:
1. Verwenden von Array.Copy()¶
Mit Array.Copy() kann eine bestimmte Anzahl von Elementen von einem Array in ein anderes kopiert werden.
Beispiel:
int[] originalArray = { 1, 2, 3, 4, 5 };
int[] zielArray = new int[5];
Array.Copy(originalArray, zielArray, originalArray.Length); // Kopiert alle
Console.WriteLine(zielArray[1]);
2
2. Verwenden von Clone()¶
Die Methode Clone() erstellt eine flache Kopie des Arrays. Dies bedeutet, dass bei einem Array von einfachen Typen (wie int, char usw.) eine vollständige Kopie erstellt wird, während bei komplexen Objekten nur die Referenzen kopiert werden.
Beispiel:
int[] originalArray = { 1, 2, 3, 4, 5 };
int[] kopiertesArray = (int[])originalArray.Clone(); // Erstellt eine Kopie des Arrays
originalArray[1] = 22;
Console.WriteLine(kopiertesArray[1]);
class Person
{
public string Name { get; set; }
}
Person[] originalRefArray = { new Person { Name = "Alice" }, new Person { Name = "Bob" } };
Person[] kopiertesRefArray = (Person[])originalRefArray.Clone(); // Flache Kopie des Arrays
// Initialer Wert
Console.WriteLine("Original Array: " + originalRefArray[0].Name);
// Änderung im originalen Array
originalRefArray[0].Name = "Charlie";
// Ausgabe, um die Veränderung zu überprüfen
Console.WriteLine("Kopiertes Array: " + kopiertesRefArray[0].Name);
2 Original Array: Alice Kopiertes Array: Charlie
Beide Arrays zeigen jeweils auf dieselben Objekte, die jeweils die Daten enthalten, indem die Elemente in den Arrays nur auf die Objekte referenzieren. Ändert man die Daten im Objekt, so sind die neuen Daten auch nach Clone in dem anderen Array sichbar.
graph TD
subgraph Original Array
A1[Person 1: Alice]
A2[Person 2: Bob]
end
subgraph Kopiertes Array
B1[Person 1: Alice]
B2[Person 2: Bob]
end
subgraph Objekte
A1 & B1 -- Referenz --> O1[(Objekt Alice)]
A2 & B2 -- Referenz --> O2[(Objekt Bob)]
end
3. Kopieren mit Array.ConstrainedCopy()¶
Diese Methode ist ähnlich wie Array.Copy(), bietet jedoch zusätzliche Sicherheitsprüfungen und wird in speziellen Szenarien verwendet, in denen die Integrität des Kopiervorgangs garantiert werden muss.
Beispiel:
int[] originalArray = { 1, 2, 3, 4, 5 };
int[] zielArray = new int[5];
Array.ConstrainedCopy(originalArray, 0, zielArray, 0, originalArray.Length); // Sichere Kopie
Console.WriteLine(zielArray[1]);
2