ArrayList Classe

Définition

Espace de noms:

System.Collections

Assembly:

System.Runtime.dll

Source:

ArrayList.cs

Implémente l’interface IList à l’aide d’un tableau dont la taille est augmentée de manière dynamique au besoin.

public ref class ArrayList : ICloneable, System::Collections::IList

public class ArrayList : ICloneable, System.Collections.IList

type ArrayList = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface ICloneable

Public Class ArrayList
Implements ICloneable, IList

Héritage

Object

ArrayList

Dérivé

System.Windows.Forms.DomainUpDown.DomainUpDownItemCollection

Implémente

ICollection IEnumerable IList ICloneable

Exemples

L’exemple suivant montre comment créer et initialiser un ArrayList et comment afficher ses valeurs.

using namespace System;
using namespace System::Collections;
void PrintValues( IEnumerable^ myList );
int main()
{
   
   // Creates and initializes a new ArrayList.
   ArrayList^ myAL = gcnew ArrayList;
   myAL->Add( "Hello" );
   myAL->Add( "World" );
   myAL->Add( "!" );
   
   // Displays the properties and values of the ArrayList.
   Console::WriteLine( "myAL" );
   Console::WriteLine( "    Count:    {0}", myAL->Count );
   Console::WriteLine( "    Capacity: {0}", myAL->Capacity );
   Console::Write( "    Values:" );
   PrintValues( myAL );
}

void PrintValues( IEnumerable^ myList )
{
   IEnumerator^ myEnum = myList->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Object^ obj = safe_cast<Object^>(myEnum->Current);
      Console::Write( "   {0}", obj );
   }

   Console::WriteLine();
}

/* 
This code produces output similar to the following:

myAL
    Count:    3
    Capacity: 4
    Values:   Hello   World   !

*/

using System;
using System.Collections;
public class SamplesArrayList  {

   public static void Main()  {

      // Creates and initializes a new ArrayList.
      ArrayList myAL = new ArrayList();
      myAL.Add("Hello");
      myAL.Add("World");
      myAL.Add("!");

      // Displays the properties and values of the ArrayList.
      Console.WriteLine( "myAL" );
      Console.WriteLine( "    Count:    {0}", myAL.Count );
      Console.WriteLine( "    Capacity: {0}", myAL.Capacity );
      Console.Write( "    Values:" );
      PrintValues( myAL );
   }

   public static void PrintValues( IEnumerable myList )  {
      foreach ( Object obj in myList )
         Console.Write( "   {0}", obj );
      Console.WriteLine();
   }
}


/*
This code produces output similar to the following:

myAL
    Count:    3
    Capacity: 4
    Values:   Hello   World   !

*/

Imports System.Collections

Public Class SamplesArrayList    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new ArrayList.
        Dim myAL As New ArrayList()
        myAL.Add("Hello")
        myAL.Add("World")
        myAL.Add("!")
        
        ' Displays the properties and values of the ArrayList.
        Console.WriteLine("myAL")
        Console.WriteLine("    Count:    {0}", myAL.Count)
        Console.WriteLine("    Capacity: {0}", myAL.Capacity)
        Console.Write("    Values:")
        PrintValues(myAL)
    End Sub

    Public Shared Sub PrintValues(myList As IEnumerable)
        Dim obj As [Object]
        For Each obj In  myList
            Console.Write("   {0}", obj)
        Next obj
        Console.WriteLine()
    End Sub

End Class


' This code produces output similar to the following:
' 
' myAL
'     Count:    3
'     Capacity: 4
'     Values:   Hello   World   !

Remarques

Important

Nous vous déconseillons d’utiliser la classe pour le ArrayList nouveau développement. Au lieu de cela, nous vous recommandons d’utiliser la classe générique List<T> . La ArrayList classe est conçue pour contenir des collections hétérogènes d’objets. Toutefois, il n’offre pas toujours les meilleures performances. Au lieu de cela, nous vous recommandons ce qui suit :

