ArrayList.Remove-Methode

Entfernt das erste Vorkommen eines bestimmten Objekts aus der ArrayList.

Namespace: System.Collections
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
Public Overridable Sub Remove ( _
    obj As Object _
)
'Usage
Dim instance As ArrayList
Dim obj As Object

instance.Remove(obj)

public virtual void Remove (
    Object obj
)

public:
virtual void Remove (
    Object^ obj
)

public void Remove (
    Object obj
)

public function Remove (
    obj : Object
)

Parameter

• obj
  Das Object, das aus der ArrayList entfernt werden soll. Der Wert kann NULL (Nothing in Visual Basic) sein.

Ausnahmen

Ausnahmetyp	Bedingung
NotSupportedException	ArrayList ist schreibgeschützt. – oder – ArrayList hat eine feste Größe.

Hinweise

Wenn die ArrayList das angegebene Objekt nicht enthält, wird die ArrayList nicht geändert. Es wird keine Ausnahme ausgelöst.

Diese Methode führt eine lineare Suche durch. Daher ist diese Methode eine O(n)-Operation, wobei nCount ist.

Diese Methode ruft Object.Equals für die Gleichheitsprüfung auf.

In Auflistungen mit zusammenhängenden Elementen, z. B. Listen, wird die entstandene Lücke durch Verschieben aller nachfolgenden Elemente gefüllt. Wenn die Auflistung indiziert ist, werden auch die Indizes der verschobenen Elemente aktualisiert. Dies gilt nicht für Auflistungen, in denen die Elemente konzeptionell in Buckets gruppiert sind, z. B. Hashtabellen.

Beispiel

Im folgenden Codebeispiel wird veranschaulicht, wie Elemente aus ArrayList entfernt werden.

Imports System
Imports System.Collections
Imports Microsoft.VisualBasic

Public Class SamplesArrayList    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new ArrayList.
        Dim myAL As New ArrayList()
        myAL.Add("The")
        myAL.Add("quick")
        myAL.Add("brown")
        myAL.Add("fox")
        myAL.Add("jumped")
        myAL.Add("over")
        myAL.Add("the")
        myAL.Add("lazy")
        myAL.Add("dog")
        
        ' Displays the ArrayList.
        Console.WriteLine("The ArrayList initially contains the following:")
        PrintValues(myAL)
        
        ' Removes the element containing "lazy".
        myAL.Remove("lazy")
        
        ' Displays the current state of the ArrayList.
        Console.WriteLine("After removing ""lazy"":")
        PrintValues(myAL)
        
        ' Removes the element at index 5.
        myAL.RemoveAt(5)
        
        ' Displays the current state of the ArrayList.
        Console.WriteLine("After removing the element at index 5:")
        PrintValues(myAL)
        
        ' Removes three elements starting at index 4.
        myAL.RemoveRange(4, 3)
        
        ' Displays the current state of the ArrayList.
        Console.WriteLine("After removing three elements starting at index 4:")
        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 'PrintValues

End Class


' This code produces the following output.
' 
' The ArrayList initially contains the following:
'    The   quick   brown   fox   jumped   over   the   lazy   dog
' After removing "lazy":
'    The   quick   brown   fox   jumped   over   the   dog
' After removing the element at index 5:
'    The   quick   brown   fox   jumped   the   dog
' After removing three elements starting at index 4:
'    The   quick   brown   fox

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

   public static void Main()  {

      // Creates and initializes a new ArrayList.
      ArrayList myAL = new ArrayList();
      myAL.Add( "The" );
      myAL.Add( "quick" );
      myAL.Add( "brown" );
      myAL.Add( "fox" );
      myAL.Add( "jumped" );
      myAL.Add( "over" );
      myAL.Add( "the" );
      myAL.Add( "lazy" );
      myAL.Add( "dog" );

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

      // Removes the element containing "lazy".
      myAL.Remove( "lazy" );

      // Displays the current state of the ArrayList.
      Console.WriteLine( "After removing \"lazy\":" );
      PrintValues( myAL );

      // Removes the element at index 5.
      myAL.RemoveAt( 5 );

      // Displays the current state of the ArrayList.
      Console.WriteLine( "After removing the element at index 5:" );
      PrintValues( myAL );

      // Removes three elements starting at index 4.
      myAL.RemoveRange( 4, 3 );

      // Displays the current state of the ArrayList.
      Console.WriteLine( "After removing three elements starting at index 4:" );
      PrintValues( myAL );
   }

   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   quick   brown   fox   jumped   over   the   lazy   dog
After removing "lazy":
   The   quick   brown   fox   jumped   over   the   dog
After removing the element at index 5:
   The   quick   brown   fox   jumped   the   dog
After removing three elements starting at index 4:
   The   quick   brown   fox
