SortedList.RemoveAt(Int32) Método

Referência

Definição

Namespace:: System.Collections

Assemblies:: mscorlib.dll, System.Collections.NonGeneric.dll

Assembly:: System.Collections.NonGeneric.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: SortedList.cs

Origem:: SortedList.cs

Origem:: SortedList.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Remove o elemento no índice especificado de um objeto SortedList.

public:
 virtual void RemoveAt(int index);

public virtual void RemoveAt (int index);

abstract member RemoveAt : int -> unit
override this.RemoveAt : int -> unit

Public Overridable Sub RemoveAt (index As Integer)

Parâmetros

index: Int32

O índice de base zero do elemento a ser removido.

Exceções

ArgumentOutOfRangeException

index está fora do intervalo de índices válidos para o objeto SortedList.

NotSupportedException

O SortedList é somente leitura.

- ou -

O SortedList tem um tamanho fixo.

Exemplos

O exemplo de código a seguir mostra como remover elementos de um SortedList objeto .

#using <system.dll>

using namespace System;
using namespace System::Collections;
void PrintKeysAndValues( SortedList^ myList )
{
   Console::WriteLine( "\t-KEY-\t-VALUE-" );
   for ( int i = 0; i < myList->Count; i++ )
   {
      Console::WriteLine( "\t{0}:\t{1}", myList->GetKey( i ), myList->GetByIndex( i ) );

   }
   Console::WriteLine();
}

int main()
{
   
   // Creates and initializes a new SortedList.
   SortedList^ mySL = gcnew SortedList;
   mySL->Add( "3c", "dog" );
   mySL->Add( "2c", "over" );
   mySL->Add( "1c", "brown" );
   mySL->Add( "1a", "The" );
   mySL->Add( "1b", "quick" );
   mySL->Add( "3a", "the" );
   mySL->Add( "3b", "lazy" );
   mySL->Add( "2a", "fox" );
   mySL->Add( "2b", "jumps" );
   
   // Displays the SortedList.
   Console::WriteLine( "The SortedList initially contains the following:" );
   PrintKeysAndValues( mySL );
   
   // Removes the element with the key "3b".
   mySL->Remove( "3b" );
   
   // Displays the current state of the SortedList.
   Console::WriteLine( "After removing \"lazy\":" );
   PrintKeysAndValues( mySL );
   
   // Removes the element at index 5.
   mySL->RemoveAt( 5 );
   
   // Displays the current state of the SortedList.
   Console::WriteLine( "After removing the element at index 5:" );
   PrintKeysAndValues( mySL );
}

/*
This code produces the following output.

The SortedList initially contains the following:
        -KEY-   -VALUE-
        1a:     The
        1b:     quick
        1c:     brown
        2a:     fox
        2b:     jumps
        2c:     over
        3a:     the
        3b:     lazy
        3c:     dog

After removing "lazy":
        -KEY-   -VALUE-
        1a:     The
        1b:     quick
        1c:     brown
        2a:     fox
        2b:     jumps
        2c:     over
        3a:     the
        3c:     dog

After removing the element at index 5:
        -KEY-   -VALUE-
        1a:     The
        1b:     quick
        1c:     brown
        2a:     fox
        2b:     jumps
        3a:     the
        3c:     dog
*/

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

   public static void Main()  {

      // Creates and initializes a new SortedList.
      SortedList mySL = new SortedList();
      mySL.Add( "3c", "dog" );
      mySL.Add( "2c", "over" );
      mySL.Add( "1c", "brown" );
      mySL.Add( "1a", "The" );
      mySL.Add( "1b", "quick" );
      mySL.Add( "3a", "the" );
      mySL.Add( "3b", "lazy" );
      mySL.Add( "2a", "fox" );
      mySL.Add( "2b", "jumps" );

      // Displays the SortedList.
      Console.WriteLine( "The SortedList initially contains the following:" );
      PrintKeysAndValues( mySL );

      // Removes the element with the key "3b".
      mySL.Remove( "3b" );

      // Displays the current state of the SortedList.
      Console.WriteLine( "After removing \"lazy\":" );
      PrintKeysAndValues( mySL );

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

      // Displays the current state of the SortedList.
      Console.WriteLine( "After removing the element at index 5:" );
      PrintKeysAndValues( mySL );
   }

   public static void PrintKeysAndValues( SortedList myList )  {
      Console.WriteLine( "\t-KEY-\t-VALUE-" );
      for ( int i = 0; i < myList.Count; i++ )  {
         Console.WriteLine( "\t{0}:\t{1}", myList.GetKey(i), myList.GetByIndex(i) );
      }
      Console.WriteLine();
   }
}
/*
This code produces the following output.

The SortedList initially contains the following:
    -KEY-    -VALUE-
    1a:    The
    1b:    quick
    1c:    brown
    2a:    fox
    2b:    jumps
    2c:    over
    3a:    the
    3b:    lazy
    3c:    dog

After removing "lazy":
    -KEY-    -VALUE-
    1a:    The
    1b:    quick
    1c:    brown
    2a:    fox
    2b:    jumps
    2c:    over
    3a:    the
    3c:    dog

After removing the element at index 5:
    -KEY-    -VALUE-
    1a:    The
    1b:    quick
    1c:    brown
    2a:    fox
    2b:    jumps
    3a:    the
    3c:    dog
*/

