C# Array-Klasse

C# Arrays

Die Array-Klasse ist die Basisklasse für alle Arrays in C# und ist im System-Namespace definiert. Die Array-Klasse bietet verschiedene Eigenschaften und Methoden für Arrays.

In C# ist die Array-Klasse die Basisklasse für alle Arrays und befindet sich unter dem System-Namespace.

Ein Array ist eine Sammlung, die verwendet wird, um eine feste Anzahl von Elementen desselben Typs zu speichern. Das Verständnis der Merkmale und Methoden der Array-Klasse ist sehr wichtig für das Schreiben effizienter C#-Programme.

Das Folgende ist eine ausführliche Einführung in die C#-Array-Klasse, einschließlich ihrer Merkmale, häufig verwendeten Methoden, Eigenschaften und Anwendungsbeispiele.

Funktionen

• Typsicherheit: Arrays können nur Elemente eines angegebenen Typs speichern, und der Typ wird bei der Deklaration festgelegt.
• Feste Länge: Die Länge eines Arrays kann nach seiner Erstellung nicht geändert werden.
• Indexzugriff: Auf Elemente in einem Array wird über den Index zugegriffen, und der Index beginnt bei 0.
• Mehrdimensionale Unterstützung: C# unterstützt eindimensionale, mehrdimensionale und gezackte Arrays (Arrays von Arrays).

Eigenschaften der Array-Klasse

Die folgende Tabelle listet einige der am häufigsten verwendeten Eigenschaften in der Array-Klasse auf:

Eine vollständige Liste der Eigenschaften der Array-Klasse finden Sie in der Microsoft C#-Dokumentation.

Methoden der Array-Klasse

Die folgende Tabelle listet einige der am häufigsten verwendeten Methoden in der Array-Klasse auf:

Weitere Hinweise zur Methodenreferenz

1. AsReadOnly<T>(T[])

   • Gibt einen schreibgeschützten Wrapper für das angegebene Array zurück.

2. BinarySearch

   • BinarySearch(Array, Int32, Int32, Object, IComparer): Sucht nach einem Wert in einem sortierten Array unter Verwendung der angegebenenIComparerSchnittstelle.
   • BinarySearch(Array, Int32, Int32, Object): Sucht nach einem Wert in einem sortierten Array unter VerwendungIComparableSchnittstelle.
   • BinarySearch(Array, Object, IComparer): Durchsucht ein sortiertes Array unter Verwendung der angegebenenIComparerSchnittstelle.
   • BinarySearch(Array, Object): Durchsucht ein sortiertes Array unter VerwendungIComparableSchnittstelle.
   • BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>): Sucht nach einem Wert in einem generischen Arraybereich unter Verwendung der angegebenenIComparer<T>Schnittstelle.
   • BinarySearch<T>(T[], Int32, Int32, T): Sucht nach einem Wert innerhalb eines generischen Arraybereichs unter VerwendungIComparable<T>Schnittstelle.
   • BinarySearch<T>(T[], T, IComparer<T>): Durchsucht ein sortiertes generisches Array unter Verwendung der angegebenenIComparer<T>Schnittstelle.
   • BinarySearch<T>(T[], T): Durchsucht ein sortiertes generisches Array unter VerwendungIComparable<T>Schnittstelle.

3. Klar

   • Clear(Array, Int32, Int32): Legt die Elemente im angegebenen Bereich eines Arrays auf ihre Standardwerte fest.
   • Clear(Array): Leert den Inhalt des Arrays.

4. Clone

   • Erstellt eine flache Kopie des Arrays.

5. ConstrainedCopy

   • Kopiert einen angegebenen Bereich von Elementen vom Quellarray in das Zielarray und stellt sicher, dass Änderungen erst vorgenommen werden, nachdem der gesamte Kopiervorgang erfolgreich abgeschlossen wurde.

