ArrayList.BinarySearch Método

Referência

Definição

Namespace:: System.Collections

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

Assembly:: System.Runtime.dll

Assembly:: System.Collections.NonGeneric.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

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.

Usa um algoritmo de pesquisa binária para localizar um elemento específico no ArrayList classificado ou parte dele.

Sobrecargas

BinarySearch(Object)	Pesquisa todo o ArrayList classificado para um elemento usando o comparador padrão e retorna o índice baseado em zero do elemento.
BinarySearch(Object, IComparer)	Pesquisa um elemento em todo o ArrayList classificado usando o comparador especificado e retorna o índice baseado em zero do elemento.
BinarySearch(Int32, Int32, Object, IComparer)	Pesquisa um intervalo de elementos no ArrayList classificado para encontrar um elemento que usa o comparador especificado e retorna o índice baseado em zero do elemento.

BinarySearch(Object)

Origem:: ArrayList.cs

Origem:: ArrayList.cs

Origem:: ArrayList.cs

Pesquisa todo o ArrayList classificado para um elemento usando o comparador padrão e retorna o índice baseado em zero do elemento.

public:
 virtual int BinarySearch(System::Object ^ value);

public virtual int BinarySearch (object value);

public virtual int BinarySearch (object? value);

abstract member BinarySearch : obj -> int
override this.BinarySearch : obj -> int

Public Overridable Function BinarySearch (value As Object) As Integer

Parâmetros

value: Object

O Object a ser localizado. O valor pode ser null.

Retornos

Int32

O índice baseado em zero da value no ArrayList classificado se value for encontrado; caso contrário, um número negativo, que é o complemento bit a bit do índice do próximo elemento maior que value ou, se não houver nenhum elemento maior, o complemento bit a bit de Count.

Exceções

ArgumentException

Nem value nem os elementos de ArrayList implementam a interface IComparable.

InvalidOperationException

value não é do mesmo tipo que os elementos do ArrayList.

Exemplos

O exemplo de código a seguir mostra como usar BinarySearch para localizar um objeto específico no ArrayList.

using namespace System;
using namespace System::Collections;
void FindMyObject( ArrayList^ myList, Object^ myObject );
void PrintValues( IEnumerable^ myList );
int main()
{
   
   // Creates and initializes a new ArrayList. BinarySearch requires
   // a sorted ArrayList.
   ArrayList^ myAL = gcnew ArrayList;
   for ( int i = 0; i <= 4; i++ )
      myAL->Add( i * 2 );
   
   // Displays the ArrayList.
   Console::WriteLine( "The Int32 ArrayList contains the following:" );
   PrintValues( myAL );
   
   // Locates a specific object that does not exist in the ArrayList.
   Object^ myObjectOdd = 3;
   FindMyObject( myAL, myObjectOdd );
   
   // Locates an object that exists in the ArrayList.
   Object^ myObjectEven = 6;
   FindMyObject( myAL, myObjectEven );
}

void FindMyObject( ArrayList^ myList, Object^ myObject )
{
   int myIndex = myList->BinarySearch( myObject );
   if ( myIndex < 0 )
      Console::WriteLine( "The object to search for ({0}) is not found. The next larger object is at index {1}.", myObject,  ~myIndex );
   else
      Console::WriteLine( "The object to search for ({0}) is at index {1}.", myObject, myIndex );
}

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 Int32 ArrayList contains the following:
    0   2   4   6   8
 The object to search for (3) is not found. The next larger object is at index 2.
 The object to search for (6) is at index 3.
 */

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

   public static void Main()  {

      // Creates and initializes a new ArrayList. BinarySearch requires
      // a sorted ArrayList.
      ArrayList myAL = new ArrayList();
      for ( int i = 0; i <= 4; i++ )
         myAL.Add( i*2 );

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

      // Locates a specific object that does not exist in the ArrayList.
      Object myObjectOdd = 3;
      FindMyObject( myAL, myObjectOdd );

      // Locates an object that exists in the ArrayList.
      Object myObjectEven = 6;
      FindMyObject( myAL, myObjectEven );
   }

   public static void FindMyObject( ArrayList myList, Object myObject )  {
      int myIndex=myList.BinarySearch( myObject );
      if ( myIndex < 0 )
         Console.WriteLine( "The object to search for ({0}) is not found. The next larger object is at index {1}.", myObject, ~myIndex );
      else
         Console.WriteLine( "The object to search for ({0}) is at index {1}.", myObject, myIndex );
   }

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

