Partager via


ArrayList.InsertRange(Int32, ICollection) Méthode

Définition

Insère les éléments d'une collection dans ArrayList au niveau de l'index spécifié.

public:
 virtual void InsertRange(int index, System::Collections::ICollection ^ c);
public virtual void InsertRange (int index, System.Collections.ICollection c);
abstract member InsertRange : int * System.Collections.ICollection -> unit
override this.InsertRange : int * System.Collections.ICollection -> unit
Public Overridable Sub InsertRange (index As Integer, c As ICollection)

Paramètres

index
Int32

Index de base zéro au niveau duquel les nouveaux éléments devraient être insérés.

c
ICollection

ICollection dont les éléments doivent être insérés dans ArrayList. La collection elle-même ne peut pas avoir la valeur null, mais elle peut contenir des éléments qui ont la valeur null.

Exceptions

c a la valeur null.

index est inférieur à zéro.

- ou -

index est supérieur à Count.

ArrayList est en lecture seule.

- ou -

ArrayList est de taille fixe.

Exemples

L’exemple de code suivant montre comment insérer des éléments dans le ArrayList.

using namespace System;
using namespace System::Collections;
void PrintValues( IEnumerable^ myList );
int main()
{
   
   // Creates and initializes a new ArrayList using Insert instead of Add.
   ArrayList^ myAL = gcnew ArrayList;
   myAL->Insert( 0, "The" );
   myAL->Insert( 1, "fox" );
   myAL->Insert( 2, "jumps" );
   myAL->Insert( 3, "over" );
   myAL->Insert( 4, "the" );
   myAL->Insert( 5, "dog" );
   
   // Creates and initializes a new Queue.
   Queue^ myQueue = gcnew Queue;
   myQueue->Enqueue( "quick" );
   myQueue->Enqueue( "brown" );
   
   // Displays the ArrayList and the Queue.
   Console::WriteLine( "The ArrayList initially contains the following:" );
   PrintValues( myAL );
   Console::WriteLine( "The Queue initially contains the following:" );
   PrintValues( myQueue );
   
   // Copies the Queue elements to the ArrayList at index 1.
   myAL->InsertRange( 1, myQueue );
   
   // Displays the ArrayList.
   Console::WriteLine( "After adding the Queue, the ArrayList now contains:" );
   PrintValues( myAL );
   
   // Search for "dog" and add "lazy" before it.
   myAL->Insert( myAL->IndexOf( "dog" ), "lazy" );
   
   // Displays the ArrayList.
   Console::WriteLine( "After adding \"lazy\", the ArrayList now contains:" );
   PrintValues( myAL );
   
   // Add "!!!" at the end.
   myAL->Insert( myAL->Count, "!!!" );
   
   // Displays the ArrayList.
   Console::WriteLine( "After adding \"!!!\", the ArrayList now contains:" );
   PrintValues( myAL );
   
   // Inserting an element beyond Count throws an exception.
   try
   {
      myAL->Insert( myAL->Count + 1, "anystring" );
   }
   catch ( Exception^ myException ) 
   {
      Console::WriteLine( "Exception: {0}", myException );
   }

}

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 the following output.
 
 The ArrayList initially contains the following:
    The   fox   jumps   over   the   dog
 The Queue initially contains the following:
    quick   brown
 After adding the Queue, the ArrayList now contains:
    The   quick   brown   fox   jumps   over   the   dog
 After adding "lazy", the ArrayList now contains:
    The   quick   brown   fox   jumps   over   the   lazy   dog
 After adding "!!!", the ArrayList now contains:
    The   quick   brown   fox   jumps   over   the   lazy   dog   !!!
 Exception: System.ArgumentOutOfRangeException: Insertion index was out of range.  Must be non-negative and less than or equal to size.
 Parameter name: index
    at System.Collections.ArrayList.Insert(Int32 index, Object value)
    at SamplesArrayList.Main()
 */
using System;
using System.Collections;
public class SamplesArrayList  {

   public static void Main()  {

      // Creates and initializes a new ArrayList using Insert instead of Add.
      ArrayList myAL = new ArrayList();
      myAL.Insert( 0, "The" );
      myAL.Insert( 1, "fox" );
      myAL.Insert( 2, "jumps" );
      myAL.Insert( 3, "over" );
      myAL.Insert( 4, "the" );
      myAL.Insert( 5, "dog" );

      // Creates and initializes a new Queue.
      Queue myQueue = new Queue();
      myQueue.Enqueue( "quick" );
      myQueue.Enqueue( "brown" );

      // Displays the ArrayList and the Queue.
      Console.WriteLine( "The ArrayList initially contains the following:" );
      PrintValues( myAL );
      Console.WriteLine( "The Queue initially contains the following:" );
      PrintValues( myQueue );

      // Copies the Queue elements to the ArrayList at index 1.
      myAL.InsertRange( 1, myQueue );

      // Displays the ArrayList.
      Console.WriteLine( "After adding the Queue, the ArrayList now contains:" );
      PrintValues( myAL );

      // Search for "dog" and add "lazy" before it.
      myAL.Insert( myAL.IndexOf( "dog" ), "lazy" );

      // Displays the ArrayList.
      Console.WriteLine( "After adding \"lazy\", the ArrayList now contains:" );
      PrintValues( myAL );

      // Add "!!!" at the end.
      myAL.Insert( myAL.Count, "!!!" );

      // Displays the ArrayList.
      Console.WriteLine( "After adding \"!!!\", the ArrayList now contains:" );
      PrintValues( myAL );

      // Inserting an element beyond Count throws an exception.
      try  {
         myAL.Insert( myAL.Count+1, "anystring" );
      } catch ( Exception myException )  {
         Console.WriteLine("Exception: " + myException.ToString());
      }
   }