*/ 

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( "The" );
   myAL->Add( "quick" );
   myAL->Add( "brown" );
   myAL->Add( "fox" );
   myAL->Add( "jumped" );
   myAL->Add( "over" );
   myAL->Add( "the" );
   myAL->Add( "lazy" );
   myAL->Add( "dog" );
   
   // Displays the ArrayList.
   Console::WriteLine( "The ArrayList initially contains the following:" );
   PrintValues( myAL );
   
   // Removes the element containing "lazy".
   myAL->Remove( "lazy" );
   
   // Displays the current state of the ArrayList.
   Console::WriteLine( "After removing \"lazy\":" );
   PrintValues( myAL );
   
   // Removes the element at index 5.
   myAL->RemoveAt( 5 );
   
   // Displays the current state of the ArrayList.
   Console::WriteLine( "After removing the element at index 5:" );
   PrintValues( myAL );
   
   // Removes three elements starting at index 4.
   myAL->RemoveRange( 4, 3 );
   
   // Displays the current state of the ArrayList.
   Console::WriteLine( "After removing three elements starting at index 4:" );
   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 the following output.
 
 The ArrayList initially contains the following:
    The   quick   brown   fox   jumped   over   the   lazy   dog
 After removing "lazy":
    The   quick   brown   fox   jumped   over   the   dog
 After removing the element at index 5:
    The   quick   brown   fox   jumped   the   dog
 After removing three elements starting at index 4:
    The   quick   brown   fox
 */

import System.*;
import System.Collections.*;

public class SamplesArrayList
{
    public static void main(String[] args)
    {
        // Creates and initializes a new ArrayList.
        ArrayList myAL = new ArrayList();

        myAL.Add("The");
        myAL.Add("quick");
        myAL.Add("brown");
        myAL.Add("fox");
        myAL.Add("jumped");
        myAL.Add("over");
        myAL.Add("the");
        myAL.Add("lazy");
        myAL.Add("dog");

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

        // Removes the element containing "lazy".
        myAL.Remove("lazy");

        // Displays the current state of the ArrayList.
        Console.WriteLine("After removing \"lazy\":");
        PrintValues(myAL);

        // Removes the element at index 5.
        myAL.RemoveAt(5);

        // Displays the current state of the ArrayList.
        Console.WriteLine("After removing the element at index 5:");
        PrintValues(myAL);

        // Removes three elements starting at index 4.
        myAL.RemoveRange(4, 3);

        // Displays the current state of the ArrayList.
        Console.WriteLine("After removing three elements starting at index 4:");
        PrintValues(myAL);
    } //main

    public static void PrintValues(IEnumerable myList)
    {
        IEnumerator objMyEnum = myList.GetEnumerator();
        while (objMyEnum.MoveNext()) {
            Object obj = objMyEnum.get_Current();
            Console.Write("   {0}", obj);
        }
        Console.WriteLine();
    } //PrintValues
} //SamplesArrayList 
/* 
 This code produces the following output.
 
 The ArrayList initially contains the following:
    The   quick   brown   fox   jumped   over   the   lazy   dog
 After removing "lazy":
    The   quick   brown   fox   jumped   over   the   dog
 After removing the element at index 5:
    The   quick   brown   fox   jumped   the   dog
 After removing three elements starting at index 4:
    The   quick   brown   fox
 */

import System;
import System.Collections;

// Creates and initializes a new ArrayList.
var myAL : ArrayList = new ArrayList();
myAL.Add( "The" );
myAL.Add( "quick" );
myAL.Add( "brown" );
myAL.Add( "fox" );
myAL.Add( "jumped" );
myAL.Add( "over" );
myAL.Add( "the" );
myAL.Add( "lazy" );
myAL.Add( "dog" );

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

// Removes the element containing "lazy".
myAL.Remove( "lazy" );

// Displays the current state of the ArrayList.
Console.WriteLine( "After removing \"lazy\":" );
PrintValues( myAL );

// Removes the element at index 5.
myAL.RemoveAt( 5 );

// Displays the current state of the ArrayList.
Console.WriteLine( "After removing the element at index 5:" );
PrintValues( myAL );

// Removes three elements starting at index 4.
myAL.RemoveRange( 4, 3 );

// Displays the current state of the ArrayList.
Console.WriteLine( "After removing three elements starting at index 4:" );
PrintValues( myAL );

function PrintValues( myList : IEnumerable )  {
   var myEnumerator : System.Collections.IEnumerator  = myList.GetEnumerator();
   while ( myEnumerator.MoveNext() )
      Console.Write( "\t{0}", myEnumerator.Current );
   Console.WriteLine();
}
 /* 
 This code produces the following output.
 
 The ArrayList initially contains the following:
     The    quick    brown    fox    jumped    over    the    lazy    dog
 After removing "lazy":
     The    quick    brown    fox    jumped    over    the    dog
 After removing the element at index 5:
     The    quick    brown    fox    jumped    the    dog
 After removing three elements starting at index 4:
     The    quick    brown    fox
 */ 

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Versionsinformationen

.NET Framework

Unterstützt in: 2.0, 1.1, 1.0

.NET Compact Framework

Unterstützt in: 2.0, 1.0

Siehe auch

Referenz

ArrayList-Klasse
ArrayList-Member
System.Collections-Namespace
RemoveAt
RemoveRange
Add
Insert

Weitere Ressourcen

Durchführen kulturunabhängiger Zeichenfolgenoperationen in Auflistungen