6. ConvertAll<TInput, TOutput>(TInput[], Converter<TInput, TOutput>)

   • Konvertiert ein Array eines Typs in ein Array eines anderen Typs.

7. Copy

   • Copy(Array, Array, Int32): Kopiert die Arrayelemente in das Zielarray, wobei die Länge durch eine 32-Bit-Ganzzahl angegeben wird.
   • Copy(Array, Array, Int64): Kopiert die Arrayelemente in das Zielarray, wobei die Länge durch eine 64-Bit-Ganzzahl angegeben wird.
   • Copy(Array, Int32, Array, Int32, Int32): Kopiert einen angegebenen Bereich von Elementen vom Quellarray in das Zielarray.
   • Copy(Array, Int64, Array, Int64, Int64): Kopiert einen angegebenen Bereich von Elementen vom Quellarray in das Zielarray.
   • CopyTo(Array, Int32): Kopiert das aktuelle Array in das Zielarray und gibt die Indexposition im Zielarray an, an der begonnen werden soll.
   • CopyTo(Array, Int64): Wie oben, wobei der Index als 64-Bit-Ganzzahl angegeben wird.

8. CreateInstance

   • CreateInstance(Type, Int32): Erstellt ein eindimensionales Array des angegebenen Typs und der angegebenen Länge.
   • CreateInstance(Type, Int32, Int32): Erstellt ein zweidimensionales Array.
   • CreateInstance(Type, Int32, Int32, Int32): Erstellt ein dreidimensionales Array.
   • CreateInstance(Type, Int32[]): Erstellt ein mehrdimensionales Array unter Verwendung der angegebenen Dimensionen.
   • CreateInstance(Type, Int64[]): Erstellt ein mehrdimensionales Array unter Verwendung von 64-Bit-Ganzzahl-Dimensionen.

9. Empty<T>

   • Gibt eine leere Array-Instanz zurück.

10. Exists<T>(T[], Predicate<T>)

    • Bestimmt, ob ein Array Elemente enthält, die die angegebene Bedingung erfüllen.

11. Fill<T>(T[], T, Int32, Int32)

    • Füllt alle Elemente in einem Array innerhalb des angegebenen Indexbereichs mit einem gegebenen Wert.
    • Fill<T>(T[], T): Füllt alle Elemente des gesamten Arrays mit einem gegebenen Wert.

12. Find

    • Find<T>(T[], Predicate<T>): Sucht das erste Element, das die Bedingungen erfüllt, und gibt es zurück.
    • FindAll<T>(T[], Predicate<T>): Gibt alle Elemente zurück, die die Bedingungen erfüllen.
    • FindIndex<T>(T[], Int32, Int32, Predicate<T>): Innerhalb des angegebenen Bereichs eines Arrays gibt es den Index des ersten Elements zurück, das die Bedingung erfüllt.
    • FindIndex<T>(T[], Int32, Predicate<T>): Nach dem angegebenen Index gibt es den Index des ersten Elements zurück, das die Bedingung erfüllt.
    • FindIndex<T>(T[], Predicate<T>): Gibt den Index des ersten Elements zurück, das die Bedingung erfüllt.
    • FindLast<T>(T[], Predicate<T>): Gibt das letzte Element zurück, das die Bedingung erfüllt.
    • FindLastIndex<T>(T[], Int32, Int32, Predicate<T>): Innerhalb des angegebenen Bereichs eines Arrays gibt es den Index des letzten Elements zurück, das die Bedingung erfüllt.
    • FindLastIndex<T>(T[], Predicate<T>): Gibt den Index des letzten Elements zurück, das die Bedingung erfüllt.

13. ForEach<T>(T[], Action<T>)

    • Führt die angegebene Operation für jedes Element des Arrays aus.

14. GetEnumerator()

    • Ruft den Enumerator des Arrays ab.

15. GetLength

    • GetLength(Int32): Ruft die Anzahl der Elemente in der angegebenen Dimension eines Arrays ab.

