In C# dienen Arrays als Container zum Speichern von Elementen desselben Datentyps. Beim Erstellen eines Arrays gibt es mehrere Ansätze, es mit Elementen zu initialisieren. Dieser Artikel befasst sich mit den verschiedenen Methoden zur Initialisierung von Arrays in C# und bietet eine umfassende Untersuchung jedes Ansatzes.
Methoden zum Initialisieren von Arrays in C#
Arrays sind eine wesentliche Datenstruktur in der Computerprogrammierung, die es Ihnen ermöglicht, eine Sammlung von Elementen desselben Datentyps an zusammenhängenden Speicherorten zu speichern und zu bearbeiten. Hier sind einige Möglichkeiten, Arrays in C# zu initialisieren:
1: Arrays mit der Array-Initialisierer-Syntax initialisieren
Der einfachste Ansatz zum Initialisieren eines Arrays ist die Verwendung der Array-Initialisierersyntax, da dabei die Array-Elemente in geschweifte Klammern eingeschlossen und durch Kommas getrennt werden, zum Beispiel:
int [ ] Zahlen = { 1 , 2 , 3 , 4 , 5 } ;
In diesem Code wird ein ganzzahliges Array mit dem Namen „Zahlen“ erstellt und mit den Werten 1 bis 5 initialisiert. Ebenso können Sie dieselbe Syntax verwenden, um ein mehrdimensionales Array zu initialisieren.
int [ , ] myMultiDimensionalArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Hier ist ein Beispielcode, der die Initialisierungssyntax verwendet, um ein 1D- und 2D-Array in C# zu initialisieren:
Verwenden des Systems;
Klassenarray
{
statische Leere Main ( Zeichenfolge [ ] args )
{
// Initialisieren eines 1D-Arrays mithilfe der Initialisierungssyntax
int [ ] array1D = { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( „Werte in array1D:“ ) ;
für ( int i = 0 ; ich < array1D.Length; i++ ) {
Console.WriteLine ( array1D [ ich ] ) ;
}
// Initialisieren eines 2D-Arrays mithilfe der Initialisierungssyntax
int [ , ] array2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( „Werte in array2D:“ ) ;
für ( int i = 0 ; ich < array2D.GetLength ( 0 ) ; i++ ) {
für ( int j = 0 ; J < array2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( „({0}, {1}): {2}“ , i, j, array2D [ ich, j ] ) ;
}
}
}
}
In diesem Code verwenden wir die Initialisierungssyntax, um ein eindimensionales Ganzzahlarray namens array1D mit den Werten 1, 2, 3, 4 und 5 zu initialisieren.
Wir verwenden auch die Initialisierungssyntax, um ein zweidimensionales Ganzzahlarray namens array2D mit den Werten {1, 2}, {3, 4} und {5, 6} zu initialisieren.
Anschließend verwenden wir zusätzliche for-Schleifen, um jedes Element jedes Arrays zu durchlaufen und seinen Wert an die Konsole auszugeben.
2: Arrays mit dem neuen Schlüsselwort initialisieren
Eine weitere Methode zum Initialisieren eines Arrays ist die Verwendung von neu Stichwort. Dazu müssen Sie die Größe des Arrays in eckigen Klammern angeben, gefolgt vom neuen Schlüsselwort und dann dem Datentyp der Array-Elemente. Zum Beispiel:
int [ ] Zahlen = neue int [ 5 ] ;
Dieser Code erstellt ein ganzzahliges Array mit dem Namen „numbers“ der Größe 5 und initialisiert alle Elemente auf ihren Standardwert, der für ganzzahlige Arrays 0 ist.
Hier ist die Syntax zum Initialisieren eines mehrdimensionalen Arrays mit dem Schlüsselwort new in C#:
< Typ > [ , ] < arrayName > = neu < Typ > [ < Länge1 > , < Länge2 > , ... ] { { < Anfangswerte > } } ;
In dieser Syntax ist
Hier ist ein Beispiel für die Verwendung dieser Syntax zum Initialisieren eines zweidimensionalen Ganzzahl-Arrays:
int [ , ] myArray = new int [ 3 , 2 ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
In diesem Beispiel initialisieren wir mit dem Schlüsselwort new ein 2D-Integer-Array namens myArray mit 3 Zeilen und 2 Spalten. Wir stellen außerdem Anfangswerte für jedes Element des Arrays bereit, indem wir die Syntax mit doppelten geschweiften Klammern verwenden. Die Werte sind {1, 2}, {3, 4} und {5, 6} und entsprechen den Elementen in jeder Zeile.
Hier ist ein Beispiel dafür, wie Sie mit dem Schlüsselwort new sowohl ein eindimensionales als auch ein zweidimensionales Array in C# initialisieren, zusammen mit Code zum Ausdrucken der Werte in jedem Array:
Verwenden des Systems;Klassenarray
{
statische Leere Main ( Zeichenfolge [ ] args )
{
// Initialisierung von a 1 -dimensionales Array
int [ ] myArray1D = new int [ ] { 1 , 2 , 3 , 4 , 5 } ;
Console.WriteLine ( „Werte in myArray1D:“ ) ;
für ( int i = 0 ; ich < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ ich ] ) ;
}
// Initialisierung von a 2 -dimensionales Array
int [ , ] myArray2D = new int [ , ] { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
Console.WriteLine ( „Werte in myArray2D:“ ) ;
für ( int i = 0 ; ich < myArray2D.GetLength ( 0 ) ; i++ )
{
für ( int j = 0 ; J < myArray2D.GetLength ( 1 ) ; j++ )
{
Console.WriteLine ( „({0}, {1}): {2}“ , i, j, myArray2D [ ich, j ] ) ;
}
}
}
}
In diesem Code verwenden wir das Schlüsselwort new, um ein eindimensionales Ganzzahlarray mit dem Namen zu initialisieren myArray1D mit den Werten 1, 2, 3, 4 und 5 und einem zweidimensionalen ganzzahligen Array namens myArray2D mit den Werten {1, 2}, {3, 4} und {5, 6}.
Anschließend verwenden wir for-Schleifen, um jedes Element jedes Arrays zu durchlaufen und seinen Wert an die Konsole auszugeben. Beachten Sie, dass wir für das zweidimensionale Array verwenden GetLength() um die Anzahl der Zeilen und Spalten zu bestimmen und verschachtelte for-Schleifen zu verwenden, um jedes Element zu durchlaufen.
3: Arrays mithilfe von Schleifen initialisieren
Arrays können auch mithilfe von Schleifen initialisiert werden. Ein Ansatz besteht darin, eine for-Schleife zu verwenden, die es Ihnen ermöglicht, das Array zu durchlaufen und jedem Element Werte zuzuweisen.
int [ ] Zahlen = neue int [ 5 ] ;für ( int i = 0 ; ich < zahlen.Länge; i++ )
{
Zahlen [ ich ] = ich + 1 ;
}
Dieser Code erstellt ein Integer-Array mit dem Namen „Numbers“ und einer Größe von 5 und weist jedem Element einen Wert zu, der seinem Index plus 1 entspricht. Hier ist ein Beispiel für die Initialisierung eines zweidimensionalen Integer-Arrays in C# mithilfe von Schleifen:
für ( int i = 0 ; ich < 3 ; i++ )
{
für ( int j = 0 ; J < 2 ; j++ )
{
meinArray [ ich, j ] = i + j;
}
}
In diesem Beispiel verwenden wir verschachtelte for-Schleifen, um jedes Element eines aufgerufenen zweidimensionalen Ganzzahlarrays zu durchlaufen meinArray , das 3 Zeilen und 2 Spalten hat. Für jedes Element setzen wir seinen Wert mit dem Ausdruck i + j auf die Summe seiner Zeilen- und Spaltenindizes.
Hier ist ein Beispiel dafür, wie Schleifen verwendet werden, um sowohl ein eindimensionales als auch ein zweidimensionales Array in C# zu initialisieren, zusammen mit Code zum Ausdrucken der Werte in jedem Array:
Verwenden des Systems;Klassenarray
{
statische Leere Main ( Zeichenfolge [ ] args )
{
// Initialisierung von a 1 -dimensionales Array mit einer Schleife
int [ ] myArray1D = new int [ 5 ] ;
für ( int i = 0 ; ich < myArray1D.Length; i++ )
{
myArray1D [ ich ] = ich + 1 ;
}
Console.WriteLine ( „Werte in myArray1D:“ ) ;
für ( int i = 0 ; ich < myArray1D.Length; i++ )
{
Console.WriteLine ( myArray1D [ ich ] ) ;
}
// Initialisierung von a 2 -dimensionales Array mit verschachtelten Schleifen
int [ , ] myArray2D = new int [ 3 , 2 ] ;
für ( int i = 0 ; ich < 3 ; i++ )
{
für ( int j = 0 ; J < 2 ; j++ )
{
myArray2D [ ich, j ] = i + j;
}
}
Console.WriteLine ( „Werte in myArray2D:“ ) ;
für ( int i = 0 ; ich < 3 ; i++ )
{
für ( int j = 0 ; J < 2 ; j++ )
{
Console.WriteLine ( „({0}, {1}): {2}“ , i, j, myArray2D [ ich, j ] ) ;
}
}
}
}
In diesem Code verwenden wir eine for-Schleife, um ein eindimensionales Integer-Array namens „myArray1D“ mit den Werten 1, 2, 3, 4 und 5 zu initialisieren. Wir verwenden auch verschachtelte for-Schleifen, um ein zweidimensionales Integer-Array namens „myArray1D“ zu initialisieren myArray2D mit den Werten {0, 1}, {1, 2} und {2, 3} unter Verwendung des Ausdrucks i + j.
Verwenden Sie dann zusätzliche for-Schleifen, um jedes Element jedes Arrays zu durchlaufen und seinen Wert an die Konsole auszugeben.
4: Arrays mit Array.Copy() initialisieren
Ein alternativer Ansatz zum Initialisieren eines Arrays besteht in der Verwendung der Funktion Array.Copy(). Dabei wird ein Quellarray mit den gewünschten Elementen erstellt und anschließend in ein Zielarray kopiert. Zum Beispiel:
int [ ] Quelle = { 1 , 2 , 3 , 4 , 5 } ;int [ ] Ziel = neue int [ Quelle.Länge ] ;
Array.Copy ( Quelle , Ziel, Quelle.Länge ) ;
Dieser Code erstellt ein ganzzahliges Array mit dem Namen „Quelle“ mit den Werten 1 bis 5, erstellt ein neues ganzzahliges Array mit dem Namen „Ziel“ mit der gleichen Größe wie „Quelle“ und kopiert dann die Elemente von der Quelle in das Ziel.
Erlauben Sie mir, ein Beispiel vorzustellen, das die Verwendung von Array.Copy zum Initialisieren eines zweidimensionalen Integer-Arrays in C# demonstriert:
int [ , ] sourceArray = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;int [ , ] DestinationArray = new int [ 3 , 2 ] ;
Array.Copy ( sourceArray, destinationArray, sourceArray.Length ) ;
In diesem Beispiel haben wir ein zweidimensionales Ganzzahl-Array namens sourceArray mit 3 Zeilen und 2 Spalten. Wir benutzen Array.Copy() um den Inhalt von „sourceArray“ in ein neues zweidimensionales Integer-Array namens „destinationArray“ zu kopieren, das ebenfalls über 3 Zeilen und 2 Spalten verfügt.
Der Array.Copy() Methode dauert drei Argumente : Die Quellarray , Die Zielarray , und das Länge der zu kopierenden Daten. In diesem Fall kopieren wir den gesamten Inhalt von sourceArray hinein ZielArray , also gehen wir vorbei sourceArray.Length als drittes Argument.
Beachten Sie, dass Sie verwenden können Array.Copy() um Arrays mit beliebig vielen Dimensionen zu initialisieren, solange die Quell- und Zielarrays die gleiche Anzahl an Dimensionen und in jeder Dimension die gleiche Größe haben.
Denken Sie auch daran Array.Copy() führt eine flache Kopie des Quellarrays durch. Das heißt, wenn das Quellarray Referenztypen enthält, werden die Referenzen kopiert, die Objekte selbst jedoch nicht dupliziert.
Hier ist der vollständige Code, der verwendet wird Array.Copy() Funktion zum Initialisieren des Arrays in C#:
Verwenden des Systems;Klassenarray
{
statische Leere Main ( Zeichenfolge [ ] args )
{
// Initialisierung von a 1 -dimensionales Array mit Array.Copy
int [ ] sourceArray1D = { 1 , 2 , 3 , 4 , 5 } ;
int [ ] targetArray1D = new int [ 5 ] ;
Array.Copy ( QuellArray1D, ZielArray1D, QuellArray1D.Länge ) ;
Console.WriteLine ( „Werte in DestinationArray1D:“ ) ;
für ( int i = 0 ; ich < DestinationArray1D.Length; i++ ) {
Console.WriteLine ( ZielArray1D [ ich ] ) ;
}
// Initialisierung von a 2 -dimensionales Array mit Array.Copy
int [ , ] sourceArray2D = { { 1 , 2 } , { 3 , 4 } , { 5 , 6 } } ;
int [ , ] targetArray2D = new int [ 3 , 2 ] ;
Array.Copy ( sourceArray2D, targetArray2D, sourceArray2D.Length ) ;
Console.WriteLine ( „Werte in DestinationArray2D:“ ) ;
für ( int i = 0 ; ich < targetArray2D.GetLength ( 0 ) ; i++ ) {
für ( int j = 0 ; J < targetArray2D.GetLength ( 1 ) ; j++ ) {
Console.WriteLine ( „({0}, {1}): {2}“ , i, j, DestinationArray2D [ ich, j ] ) ;
}
}
}
}
In diesem Code verwenden wir Array.Copy() um ein eindimensionales ganzzahliges Array namens „destinationArray1D“ mit den Werten 1, 2, 3, 4 und 5 aus einem Quellarray namens „sourceArray1D“ zu initialisieren.
Wir verwenden auch Array.Copy() um ein zweidimensionales ganzzahliges Array namens „destinationArray2D“ mit den Werten {1, 2}, {3, 4} und {5, 6} aus einem Quellarray namens „sourceArray2D“ zu initialisieren.
Anschließend verwenden wir zusätzliche for-Schleifen, um jedes Element jedes Arrays zu durchlaufen und seinen Wert an die Konsole auszugeben.
Abschluss
In diesem Artikel haben wir verschiedene Möglichkeiten zur Initialisierung von Arrays in C# untersucht. Wir haben die Syntax des Array-Initialisierers, die Verwendung des Schlüsselworts new, die Initialisierung von Arrays mithilfe von Schleifen und die Verwendung der Methode Array.Copy() behandelt. Abhängig vom konkreten Anwendungsfall weist jede dieser Methoden ihre eigenen Vor- und Nachteile auf. Wenn Sie sich mit diesen verschiedenen Ansätzen vertraut machen, können Sie den für Ihre speziellen Anforderungen am besten geeigneten auswählen.