C# Tableau dynamique (ArrayList)
ArrayList est une classe de tableau dynamique fournie en C#, située dans l'espace de noms System.Collections.
Les tableaux dynamiques (ArrayList) diffèrent des tableaux ordinaires en ce que leur taille peut être ajustée dynamiquement sans qu'il soit nécessaire de définir une longueur fixe à l'avance.
Le tableau dynamique (ArrayList) représente une collection ordonnée d'objets pouvant être indexés individuellement, et il permet également l'allocation dynamique de mémoire, l'ajout, la recherche et le tri d'éléments dans la liste.
ArrayListLa classe convient aux opérations sur les tableaux qui nécessitent des redimensionnements fréquents, mais en raison de sa nature non générique, elle est progressivement [remplacée par List<T>] dans le développement C# moderne.List<T>remplacement.
Structure de base
public class ArrayList : ICollection, IEnumerable, IList, ICloneable
Implémenter l'interface :
- Implémenter l'interface:
IList: Prend en charge l'accès aux éléments par index.ICollection: Prend en charge les opérations de collection de base, telles que l'ajout, la suppression et le comptage.IEnumerable: Prend en charge l'itération sur les éléments via un énumérateur.ICloneable: Prend en charge le clonageArrayList。
Fonctionnalités
Extension dynamique:
ArrayListSa capacité peut être automatiquement ajustée selon les besoins, sans qu'il soit nécessaire de spécifier une taille fixe.- Lorsque le nombre d'éléments ajoutés dépasse la capacité actuelle,
ArrayListIl augmente automatiquement la capacité (généralement en doublant la capacité d'origine).
Collections non génériques:
ArrayListIl s'agit d'une collection non générique, et tous les éléments sont stockés sous forme deobjecttype. Cela signifie qu'il peut stocker des objets de n'importe quel type, mais il faut faire attention à l'impact sur les performances du boxing et de l'unboxing.
Fonctionnement non ordonné:
- Bien que l'ordre de stockage des éléments soit le même que l'ordre d'ajout, il ne fournit pas de fonctionnalité de tri intégrée.
Sécurité des threads:
- Il n'est pas thread-safe par défaut. Si une [implémentation thread-safe est nécessaire],
ArrayList, on peut utiliserArrayList.SynchronizedLa méthode crée une version thread-safe.
Méthodes et propriétés de la classe ArrayList
Le tableau ci-dessous répertorieArrayListQuelques utilisations courantes de la classePropriété:
| Nom de l'attribut | Type | Description |
|---|---|---|
Count | int | ObtientArrayListLe nombre d'éléments contenus. |
Capacity | int | Obtient ou définitArrayListLa capacité (espace de stockage). |
IsFixedSize | bool | IndiqueArrayListS'il a une taille fixe. |
IsReadOnly | bool | IndiqueArrayListS'il est en lecture seule. |
IsSynchronized | bool | IndiqueArrayListS'il est thread-safe. |
SyncRoot | object | Obtient un objet qui peut être utilisé pour un accès synchronisé. |
Le tableau ci-dessous répertorieArrayListQuelques utilisations courantes de la classeMéthodes:
| Nom de la méthode | Type de retour | Description |
|---|---|---|
| Ajout et insertion | ||
Add(object value) | int | Ajoute l'objet àArrayListÀ la fin, retourne l'index du nouvel élément. |
AddRange(ICollection c) | void | Ajoute tous les éléments de la collection spécifiée àArrayListla fin. |
Insert(int index, object value) | void | Insère un objet à l'index spécifié. |
InsertRange(int index, ICollection c) | void | Insère tous les éléments de la collection spécifiée à l'index spécifié. |
| Delete | ||
Remove(object value) | void | Supprime la première occurrence de l'objet spécifié. |
RemoveAt(int index) | void | Supprime l'élément à l'index spécifié. |
RemoveRange(int index, int count) | void | Supprime un nombre spécifié d'éléments à partir de l'index spécifié. |
Clear() | void | Supprime tous les éléments. |
| Accès et interrogation | ||
Contains(object item) | bool | Prise de décisionArrayListIndique si l'objet spécifié est contenu. |
IndexOf(object value) | int | Obtient l'index de la première occurrence de l'objet spécifié. |
LastIndexOf(object value) | int | Obtient l'index de la dernière occurrence de l'objet spécifié. |
| Tri et copie | ||
Sort() | void | Trie dans l'ordre par défaut.ArrayListLes éléments qu'il contient. |
Sort(IComparer comparer) | void | Trie selon un comparateur personnalisé. |
Reverse() | void | ReverseArrayListL'ordre des éléments dans |
CopyTo(Array array) | void | vaArrayListCopie les éléments dans le tableau spécifié. |
| Autre | ||
GetRange(int index, int count) | ArrayList | Obtient un sous-ensemble d'un nombre spécifié d'éléments à partir de l'index spécifié. |
ToArray() | object[] | vaArrayListCopier les éléments dans le tableau. |
TrimToSize() | void | Ajuste la capacité au nombre réel d'éléments pour économiser de la mémoire. |
Exemple
L'exemple suivant illustre le concept de tableaux dynamiques (ArrayList) :
Exemple
using System.Collections;
namespace CollectionApplication
{
class Program
{
static void Main(string[] args)
{
// Créer un tableau dynamique et l'initialiser
ArrayList numbers = InitializeArrayList();
// Afficher la capacité du tableau et le nombre d'éléments
DisplayArrayListInfo(numbers);
// Afficher le contenu du tableau
Console.Write("Contenu original : ");
DisplayArrayListContent(numbers);
// Trier le contenu du tableau
numbers.Sort();
// Afficher le contenu trié
Console.Write("Contenu trié : ");
DisplayArrayListContent(numbers);
Console.ReadKey(); // Attendre que l'utilisateur appuie sur une touche pour quitter
}
/// <summary>
/// Initialiser et remplir l'ArrayList
/// </summary>
/// <returns>Un ArrayList contenant les données initiales</returns>
static ArrayList InitializeArrayList()
{
ArrayList al = new ArrayList();
Console.WriteLine("Ajout de nombres à l'ArrayList :");
// Ajouter les éléments initiaux
int[] initialNumbers = { 45, 78, 33, 56, 12, 23, 9 };
foreach (int num in initialNumbers)
{
al.Add(num);
Console.WriteLine($"Ajouté : {num}");
}
return al;
}
/// <summary>
/// Affiche la capacité et le nombre d'éléments d'ArrayList
/// </summary>
/// <param name="al">objet ArrayList</param>
static void DisplayArrayListInfo(ArrayList al)
{
Console.WriteLine($"\nCapacité : {al.Capacity}"); // capacité actuelle
Console.WriteLine($"Nombre : {al.Count}"); // Nombre d'éléments actuel
}
/// <summary>
/// Affiche le contenu de ArrayList
/// </summary>
/// <param name="al">objet ArrayList</param>
static void DisplayArrayListContent(ArrayList al)
{
foreach (int num in al)
{
Console.Write(num + " ");
}
Console.WriteLine(); // nouvelle ligne
}
}
}
Lorsque le code ci-dessus est compilé et exécuté, il produit les résultats suivants :
Adding numbers to the ArrayList: Added: 45 Added: 78 Added: 33 Added: 56 Added: 12 Added: 23 Added: 9 Capacity: 16 Count: 7 Original Content: 45 78 33 56 12 23 9 Sorted Content: 9 12 23 33 45 56 78
et collections génériquesList<T>comparaison
| Fonctionnalités | ArrayList | List<T> |
|---|---|---|
| Sûreté de typage | Non (stockageobjecttype) | Oui (générique, contrainte fortement typée) |
| Boxing et unboxing | Oui (nécessaire pour les types valeur) | non |
| Performance | Relativement faible | Plus élevé |
| Prise en charge des génériques | Aucune | Oui |
| Cas d'utilisation | Code hérité ou scénarios simples | Privilégié dans le développement moderne |
Notes
Évitez le boxing et l'unboxing fréquents:
- Si les données sont principalement constituées de types valeur, il est recommandé d'utiliser [List<T>]
List<T>afin d'éviter une surcharge de performance.
Utilisez des données de types mixtes avec prudence.:
- Essayez de ne pas mélanger et stocker des objets de types différents, afin de réduire le risque d'erreurs d'exécution.
Solution alternative:
- Dans le développement C# moderne, il est recommandé d'utiliser des collections génériques (telles que
List<T>、Dictionary<TKey, TValue>) pour améliorer la sécurité et l'efficacité du code.