C# Classe Array

Tableaux C#

La classe Array est la classe de base de tous les tableaux en C#, définie dans l'espace de noms System. La classe Array fournit diverses propriétés et méthodes pour les tableaux.

En C#, la classe Array est la classe de base de tous les tableaux, située sous l'espace de noms System.

Un tableau est une collection utilisée pour stocker un nombre fixe d'éléments du même type. Comprendre les caractéristiques et les méthodes de la classe Array est très important pour écrire des programmes C# efficaces.

Ce qui suit est une introduction détaillée à la classe Array C#, y compris ses caractéristiques, ses méthodes couramment utilisées, ses propriétés et des exemples d'utilisation.

Fonctionnalités

• Sécurité de type: Les tableaux ne peuvent stocker que des éléments d'un type spécifié, et le type est déterminé au moment de la déclaration.
• Longueur fixe: La longueur d'un tableau ne peut pas être modifiée après sa création.
• Accès par index: Les éléments d'un tableau sont accessibles par index, et l'index commence à 0.
• Prise en charge multidimensionnelle: C# prend en charge les tableaux unidimensionnels, multidimensionnels et en escalier (tableaux de tableaux).

Propriétés de la classe Array

Le tableau suivant répertorie quelques-unes des propriétés les plus couramment utilisées de la classe Array :

Pour la liste complète des propriétés de la classe Array, veuillez vous référer à la documentation Microsoft C#.

Méthodes de la classe Array

Le tableau suivant répertorie certaines des méthodes les plus couramment utilisées dans la classe Array :

Autres notes de référence sur les méthodes

1. AsReadOnly<T>(T[])

   • Retourne un wrapper en lecture seule pour le tableau spécifié.

2. BinarySearch

   • BinarySearch(Array, Int32, Int32, Object, IComparer): Recherche une valeur dans un tableau trié, à l'aide duIComparerInterface.
   • BinarySearch(Array, Int32, Int32, Object): Recherche une valeur dans un tableau trié, à l'aide deIComparableInterface.
   • BinarySearch(Array, Object, IComparer): Recherche dans un tableau trié, à l'aide duIComparerInterface.
   • BinarySearch(Array, Object): Recherche dans un tableau trié, à l'aide deIComparableInterface.
   • BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>): Recherche une valeur dans une plage de tableau générique, à l'aide duIComparer<T>Interface.
   • BinarySearch<T>(T[], Int32, Int32, T): Recherche une valeur dans une plage de tableau générique, à l'aide deIComparable<T>Interface.
   • BinarySearch<T>(T[], T, IComparer<T>): Recherche dans un tableau générique trié, à l'aide duIComparer<T>Interface.
   • BinarySearch<T>(T[], T): Recherche dans un tableau générique trié, à l'aide deIComparable<T>Interface.

3. Clair

   • Clear(Array, Int32, Int32): Définit les éléments dans la plage spécifiée d'un tableau à leurs valeurs par défaut.
   • Clear(Array): Efface le contenu du tableau.

4. Clone

   • Crée une copie superficielle du tableau.

5. ConstrainedCopy

   • Copie une plage spécifiée d'éléments du tableau source vers le tableau de destination, en garantissant que les modifications ne sont effectuées qu'après la réussite complète de l'opération de copie.

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

   • Convertit un tableau d'un type en un tableau d'un autre type.

7. Copy

   • Copy(Array, Array, Int32): Copie les éléments du tableau vers le tableau de destination, avec la longueur spécifiée par un entier 32 bits.
   • Copy(Array, Array, Int64): Copie les éléments du tableau vers le tableau de destination, avec la longueur spécifiée par un entier 64 bits.
   • Copy(Array, Int32, Array, Int32, Int32): Copie une plage spécifiée d'éléments du tableau source vers le tableau de destination.
   • Copy(Array, Int64, Array, Int64, Int64): Copie une plage spécifiée d'éléments du tableau source vers le tableau de destination.
   • CopyTo(Array, Int32): Copie le tableau actuel vers le tableau de destination, en spécifiant la position d'index dans le tableau de destination à laquelle commencer.
   • CopyTo(Array, Int64): Identique à ci-dessus, avec l'index sous forme d'un entier 64 bits.

8. CreateInstance

   • CreateInstance(Type, Int32): Crée un tableau unidimensionnel du type et de la longueur spécifiés.
   • CreateInstance(Type, Int32, Int32): Crée un tableau à deux dimensions.
   • CreateInstance(Type, Int32, Int32, Int32): Crée un tableau à trois dimensions.
   • CreateInstance(Type, Int32[]): Crée un tableau multidimensionnel à l'aide des dimensions spécifiées.
   • CreateInstance(Type, Int64[]): Crée un tableau multidimensionnel à l'aide de dimensions d'entiers 64 bits.

9. Empty<T>

   • Retourne une instance de tableau vide.

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

    • Détermine si un tableau contient des éléments qui répondent à la condition spécifiée.

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

    • Remplit tous les éléments d'un tableau dans la plage d'indices spécifiée avec une valeur donnée.
    • Fill<T>(T[], T): Remplit tous les éléments du tableau entier avec une valeur donnée.

