ArrayList Classe

Définition

Implémente l’interface IList à l’aide d’un tableau dont la taille est augmentée de manière dynamique au besoin.Implements the IList interface using an array whose size is dynamically increased as required.

public ref class ArrayList : ICloneable, System::Collections::IList
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class ArrayList : ICloneable, System.Collections.IList
type ArrayList = class
    interface IList
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class ArrayList
Implements ICloneable, IList
Héritage
ArrayList
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant montre comment créer et initialiser un ArrayList et comment afficher ses valeurs.The following example shows how to create and initialize an ArrayList and how to display its values.

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 ArrayList pour le nouveau développement.We don't recommend that you use the ArrayList class for new development. Au lieu de cela, nous vous recommandons d’utiliser la classe générique List<T>.Instead, we recommend that you use the generic List<T> class. La classe ArrayList est conçue pour contenir des collections d’objets hétérogènes.The ArrayList class is designed to hold heterogeneous collections of objects. Toutefois, il n’offre pas toujours les meilleures performances.However, it does not always offer the best performance. Au lieu de cela, nous vous recommandons les éléments suivants :Instead, we recommend the following:

  • Pour une collection d’objets hétérogène, utilisez le type List<Object> ( C#dans) ou List(Of Object) (en Visual Basic).For a heterogeneous collection of objects, use the List<Object> (in C#) or List(Of Object) (in Visual Basic) type.
  • Pour une collection homogène d’objets, utilisez la classe List<T>.For a homogeneous collection of objects, use the List<T> class.
    Pour plus d’informations sur les performances relatives de ces classes, consultez Considérations sur les performances dans la rubrique de référence List<T>.See Performance Considerations in the List<T> reference topic for a discussion of the relative performance of these classes. Consultez les collections non génériques sur GitHub pour obtenir des informations générales sur l’utilisation de génériques au lieu de types de collections non génériques.See Non-generic collections shouldn't be used on GitHub for general information on the use of generic instead of non-generic collection types.

Le tri de la ArrayList n’est pas garanti.The ArrayList is not guaranteed to be sorted. Vous devez trier le ArrayList en appelant sa méthode Sort avant d’effectuer des opérations (par exemple, BinarySearch) qui nécessitent le tri du ArrayList.You must sort the ArrayList by calling its Sort method prior to performing operations (such as BinarySearch) that require the ArrayList to be sorted. Pour conserver une collection qui est automatiquement triée au fur et à mesure de l’ajout de nouveaux éléments, vous pouvez utiliser la classe SortedSet<T>.To maintain a collection that is automatically sorted as new elements are added, you can use the SortedSet<T> class.

La capacité d’un ArrayList correspond au nombre d’éléments que le ArrayList peut contenir.The capacity of an ArrayList is the number of elements the ArrayList can hold. À mesure que des éléments sont ajoutés à un ArrayList, la capacité est automatiquement augmentée en fonction des besoins par réallocation.As elements are added to an ArrayList, the capacity is automatically increased as required through reallocation. La capacité peut être réduite en appelant TrimToSize ou en définissant la propriété Capacity explicitement.The capacity can be decreased by calling TrimToSize or by setting the Capacity property explicitly.

.NET Framework uniquement : Pour les très grands objets ArrayList, vous pouvez augmenter la capacité maximale à 2 milliards éléments sur un système 64 bits en affectant à l’attribut enabled de l’élément de configuration <gcAllowVeryLargeObjects> la valeur true dans l’environnement d’exécution..NET Framework only: For very large ArrayList objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

Les éléments de cette collection sont accessibles à l’aide d’un index d’entiers.Elements in this collection can be accessed using an integer index. Les index de cette collection sont de base zéro.Indexes in this collection are zero-based.

La collection ArrayList accepte null comme valeur valide.The ArrayList collection accepts null as a valid value. Il autorise également les éléments en double.It also allows duplicate elements.

L’utilisation de tableaux multidimensionnels en tant qu’éléments dans une collection ArrayList n’est pas prise en charge.Using multidimensional arrays as elements in an ArrayList collection is not supported.

Constructeurs

ArrayList()

Initialise une nouvelle instance de la classe ArrayList qui est vide et possède la capacité initiale par défaut.Initializes a new instance of the ArrayList class that is empty and has the default initial capacity.

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.Initializes a new instance of the ArrayList class that contains elements copied from the specified collection and that has the same initial capacity as the number of elements copied.

ArrayList(Int32)

Initialise une nouvelle instance de la classe ArrayList qui est vide et a la capacité initiale spécifiée.Initializes a new instance of the ArrayList class that is empty and has the specified initial capacity.

Propriétés

Capacity

Obtient ou définit le nombre d'éléments que ArrayList peut contenir.Gets or sets the number of elements that the ArrayList can contain.

Count

Obtient le nombre d’éléments réellement contenus dans ArrayList.Gets the number of elements actually contained in the ArrayList.

IsFixedSize

Obtient une valeur indiquant si ArrayList est de taille fixe.Gets a value indicating whether the ArrayList has a fixed size.

IsReadOnly

Obtient une valeur indiquant si ArrayList est en lecture seule.Gets a value indicating whether the ArrayList is read-only.

IsSynchronized

Obtient une valeur indiquant si l'accès à ArrayList est synchronisé (thread-safe).Gets a value indicating whether access to the ArrayList is synchronized (thread safe).

Item[Int32]

Obtient ou définit l'élément au niveau de l'index spécifié.Gets or sets the element at the specified index.

SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à ArrayList.Gets an object that can be used to synchronize access to the ArrayList.

Méthodes

Adapter(IList)

Crée un wrapper ArrayList pour un IList spécifique.Creates an ArrayList wrapper for a specific IList.

Add(Object)

Ajoute un objet à la fin de la ArrayList.Adds an object to the end of the ArrayList.

AddRange(ICollection)

Ajoute les éléments de ICollection à la fin de ArrayList.Adds the elements of an ICollection to the end of the 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.Searches a range of elements in the sorted ArrayList for an element using the specified comparer and returns the zero-based index of the element.

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.Searches the entire sorted ArrayList for an element using the default comparer and returns the zero-based index of the element.

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.Searches the entire sorted ArrayList for an element using the specified comparer and returns the zero-based index of the element.

Clear()

Supprime tous les éléments de ArrayList.Removes all elements from the ArrayList.

Clone()

Crée une copie superficielle de ArrayList.Creates a shallow copy of the ArrayList.

Contains(Object)

Détermine si le ArrayList contient un élément.Determines whether an element is in the ArrayList.

CopyTo(Array)

Copie l’ensemble de ArrayList dans un Array compatible unidimensionnel en commençant au début du tableau cible.Copies the entire ArrayList to a compatible one-dimensional Array, starting at the beginning of the target array.

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.Copies the entire ArrayList to a compatible one-dimensional Array, starting at the specified index of the target array.

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.Copies a range of elements from the ArrayList to a compatible one-dimensional Array, starting at the specified index of the target array.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.Determines whether the specified object is equal to the current object.

(Hérité de Object)
FixedSize(ArrayList)

Retourne un wrapper ArrayList de taille fixe.Returns an ArrayList wrapper with a fixed size.

FixedSize(IList)

Retourne un wrapper IList de taille fixe.Returns an IList wrapper with a fixed size.

GetEnumerator()

Retourne un énumérateur pour le ArrayList entier.Returns an enumerator for the entire ArrayList.

GetEnumerator(Int32, Int32)

Retourne un énumérateur pour une plage d’éléments d’ArrayList.Returns an enumerator for a range of elements in the ArrayList.

GetHashCode()

Sert de fonction de hachage par défaut.Serves as the default hash function.

(Hérité de Object)
GetRange(Int32, Int32)

Retourne un ArrayList qui représente un sous-ensemble des éléments du ArrayList source.Returns an ArrayList which represents a subset of the elements in the source ArrayList.

GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(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.Searches for the specified Object and returns the zero-based index of the first occurrence within the entire 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.Searches for the specified Object and returns the zero-based index of the first occurrence within the range of elements in the ArrayList that extends from the specified index to the last element.

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é.Searches for the specified Object and returns the zero-based index of the first occurrence within the range of elements in the ArrayList that starts at the specified index and contains the specified number of elements.

Insert(Int32, Object)

Insère un élément dans la classe ArrayList au niveau de l'index spécifié.Inserts an element into the ArrayList at the specified index.

InsertRange(Int32, ICollection)

Insère les éléments d'une collection dans ArrayList au niveau de l'index spécifié.Inserts the elements of a collection into the ArrayList at the specified index.

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.Searches for the specified Object and returns the zero-based index of the last occurrence within the entire 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é.Searches for the specified Object and returns the zero-based index of the last occurrence within the range of elements in the ArrayList that extends from the first element to the specified index.

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é.Searches for the specified Object and returns the zero-based index of the last occurrence within the range of elements in the ArrayList that contains the specified number of elements and ends at the specified index.

MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(Hérité de Object)
ReadOnly(ArrayList)

Retourne un wrapper ArrayList en lecture seule.Returns a read-only ArrayList wrapper.

ReadOnly(IList)

Retourne un wrapper IList en lecture seule.Returns a read-only IList wrapper.

Remove(Object)

Supprime la première occurrence d'un objet spécifique de ArrayList.Removes the first occurrence of a specific object from the ArrayList.

RemoveAt(Int32)

Supprime l'élément au niveau de l'index spécifié de ArrayList.Removes the element at the specified index of the ArrayList.

RemoveRange(Int32, Int32)

Supprime une plage d'éléments de ArrayList.Removes a range of elements from the ArrayList.

Repeat(Object, Int32)

Retourne un ArrayList dont les éléments sont des copies de la valeur spécifiée.Returns an ArrayList whose elements are copies of the specified value.

Reverse()

Inverse l'ordre des éléments dans l'ensemble de ArrayList.Reverses the order of the elements in the entire ArrayList.

Reverse(Int32, Int32)

Inverse l'ordre des éléments dans la plage spécifiée.Reverses the order of the elements in the specified range.

SetRange(Int32, ICollection)

Copie les éléments d’une collection par-dessus une plage d’éléments dans ArrayList.Copies the elements of a collection over a range of elements in the ArrayList.

Sort()

Trie les éléments dans l’intégralité de ArrayList.Sorts the elements in the entire ArrayList.

Sort(IComparer)

Trie les éléments dans l'ensemble de ArrayList à l'aide du comparateur spécifié.Sorts the elements in the entire ArrayList using the specified comparer.

Sort(Int32, Int32, IComparer)

Trie les éléments dans une plage d'éléments de ArrayList à l'aide du comparateur spécifié.Sorts the elements in a range of elements in ArrayList using the specified comparer.

Synchronized(ArrayList)

Retourne un wrapper ArrayList qui est synchronisé (thread-safe).Returns an ArrayList wrapper that is synchronized (thread safe).

Synchronized(IList)

Retourne un wrapper IList qui est synchronisé (thread-safe).Returns an IList wrapper that is synchronized (thread safe).

ToArray()

Copie les éléments de ArrayList dans un nouveau tableau Object.Copies the elements of the ArrayList to a new Object array.

ToArray(Type)

Copie les éléments de ArrayList vers un nouveau tableau du type d'élément spécifié.Copies the elements of the ArrayList to a new array of the specified element type.

ToString()

Retourne une chaîne qui représente l'objet en cours.Returns a string that represents the current object.

(Hérité de Object)
TrimToSize()

Définit la capacité au nombre réel d'éléments dans ArrayList.Sets the capacity to the actual number of elements in the ArrayList.

Méthodes d’extension

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à

Cohérence de thread

Public static (Shared dans Visual Basic) les membres de ce type sont thread-safe.Public static (Shared in Visual Basic) members of this type are thread safe. Il n'est pas garanti que les membres d'instance soient thread-safe.Any instance members are not guaranteed to be thread safe.

Un ArrayList peut prendre en charge plusieurs lecteurs simultanément, tant que la collection n’est pas modifiée.An ArrayList can support multiple readers concurrently, as long as the collection is not modified. Pour garantir la sécurité des threads du ArrayList, toutes les opérations doivent être effectuées par le biais du wrapper retourné par la méthode Synchronized(IList).To guarantee the thread safety of the ArrayList, all operations must be done through the wrapper returned by the Synchronized(IList) method.

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe.Enumerating through a collection is intrinsically not a thread-safe procedure. 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.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Voir aussi