16. GetLongLength(Int32)

    • Ruft die Länge des Arrays als 64-Bit-Ganzzahl ab.

17. GetLowerBound(Int32)

    • Ruft den Index des ersten Elements in der angegebenen Dimension eines Arrays ab.

18. GetUpperBound(Int32)

    • Ruft den Index des letzten Elements in der angegebenen Dimension eines Arrays ab.

19. GetValue

    • GetValue(Int32): Ruft den Wert am angegebenen Index eines eindimensionalen Arrays ab.
    • GetValue(Int32, Int32): Ruft den Wert am angegebenen Index eines zweidimensionalen Arrays ab.
    • GetValue(Int32, Int32, Int32): Ruft den Wert am angegebenen Index eines dreidimensionalen Arrays ab.
    • GetValue(Int32[]): Ruft den Wert eines mehrdimensionalen Arrays ab.

20. IndexOf

    • IndexOf(Array, Object): Gibt den Index des ersten Vorkommens des angegebenen Objekts zurück.
    • IndexOf(Array, Object, Int32): Gibt den Index des ersten Vorkommens des angegebenen Objekts innerhalb eines bestimmten Bereichs im Array zurück.
    • IndexOf(Array, Object, Int32, Int32): Gibt den Index des ersten Vorkommens des angegebenen Objekts innerhalb des angegebenen Bereichs im Array zurück.

21. LastIndexOf

    • ähnlich wieIndexOf, sucht jedoch vom Ende des Arrays aus.

22. Resize<T>(T[], Int32)

    • Ändert die Größe eines eindimensionalen Arrays.

23. Reverse

    • Reverse(Array): Kehrt die Reihenfolge der Elemente im Array um.
    • Reverse<T>(T[]): Kehrt die Reihenfolge der Elemente in einem generischen Array um.

24. SetValue

    • SetValue(Object, Int32): Legt den Wert am angegebenen Index des Arrays fest.
    • SetValue(Object, Int32, Int32): Legt den Wert an der angegebenen Position eines zweidimensionalen Arrays fest.

25. Sort

    • Sort(Array): Sortiert das Array.
    • Sort<T>(T[], IComparer<T>): Sortiert ein generisches Array.

26. TrueForAll<T>(T[], Predicate<T>)

    • Bestimmt, ob alle Elemente in einem Array die Bedingung erfüllen.

Eine vollständige Liste der Methoden der Array-Klasse finden Sie in der Microsoft C#-Dokumentation.

Beispiel

Das folgende Programm veranschaulicht die Verwendung einiger Methoden der Array-Klasse:

Wenn der obige Code kompiliert und ausgeführt wird, liefert er die folgenden Ergebnisse:

原始数组： 34 72 13 44 25 30 10
逆转数组： 10 30 25 44 13 72 34
排序数组： 10 13 25 30 34 44 72

Beispiele für gängige Methoden

1. Array(Array, int index, int length)

将数组中指定范围的元素设置为其类型的默认值。

int[] arr = {1, 2, 3, 4, 5};
Array.Clear(arr, 1, 2); // arr = {1, 0, 0, 4, 5}

2. Array.Copy(Array sourceArray, Array destinationArray, int length)

将元素从源数组复制到目标数组。

int[] source = {1, 2, 3};
int[] destination = new int[3];
Array.Copy(source, destination, 3); // destination = {1, 2, 3}

3. Array.Clone()

Erstellt eine flache Kopie des Arrays.

int[] arr = {1, 2, 3};
int[] clonedArr = (int[])arr.Clone();

4. Array.IndexOf(Array array, object value)

返回指定元素在一维数组中第一次出现的索引。

int[] arr = {1, 2, 3, 2};
int index = Array.IndexOf(arr, 2); // index = 1

5. Array.LastIndexOf(Array array, object value)

返回指定元素在一维数组中最后一次出现的索引。

int[] arr = {1, 2, 3, 2};
int lastIndex = Array.LastIndexOf(arr, 2); // lastIndex = 3