   public static void PrintValues( IEnumerable myList )  {
      foreach ( Object obj in myList )
         Console.Write( "   {0}", obj );
      Console.WriteLine();
   }
}
/*
This code produces the following output.

The ArrayList initially contains the following:
   The   fox   jumps   over   the   dog
The Queue initially contains the following:
   quick   brown
After adding the Queue, the ArrayList now contains:
   The   quick   brown   fox   jumps   over   the   dog
After adding "lazy", the ArrayList now contains:
   The   quick   brown   fox   jumps   over   the   lazy   dog
After adding "!!!", the ArrayList now contains:
   The   quick   brown   fox   jumps   over   the   lazy   dog   !!!
Exception: System.ArgumentOutOfRangeException: Insertion index was out of range.  Must be non-negative and less than or equal to size.
Parameter name: index
   at System.Collections.ArrayList.Insert(int index, Object value)
   at SamplesArrayList.Main()
*/
Imports System.Collections

Public Class SamplesArrayList    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new ArrayList using Insert instead of Add.
        Dim myAL As New ArrayList()
        myAL.Insert(0, "The")
        myAL.Insert(1, "fox")
        myAL.Insert(2, "jumps")
        myAL.Insert(3, "over")
        myAL.Insert(4, "the")
        myAL.Insert(5, "dog")
        
        ' Creates and initializes a new Queue.
        Dim myQueue As New Queue()
        myQueue.Enqueue("quick")
        myQueue.Enqueue("brown")
        
        ' Displays the ArrayList and the Queue.
        Console.WriteLine("The ArrayList initially contains the following:")
        PrintValues(myAL)
        Console.WriteLine("The Queue initially contains the following:")
        PrintValues(myQueue)
        
        ' Copies the Queue elements to the ArrayList at index 1.
        myAL.InsertRange(1, myQueue)
        
        ' Displays the ArrayList.
        Console.WriteLine("After adding the Queue, the ArrayList now contains:")
        PrintValues(myAL)
        
        ' Search for "dog" and add "lazy" before it.
        myAL.Insert(myAL.IndexOf("dog"), "lazy")
        
        ' Displays the ArrayList.
        Console.WriteLine("After adding ""lazy"", the ArrayList now contains:")
        PrintValues(myAL)
        
        ' Add "!!!" at the end.
        myAL.Insert(myAL.Count, "!!!")
        
        ' Displays the ArrayList.
        Console.WriteLine("After adding ""!!!"", the ArrayList now contains:")
        PrintValues(myAL)
        
        ' Inserting an element beyond Count throws an exception.
        Try
            myAL.Insert(myAL.Count + 1, "anystring")
        Catch myException As Exception
            Console.WriteLine("Exception: " + myException.ToString())
        End Try
    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 the following output.
' 
' The ArrayList initially contains the following:
'     The    fox    jumps    over    the    dog
' The Queue initially contains the following:
'     quick    brown
' After adding the Queue, the ArrayList now contains:
'     The    quick    brown    fox    jumps    over    the    dog
' After adding "lazy", the ArrayList now contains:
'     The    quick    brown    fox    jumps    over    the    lazy    dog
' After adding "!!!", the ArrayList now contains:
'     The    quick    brown    fox    jumps    over    the    lazy    dog    !!!
' Exception: System.ArgumentOutOfRangeException: Insertion index was out of range.  Must be non-negative and less than or equal to size.
' Parameter name: index
'    at System.Collections.ArrayList.Insert(Int32 index, Object value)
'    at SamplesArrayList.Main()

Remarques

ArrayList accepte null comme valeur valide et autorise les éléments en double.

Si le nouveau Count (le actuel Count plus la taille de la collection) est supérieur Capacityà , la capacité du ArrayList est augmentée en réaffectant automatiquement le tableau interne pour prendre en charge les nouveaux éléments, et les éléments existants sont copiés dans le nouveau tableau avant l’ajout des nouveaux éléments.

Si index est égal à Count, les éléments sont ajoutés à la fin de ArrayList.

L’ordre des éléments dans est ICollection conservé dans le ArrayList.

Dans des collections d’éléments contigus, telles que les listes, les éléments situés après le point d’insertion descendent afin de prendre en compte le nouvel élément. Si la collection est indexée, les index des éléments déplacés sont également mis à jour. Ce comportement ne s'applique pas aux collections dont les éléments sont regroupés de manière conceptuelle en compartiments, comme par exemple les tables de hachage.

Cette méthode est une O(n + m) opération, où n est le nombre d’éléments à ajouter et m est Count.

S’applique à

Voir aussi