The int ArrayList contains the following:
   0   2   4   6   8
The object to search for (3) is not found. The next larger object is at index 2.
The object to search for (6) is at index 3.
*/

Imports System.Collections

Public Class SamplesArrayList    
    
    Public Shared Sub Main()
        
        ' Creates and initializes a new ArrayList. BinarySearch requires
        ' a sorted ArrayList.
        Dim myAL As New ArrayList()
        Dim i As Integer
        For i = 0 To 4
            myAL.Add(i * 2)
        Next i 

        ' Displays the ArrayList.
        Console.WriteLine("The Int32 ArrayList contains the following:")
        PrintValues(myAL)
        
        ' Locates a specific object that does not exist in the ArrayList.
        Dim myObjectOdd As Object = 3
        FindMyObject(myAL, myObjectOdd)
        
        ' Locates an object that exists in the ArrayList.
        Dim myObjectEven As Object = 6
        FindMyObject(myAL, myObjectEven)
    End Sub    
    
    Public Shared Sub FindMyObject(myList As ArrayList, myObject As Object)
        Dim myIndex As Integer = myList.BinarySearch(myObject)
        If myIndex < 0 Then
            Console.WriteLine("The object to search for ({0}) is not found. " _
               + "The next larger object is at index {1}.", myObject, _
               Not myIndex)
        Else
            Console.WriteLine("The object to search for ({0}) is at index " _
               + "{1}.", myObject, myIndex)
        End If
    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 Int32 ArrayList contains the following:
'     0    2    4    6    8
' The object to search for (3) is not found. The next larger object is at index 2.
' The object to search for (6) is at index 3.

Comentários

O value parâmetro e cada elemento do ArrayList devem implementar a IComparable interface , que é usada para comparações. Os elementos do ArrayList já devem ser classificados em valor crescente de acordo com a ordem de classificação definida pela IComparable implementação; caso contrário, o resultado pode estar incorreto.

A comparação null com qualquer tipo é permitida e não gera uma exceção ao usar IComparable. Durante a classificação, null é considerado menor que qualquer outro objeto.

Se o ArrayList contiver mais de um elemento com o mesmo valor, o método retornará apenas uma das ocorrências e poderá retornar qualquer uma das ocorrências, não necessariamente a primeira.

Caso o ArrayList não contenha o valor especificado, o método retorna um inteiro negativo. Você pode aplicar a operação de complemento bit a bit (~) a esse inteiro negativo para obter o índice do primeiro elemento maior que o valor de pesquisa. Ao inserir o valor no ArrayList, esse índice deve ser usado como o ponto de inserção para manter a ordem de classificação.

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

Confira também

Executando operações de cadeia de caracteres Culture-Insensitive em coleções

Aplica-se a

BinarySearch(Object, IComparer)

Origem:: ArrayList.cs

Origem:: ArrayList.cs

Origem:: ArrayList.cs

Pesquisa um elemento em todo o ArrayList classificado usando o comparador especificado e retorna o índice baseado em zero do elemento.

public:
 virtual int BinarySearch(System::Object ^ value, System::Collections::IComparer ^ comparer);

public virtual int BinarySearch (object value, System.Collections.IComparer comparer);

public virtual int BinarySearch (object? value, System.Collections.IComparer? comparer);

abstract member BinarySearch : obj * System.Collections.IComparer -> int
override this.BinarySearch : obj * System.Collections.IComparer -> int

Public Overridable Function BinarySearch (value As Object, comparer As IComparer) As Integer

Parâmetros

value: Object

O Object a ser localizado. O valor pode ser null.

comparer: IComparer

A implementação de IComparer a ser usada durante a comparação de elementos.

- ou -

null para usar o comparador padrão que é a implementação IComparable de cada elemento.

Retornos

Int32

Exceções

ArgumentException

comparer é null e nem value ou os elementos de ArrayList implementam a interface IComparable.

InvalidOperationException

comparer é null e value não é do mesmo tipo que os elementos de ArrayList.

Exemplos

O exemplo a seguir cria um ArrayList de animais coloridos. O fornecido IComparer executa a comparação de cadeia de caracteres para a pesquisa binária. Os resultados de uma pesquisa iterativa e uma pesquisa binária são exibidos.

