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.

public ref class ArrayList : System::Collections::IList
public ref class ArrayList : ICloneable, System::Collections::IList
public class ArrayList : System.Collections.IList
public class ArrayList : ICloneable, System.Collections.IList
[System.Serializable]
public class ArrayList : ICloneable, System.Collections.IList
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class ArrayList : ICloneable, System.Collections.IList
type ArrayList = class
    interface IEnumerable
    interface IList
    interface ICollection
type ArrayList = class
    interface ICollection
    interface IEnumerable
    interface IList
    interface ICloneable
type ArrayList = class
    interface IEnumerable
    interface IList
    interface ICollection
    interface ICloneable
[<System.Serializable>]
type ArrayList = class
    interface IList
    interface ICollection
    interface IEnumerable
    interface ICloneable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ArrayList = class
    interface IList
    interface ICollection
    interface IEnumerable
    interface ICloneable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type ArrayList = class
    interface IList
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class ArrayList
Implements IList
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.

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 ArrayList classe pour un nouveau développement. Au lieu de cela, nous vous recommandons d’utiliser la List<T> classe générique. La ArrayList classe est conçue pour contenir des collections d’objets hétérogènes. Toutefois, il n’offre pas toujours les meilleures performances. Au lieu de cela, nous vous recommandons les éléments suivants :

  • pour une collection d’objets hétérogène, 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.
    Pour plus List<T> d’informations sur les performances relatives de ces classes, consultez Considérations sur les performances dans la rubrique de référence. 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.

Il n' ArrayList est pas garanti que le tri soit effectué. Vous devez trier le ArrayList en appelant sa Sort méthode avant d’effectuer des opérations (telles que BinarySearch ) qui nécessitent le ArrayList tri de. Pour conserver une collection qui est automatiquement triée au fur et à mesure de l’ajout de nouveaux éléments, vous pouvez utiliser la SortedSet<T> classe.

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

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

Les éléments de cette collection sont accessibles à l’aide d’un index d’entiers. 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.

S’applique à

Cohérence de thread

les membres statiques publics ( Shared dans 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, à condition que la collection ne soit pas modifiée. 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 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