• Pour une collection hétérogène d’objets, utilisez le List<Object> type (en C#) ou List(Of Object) (en Visual Basic).
• Pour une collection homogène d’objets, utilisez la List<T> classe . Consultez Considérations relatives aux performances dans la List<T> rubrique de référence pour une présentation des performances relatives de ces classes. Pour obtenir des informations générales sur l’utilisation des types de collection génériques plutôt que des types de collection non génériques, consultez Collections non génériques sur GitHub.

Le ArrayList n’est pas garanti d’être trié. Vous devez trier le en ArrayList appelant sa Sort méthode avant d’effectuer des opérations (telles que BinarySearch) qui nécessitent le ArrayList tri. Pour gérer une collection qui est automatiquement triée à mesure que de nouveaux éléments sont ajoutés, vous pouvez utiliser la SortedSet<T> classe .

La capacité d’un ArrayList est le nombre d’éléments que peut ArrayList contenir. À mesure que des éléments sont ajoutés à un ArrayList, la capacité est automatiquement augmentée en fonction des besoins par le biais de la réaffectation. La capacité peut être réduite en appelant TrimToSize ou en définissant explicitement la Capacity propriété.

.NET Framework uniquement : Pour les objets très volumineuxArrayList, vous pouvez augmenter la capacité maximale à 2 milliards d’éléments sur un système 64 bits en définissant l’attribut enabledtrue de l’élément <gcAllowVeryLargeObjects> de configuration sur dans l’environnement d’exécution.

Les éléments de cette collection sont accessibles à l’aide d’un index entier. Les index de cette collection sont de base zéro.

La ArrayList collection accepte null comme valeur valide. Il autorise également les éléments en double.

L’utilisation de tableaux multidimensionnels en tant qu’éléments dans une ArrayList collection n’est pas prise en charge.

Constructeurs

ArrayList()	Initialise une nouvelle instance de la classe ArrayList qui est vide et possède la capacité initiale par défaut.
ArrayList(ICollection)	Initialise une nouvelle instance de la classe ArrayList qui contient des éléments copiés à partir de la collection spécifiée et qui possède la capacité initiale correspondant au nombre d'éléments copiés.
ArrayList(Int32)	Initialise une nouvelle instance de la classe ArrayList qui est vide et a la capacité initiale spécifiée.

Propriétés

Capacity	Obtient ou définit le nombre d'éléments que ArrayList peut contenir.
Count	Obtient le nombre d’éléments réellement contenus dans ArrayList.
IsFixedSize	Obtient une valeur indiquant si ArrayList est de taille fixe.
IsReadOnly	Obtient une valeur indiquant si ArrayList est en lecture seule.
IsSynchronized	Obtient une valeur indiquant si l’accès à ArrayList est synchronisé (thread-safe).
Item[Int32]	Obtient ou définit l'élément au niveau de l'index spécifié.
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès à ArrayList.

Méthodes

Adapter(IList)	Crée un wrapper ArrayList pour un IList spécifique.
Add(Object)	Ajoute un objet à la fin de la ArrayList.
AddRange(ICollection)	Ajoute les éléments de ICollection à la fin de ArrayList.
BinarySearch(Int32, Int32, Object, IComparer)	Recherche un élément utilisant le comparateur spécifié dans une plage d'éléments du ArrayList trié et retourne l'index de base zéro de l'élément.
BinarySearch(Object)	Recherche un élément utilisant le comparateur par défaut dans le ArrayList entièrement trié et retourne l'index de base zéro de l'élément.
BinarySearch(Object, IComparer)	Recherche un élément utilisant le comparateur spécifié dans le ArrayList entièrement trié et retourne l'index de base zéro de l'élément.
Clear()	Supprime tous les éléments de ArrayList.
Clone()	Crée une copie superficielle de ArrayList.
Contains(Object)	Détermine si le ArrayList contient un élément.
CopyTo(Array)	Copie l’ensemble de ArrayList dans un Array compatible unidimensionnel en commençant au début du tableau cible.
CopyTo(Array, Int32)	Copie l'ensemble de l'objet ArrayList vers un objet Array unidimensionnel compatible, en commençant à l'index spécifié du tableau cible.
CopyTo(Int32, Array, Int32, Int32)	Copie une plage d’éléments de ArrayList vers un Array unidimensionnel compatible, en commençant à l’index spécifié du tableau cible.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
FixedSize(ArrayList)	Retourne un wrapper ArrayList de taille fixe.
FixedSize(IList)	Retourne un wrapper IList de taille fixe.
GetEnumerator()	Retourne un énumérateur pour le ArrayList entier.
GetEnumerator(Int32, Int32)	Retourne un énumérateur pour une plage d’éléments d’ArrayList.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetRange(Int32, Int32)	Retourne un ArrayList qui représente un sous-ensemble des éléments du ArrayList source.
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
IndexOf(Object)	Recherche le Object spécifié et retourne l’index de base zéro de la première occurrence dans l’ensemble du ArrayList.
IndexOf(Object, Int32)	Recherche le Object spécifié et retourne l’index de base zéro de la première occurrence au sein de la plage d’éléments du ArrayList qui s’étend de l’index spécifié jusqu’au dernier élément.
IndexOf(Object, Int32, Int32)	Recherche le Object spécifié et retourne l’index de base zéro de la première occurrence dans la plage d’éléments de ArrayList qui commence à l’index spécifié et qui contient le nombre d’éléments spécifié.
Insert(Int32, Object)	Insère un élément dans la classe ArrayList au niveau de l'index spécifié.
InsertRange(Int32, ICollection)	Insère les éléments d'une collection dans ArrayList au niveau de l'index spécifié.
LastIndexOf(Object)	Recherche le Object spécifié et retourne l’index de base zéro de la dernière occurrence dans l’ensemble du ArrayList.
LastIndexOf(Object, Int32)	Recherche le Object spécifié et retourne l’index de base zéro de la dernière occurrence dans la plage d’éléments de l’ArrayList qui s’étend du premier élément à l’index spécifié.
LastIndexOf(Object, Int32, Int32)	Recherche le Object spécifié et retourne l’index de base zéro de la dernière occurrence dans la plage d’éléments de ArrayList qui contient le nombre spécifié d’éléments et se termine à l’index spécifié.
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
ReadOnly(ArrayList)	Retourne un wrapper ArrayList en lecture seule.
ReadOnly(IList)	Retourne un wrapper IList en lecture seule.
Remove(Object)	Supprime la première occurrence d’un objet spécifique de ArrayList.
RemoveAt(Int32)	Supprime l'élément au niveau de l'index spécifié de ArrayList.
RemoveRange(Int32, Int32)	Supprime une plage d'éléments de ArrayList.
Repeat(Object, Int32)	Retourne un ArrayList dont les éléments sont des copies de la valeur spécifiée.
Reverse()	Inverse l'ordre des éléments dans l'ensemble de ArrayList.
Reverse(Int32, Int32)	Inverse l'ordre des éléments dans la plage spécifiée.
SetRange(Int32, ICollection)	Copie les éléments d’une collection par-dessus une plage d’éléments dans ArrayList.
Sort()	Trie les éléments dans l’intégralité de ArrayList.
Sort(IComparer)	Trie les éléments dans l'ensemble de ArrayList à l'aide du comparateur spécifié.
Sort(Int32, Int32, IComparer)	Trie les éléments dans une plage d'éléments de ArrayList à l'aide du comparateur spécifié.
Synchronized(ArrayList)	Retourne un wrapper ArrayList qui est synchronisé (thread-safe).
Synchronized(IList)	Retourne un wrapper IList qui est synchronisé (thread-safe).
ToArray()	Copie les éléments de ArrayList dans un nouveau tableau Object.
ToArray(Type)	Copie les éléments de ArrayList vers un nouveau tableau du type d'élément spécifié.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)
TrimToSize()	Définit la capacité au nombre réel d'éléments dans ArrayList.

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

Cohérence de thread

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread-safe. Tous les membres de l'instance ne sont pas garantis comme étant thread-safe.

Un ArrayList peut prendre en charge plusieurs lecteurs simultanément, tant que la collection n’est pas modifiée. Pour garantir la sécurité du thread de , ArrayListtoutes les opérations doivent être effectuées via le wrapper retourné par la Synchronized(IList) méthode .

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours la modifier, ce qui entraîne la levée d'une exception par l'énumérateur. Pour garantir la sécurité des threads au cours de l’énumération, vous pouvez verrouiller la collection pendant l’ensemble de l’énumération ou bien intercepter les exceptions résultant des modifications apportées par les autres threads.

Voir aussi

• IList
• List<T>
• Exécution d’opérations de chaîne Culture-Insensitive dans des collections