6. Array.Reverse(Array array)

反转一维数组中元素的顺序。

int[] arr = {1, 2, 3};
Array.Reverse(arr); // arr = {3, 2, 1}

7. Array.Sort(Array array)

按升序对一维数组的元素进行排序。

int[] arr = {3, 1, 2};
Array.Sort(arr); // arr = {1, 2, 3}

8. Array.BinarySearch(Array array, object value)

Sucht nach einem Element in einem sortierten eindimensionalen Array und gibt dessen Index zurück.

int[] arr = {1, 2, 3, 4, 5};
int index = Array.BinarySearch(arr, 3); // index = 2

Hinweis:Vor der Verwendung von BinarySearch muss das Array bereits sortiert sein.

9. Array.Resize(ref T[] array, int newSize)

Ändert die Größe eines eindimensionalen Arrays.

int[] arr = {1, 2, 3};
Array.Resize(ref arr, 5); // arr = {1, 2, 3, 0, 0}

10. Array.Exists<T>(T[] array, Predicate match)

Bestimmt, ob es ein Element im Array gibt, das die Bedingung erfüllt.

int[] arr = {1, 2, 3};
bool exists = Array.Exists(arr, x => x == 2); // exists = true

11. Array.Find<T>(T[] array, Predicate match)

Findet das erste Element im Array, das die Bedingung erfüllt.

int[] arr = {1, 2, 3, 4};
int result = Array.Find(arr, x => x > 2); // result = 3

12. Array.FindAll<T>(T[] array, Predicate match)

Findet alle Elemente im Array, die die Bedingung erfüllen.

int[] arr = {1, 2, 3, 4};
int[] results = Array.FindAll(arr, x => x > 2); // results = {3, 4}

13. Array.FindIndex<T>(T[] array, Predicate match)

Gibt den Index des ersten Elements zurück, das die Bedingung erfüllt.

int[] arr = {1, 2, 3, 4};
int index = Array.FindIndex(arr, x => x > 2); // index = 2

14. Array.FindLast<T>(T[] array, Predicate match)

Findet das letzte Element, das die Bedingungen erfüllt.

int[] arr = {1, 2, 3, 4};
int result = Array.FindLast(arr, x => x > 2); // result = 4

15. Array.FindLastIndex<T>(T[] array, Predicate match)

Gibt den Index des letzten Elements zurück, das die Bedingung erfüllt.

int[] arr = {1, 2, 3, 4};
int index = Array.FindLastIndex(arr, x => x > 2); // index = 3

16. Array.TrueForAll<T>(T[] array, Predicate match)

Bestimmt, ob alle Elemente im Array die Bedingung erfüllen.

int[] arr = {1, 2, 3};
bool allPositive = Array.TrueForAll(arr, x => x > 0); // allPositive = true

17. Array.ForEach<T>(T[] array, Action action)

Führt die angegebene Operation für jedes Element des Arrays aus.

int[] arr = {1, 2, 3};
Array.ForEach(arr, x => Console.WriteLine(x)); // 输出 1 2 3

18. Array.ConstrainedCopy(Array sourceArray, int sourceIndex, Array destinationArray, int destinationIndex, int length)

int[] source = {1, 2, 3, 4, 5};
int[] destination = new int[5];
Array.ConstrainedCopy(source, 0, destination, 0, 5);

19. Array.Fill<T>(T[] array, T value)

Setzt alle Elemente des Arrays auf den angegebenen Wert.

int[] arr = new int[5];
Array.Fill(arr, 10); // arr = {10, 10, 10, 10, 10}

20. Array.AsReadOnly<T>(T[] array)

Gibt einen schreibgeschützten Wrapper für das Array zurück.

int[] arr = {1, 2, 3};
var readOnlyArr = Array.AsReadOnly(arr);
// readOnlyArr[0] = 5; // 编译错误，集合是只读的

C# Arrays