Condividi tramite


ArrayList.Insert(Int32, Object) Metodo

Definizione

Inserisce un elemento in ArrayList in corrispondenza dell'indice specificato.

public:
 virtual void Insert(int index, System::Object ^ value);
public virtual void Insert (int index, object value);
public virtual void Insert (int index, object? value);
abstract member Insert : int * obj -> unit
override this.Insert : int * obj -> unit
Public Overridable Sub Insert (index As Integer, value As Object)

Parametri

index
Int32

Indice in base zero nel quale value deve essere inserito.

value
Object

Oggetto Object da inserire. Il valore può essere null.

Implementazioni

Eccezioni

index è minore di zero.

-oppure-

index è maggiore di Count.

La classe ArrayList è di sola lettura.

-oppure-

Le dimensioni dell'oggetto ArrayList sono fisse.

Esempio

Nell'esempio di codice seguente viene illustrato come inserire elementi nell'oggetto 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()

Commenti

ArrayList accetta null come valore valido e consente elementi duplicati.

Se Count è già uguale Capacity, la capacità dell'oggetto ArrayList viene aumentata automaticamente riallocare la matrice interna e gli elementi esistenti vengono copiati nella nuova matrice prima dell'aggiunta del nuovo elemento.

Se index è uguale a Count, value viene aggiunto alla fine di ArrayList.

In raccolte di elementi adiacenti, quali gli elenchi, gli elementi successivi al punto di inserimento vengono spostati verso il basso per consentire l'inserimento del nuovo elemento. Se la raccolta è indicizzata, vengono aggiornati anche gli indici degli elementi spostati. Questo comportamento non viene applicato alle raccolte in cui gli elementi sono raggruppati concettualmente in bucket, come accade ad esempio per le tabelle hash.

Questo metodo è un'operazione O(n) , dove n è Count.

Si applica a

Vedi anche