using namespace System;
using namespace System::Collections;

public ref class SimpleStringComparer : public IComparer
{
    virtual int Compare(Object^ x, Object^ y) sealed = IComparer::Compare
    {
        String^ cmpstr = (String^)x;
        return cmpstr->CompareTo((String^)y);
    }
};

public ref class MyArrayList : public ArrayList
{
public:
    static void Main()
    {
        // Creates and initializes a new ArrayList.
        MyArrayList^ coloredAnimals = gcnew MyArrayList();

        coloredAnimals->Add("White Tiger");
        coloredAnimals->Add("Pink Bunny");
        coloredAnimals->Add("Red Dragon");
        coloredAnimals->Add("Green Frog");
        coloredAnimals->Add("Blue Whale");
        coloredAnimals->Add("Black Cat");
        coloredAnimals->Add("Yellow Lion");

        // BinarySearch requires a sorted ArrayList.
        coloredAnimals->Sort();

        // Compare results of an iterative search with a binary search
        int index = coloredAnimals->IterativeSearch("White Tiger");
        Console::WriteLine("Iterative search, item found at index: {0}", index);

        index = coloredAnimals->BinarySearch("White Tiger", gcnew SimpleStringComparer());
        Console::WriteLine("Binary search, item found at index:    {0}", index);
    }

    int IterativeSearch(Object^ finditem)
    {
        int index = -1;

        for (int i = 0; i < this->Count; i++)
        {
            if (finditem->Equals(this[i]))
            {
                index = i;
                break;
            }
        }
        return index;
    }
};

int main()
{
    MyArrayList::Main();
}
//
// This code produces the following output.
//
// Iterative search, item found at index: 5
// Binary search, item found at index:    5
//

using System;
using System.Collections;

public class SimpleStringComparer : IComparer
{
    int IComparer.Compare(object x, object y)
    {
        string cmpstr = (string)x;
        return cmpstr.CompareTo((string)y);
    }
}

public class MyArrayList : ArrayList
{
    public static void Main()
    {
        // Creates and initializes a new ArrayList.
        MyArrayList coloredAnimals = new MyArrayList();

        coloredAnimals.Add("White Tiger");
        coloredAnimals.Add("Pink Bunny");
        coloredAnimals.Add("Red Dragon");
        coloredAnimals.Add("Green Frog");
        coloredAnimals.Add("Blue Whale");
        coloredAnimals.Add("Black Cat");
        coloredAnimals.Add("Yellow Lion");

        // BinarySearch requires a sorted ArrayList.
        coloredAnimals.Sort();

        // Compare results of an iterative search with a binary search
        int index = coloredAnimals.IterativeSearch("White Tiger");
        Console.WriteLine("Iterative search, item found at index: {0}", index);

        index = coloredAnimals.BinarySearch("White Tiger", new SimpleStringComparer());
        Console.WriteLine("Binary search, item found at index:    {0}", index);
    }

    public int IterativeSearch(object finditem)
    {
        int index = -1;

        for (int i = 0; i < this.Count; i++)
        {
            if (finditem.Equals(this[i]))
            {
                index = i;
                break;
            }
        }
        return index;
    }
}
//
// This code produces the following output.
//
// Iterative search, item found at index: 5
// Binary search, item found at index:    5
//

Imports System.Collections

Public Class SimpleStringComparer
    Implements IComparer

    Function Compare(x As Object, y As Object) As Integer Implements IComparer.Compare
          Dim cmpstr As String = CType(x, String)
          Return cmpstr.CompareTo(CType(y, String))
    End Function
End Class

Public Class MyArrayList
    Inherits ArrayList

    Public Shared Sub Main()
        ' Creates and initializes a new ArrayList.
        Dim coloredAnimals As New MyArrayList()

        coloredAnimals.Add("White Tiger")
        coloredAnimals.Add("Pink Bunny")
        coloredAnimals.Add("Red Dragon")
        coloredAnimals.Add("Green Frog")
        coloredAnimals.Add("Blue Whale")
        coloredAnimals.Add("Black Cat")
        coloredAnimals.Add("Yellow Lion")

        ' BinarySearch requires a sorted ArrayList.
        coloredAnimals.Sort()

        ' Compare results of an iterative search with a binary search
        Dim index As Integer = coloredAnimals.IterativeSearch("White Tiger")
        Console.WriteLine("Iterative search, item found at index: {0}", index)

        index = coloredAnimals.BinarySearch("White Tiger", New SimpleStringComparer())
        Console.WriteLine("Binary search, item found at index:    {0}", index)
    End Sub

    Public Function IterativeSearch(finditem As Object) As Integer
        Dim index As Integer = -1

        For i As Integer = 0 To MyClass.Count - 1
            If finditem.Equals(MyClass.Item(i))
                index = i
                Exit For
            End If
        Next i
        Return index
    End Function