12. Find

    • Find<T>(T[], Predicate<T>): Recherche le premier élément qui correspond aux conditions et le renvoie.
    • FindAll<T>(T[], Predicate<T>): Renvoie tous les éléments qui correspondent aux conditions.
    • FindIndex<T>(T[], Int32, Int32, Predicate<T>): Dans la plage spécifiée d'un tableau, renvoie l'index du premier élément qui remplit la condition.
    • FindIndex<T>(T[], Int32, Predicate<T>): Après l'index spécifié, renvoie l'index du premier élément qui remplit la condition.
    • FindIndex<T>(T[], Predicate<T>): Renvoie l'index du premier élément qui remplit la condition.
    • FindLast<T>(T[], Predicate<T>): Renvoie le dernier élément qui remplit la condition.
    • FindLastIndex<T>(T[], Int32, Int32, Predicate<T>): Dans la plage spécifiée d'un tableau, renvoie l'index du dernier élément qui remplit la condition.
    • FindLastIndex<T>(T[], Predicate<T>): Renvoie l'index du dernier élément qui remplit la condition.

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

    • Effectue l'opération spécifiée sur chaque élément du tableau.

14. GetEnumerator()

    • Obtient l'énumérateur du tableau.

15. GetLength

    • GetLength(Int32): Obtient le nombre d'éléments dans la dimension spécifiée d'un tableau.

16. GetLongLength(Int32)

    • Obtient la longueur du tableau sous forme d'un entier 64 bits.

17. GetLowerBound(Int32)

    • Obtient l'index du premier élément dans la dimension spécifiée d'un tableau.

18. GetUpperBound(Int32)

    • Obtient l'index du dernier élément dans la dimension spécifiée d'un tableau.

19. GetValue

    • GetValue(Int32): Obtient la valeur à l'index spécifié d'un tableau unidimensionnel.
    • GetValue(Int32, Int32): Obtient la valeur à l'index spécifié d'un tableau bidimensionnel.
    • GetValue(Int32, Int32, Int32): Obtient la valeur à l'index spécifié d'un tableau tridimensionnel.
    • GetValue(Int32[]): Obtient la valeur d'un tableau multidimensionnel.

20. IndexOf

    • IndexOf(Array, Object): Retourne l'index de la première occurrence de l'objet spécifié.
    • IndexOf(Array, Object, Int32): Retourne l'index de la première occurrence de l'objet spécifié dans une plage spécifique du tableau.
    • IndexOf(Array, Object, Int32, Int32): Retourne l'index de la première occurrence de l'objet spécifié dans la plage spécifiée du tableau.

21. LastIndexOf

    • similaire àIndexOf, mais effectue la recherche à partir de la fin du tableau.

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

    • Modifie la taille d'un tableau unidimensionnel.

23. Reverse

    • Reverse(Array): Inverse l'ordre des éléments dans le tableau.
    • Reverse<T>(T[]): Inverse l'ordre des éléments dans un tableau générique.

24. SetValue

    • SetValue(Object, Int32): Définit la valeur à l'indice spécifié du tableau.
    • SetValue(Object, Int32, Int32): Définit la valeur à la position spécifiée d'un tableau à deux dimensions.

25. Sort

    • Sort(Array): Trie le tableau.
    • Sort<T>(T[], IComparer<T>): Trie un tableau générique.

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

    • Détermine si tous les éléments d'un tableau satisfont la condition.

Pour la liste complète des méthodes de la classe Array, veuillez consulter la documentation Microsoft C#.

Exemple

Le programme suivant illustre l'utilisation de certaines méthodes de la classe Array :

Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :

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

Exemples de méthodes courantes

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

Définit une plage spécifiée d'éléments dans un tableau à la valeur par défaut de leur type.

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)

Copie les éléments du tableau source vers le tableau de destination.

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

3. Array.Clone()

Crée une copie superficielle du tableau.

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

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

Retourne l'index de la première occurrence de l'élément spécifié dans un tableau unidimensionnel.

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

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

Retourne l'index de la dernière occurrence de l'élément spécifié dans un tableau unidimensionnel.

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

6. Array.Reverse(Array array)

Inverse l'ordre des éléments dans un tableau unidimensionnel.

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

7. Array.Sort(Array array)

Trie les éléments d'un tableau unidimensionnel par ordre croissant.

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

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

Recherche un élément dans un tableau unidimensionnel trié et renvoie son index.

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

Remarque :Avant d'utiliser BinarySearch, le tableau doit déjà être trié.

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

Redimensionne un tableau unidimensionnel.

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

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

Détermine si un élément du tableau remplit la condition.

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

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

Recherche le premier élément du tableau qui remplit la condition.

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

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

Trouve tous les éléments du tableau qui remplissent la condition.

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)

Retourne l'index du premier élément qui remplit la condition.

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

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

Trouve le dernier élément qui correspond aux conditions.

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

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

Retourne l'index du dernier élément qui remplit la condition.

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

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

Détermine si tous les éléments du tableau satisfont à la condition.

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

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

Effectue l'opération spécifiée sur chaque élément du tableau.

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)

Définit tous les éléments du tableau sur la valeur spécifiée.

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

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

Retourne un wrapper en lecture seule pour le tableau.

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

Tableaux C#