Imports System.Collections

Public Class SamplesSortedList    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new SortedList.
        Dim mySL As New SortedList()
        mySL.Add("3c", "dog")
        mySL.Add("2c", "over")
        mySL.Add("1c", "brown")
        mySL.Add("1a", "The")
        mySL.Add("1b", "quick")
        mySL.Add("3a", "the")
        mySL.Add("3b", "lazy")
        mySL.Add("2a", "fox")
        mySL.Add("2b", "jumps")
        
        ' Displays the SortedList.
        Console.WriteLine("The SortedList initially contains the following:")
        PrintKeysAndValues(mySL)
        
        ' Removes the element with the key "3b".
        mySL.Remove("3b")
        
        ' Displays the current state of the SortedList.
        Console.WriteLine("After removing ""lazy"":")
        PrintKeysAndValues(mySL)
        
        ' Removes the element at index 5.
        mySL.RemoveAt(5)
        
        ' Displays the current state of the SortedList.
        Console.WriteLine("After removing the element at index 5:")
        PrintKeysAndValues(mySL)
    End Sub
    
    
    Public Shared Sub PrintKeysAndValues(myList As SortedList)
        Console.WriteLine(ControlChars.Tab & "-KEY-" & ControlChars.Tab & _
           "-VALUE-")
        Dim i As Integer
        For i = 0 To myList.Count - 1
            Console.WriteLine(ControlChars.Tab & "{0}:" & ControlChars.Tab & _
               "{1}", myList.GetKey(i), myList.GetByIndex(i))
        Next i
        Console.WriteLine()
    End Sub
End Class

' This code produces the following output.
' 
' The SortedList initially contains the following:
'     -KEY-    -VALUE-
'     1a:    The
'     1b:    quick
'     1c:    brown
'     2a:    fox
'     2b:    jumps
'     2c:    over
'     3a:    the
'     3b:    lazy
'     3c:    dog
' 
' After removing "lazy":
'     -KEY-    -VALUE-
'     1a:    The
'     1b:    quick
'     1c:    brown
'     2a:    fox
'     2b:    jumps
'     2c:    over
'     3a:    the
'     3c:    dog
' 
' After removing the element at index 5:
'     -KEY-    -VALUE-
'     1a:    The
'     1b:    quick
'     1c:    brown
'     2a:    fox
'     2b:    jumps
'     3a:    the
'     3c:    dog

Comentários

A sequência de índice é baseada na sequência de classificação. Quando um elemento é adicionado, ele é inserido SortedList na ordem de classificação correta e a indexação é ajustada adequadamente. Quando um elemento é removido, a indexação também se ajusta adequadamente. Portanto, o índice de um par chave/valor específico pode mudar conforme os elementos são adicionados ou removidos do SortedList objeto.

Em coleções de elementos contíguos, como listas, os elementos que seguem o elemento removido sobem para ocupar o ponto vazio. Caso a coleção seja indexada, os índices dos elementos que são movidos também são atualizados. Este comportamento não se aplica às coleções em que elementos sejam agrupados conceitualmente em buckets, como uma tabela de hash.

Esse método é uma O(n) operação, em que n é Count.

Aplica-se a

Confira também

Remove(Object)

Compartilhar via