End Class
'
' This code produces the following output.
'
' Iterative search, item found at index: 5
' Binary search, item found at index:    5
'

Comentários

A comparação personaliza como os elementos são comparados. Por exemplo, você pode usar uma CaseInsensitiveComparer instância como comparador para executar pesquisas de cadeia de caracteres que não diferenciam maiúsculas de minúsculas.

Se comparer for fornecido, os elementos do ArrayList serão comparados com o valor especificado usando a implementação especificada IComparer . Os elementos do ArrayList já devem ser classificados em valor crescente de acordo com a ordem de classificação definida por comparer; caso contrário, o resultado pode estar incorreto.

Caso comparer seja null, a comparação é feita usando-se a implementação de IComparable fornecida pelo próprio elemento ou pelo valor especificado. Os elementos do ArrayList já devem ser classificados em valor crescente de acordo com a ordem de classificação definida pela IComparable implementação; caso contrário, o resultado pode estar incorreto.

A comparação null com qualquer tipo é permitida e não gera uma exceção ao usar IComparable. Durante a classificação, null é considerado menor que qualquer outro objeto.

Se o ArrayList contiver mais de um elemento com o mesmo valor, o método retornará apenas uma das ocorrências e poderá retornar qualquer uma das ocorrências, não necessariamente a primeira.

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

Confira também

Executando operações de cadeia de caracteres Culture-Insensitive em coleções

Aplica-se a

BinarySearch(Int32, Int32, Object, IComparer)

Origem:: ArrayList.cs

Origem:: ArrayList.cs

Origem:: ArrayList.cs

Pesquisa um intervalo de elementos no ArrayList classificado para encontrar um elemento que usa o comparador especificado e retorna o índice baseado em zero do elemento.

public:
 virtual int BinarySearch(int index, int count, System::Object ^ value, System::Collections::IComparer ^ comparer);

public virtual int BinarySearch (int index, int count, object value, System.Collections.IComparer comparer);

public virtual int BinarySearch (int index, int count, object? value, System.Collections.IComparer? comparer);

abstract member BinarySearch : int * int * obj * System.Collections.IComparer -> int
override this.BinarySearch : int * int * obj * System.Collections.IComparer -> int

Public Overridable Function BinarySearch (index As Integer, count As Integer, value As Object, comparer As IComparer) As Integer

Parâmetros

index: Int32

O índice baseado em zero inicial do intervalo a ser pesquisado.

count: Int32

O tamanho do intervalo a ser procurado.

value: Object

O Object a ser localizado. O valor pode ser null.

comparer: IComparer

A implementação de IComparer a ser usada durante a comparação de elementos.

- ou -

null para usar o comparador padrão que é a implementação IComparable de cada elemento.

Retornos

Int32

Exceções

ArgumentException

index e count não denotam um intervalo válido em ArrayList.

- ou -

comparer é null e nem value ou os elementos de ArrayList implementam a interface IComparable.

InvalidOperationException

comparer é null e value não é do mesmo tipo que os elementos de ArrayList.

ArgumentOutOfRangeException

index é menor que zero.

- ou -

count é menor que zero.

Comentários

A comparação null com qualquer tipo é permitida e não gera uma exceção ao usar IComparable. Durante a classificação, null é considerado menor que qualquer outro objeto.

Se o ArrayList contiver mais de um elemento com o mesmo valor, o método retornará apenas uma das ocorrências e poderá retornar qualquer uma das ocorrências, não necessariamente a primeira.

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

Confira também

Aplica-se a

ArrayList.BinarySearch Método

Definição

Sobrecargas

BinarySearch(Object)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BinarySearch(Object, IComparer)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

BinarySearch(Int32, Int32, Object, IComparer)

Parâmetros

Retornos

Exceções

Comentários

Confira também

Aplica-se a

Comentários

Recursos adicionais