List<T>.FindIndex Método

Referência

Definição

Namespace:: System.Collections.Generic

Assembly:: System.Collections.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.

Pesquisa um elemento que corresponda às condições definidas por um predicado especificado e retorna o índice baseado em zero da primeira ocorrência no List<T> ou parte dele. Esse método retornará -1 se não for encontrado um item que corresponda às condições.

Sobrecargas

FindIndex(Int32, Int32, Predicate<T>)	Pesquisa um elemento que coincida com as condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos na List<T> que começa no índice especificado e contém o número de elementos especificado.
FindIndex(Predicate<T>)	Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência em toda a List<T>.
FindIndex(Int32, Predicate<T>)	Pesquisa um elemento que corresponda às condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos no List<T> que se estende do índice especificado ao último elemento.

FindIndex(Int32, Int32, Predicate<T>)

Origem:: List.cs

Origem:: List.cs

Origem:: List.cs

Pesquisa um elemento que coincida com as condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos na List<T> que começa no índice especificado e contém o número de elementos especificado.

public:
 int FindIndex(int startIndex, int count, Predicate<T> ^ match);

public int FindIndex (int startIndex, int count, Predicate<T> match);

member this.FindIndex : int * int * Predicate<'T> -> int

Public Function FindIndex (startIndex As Integer, count As Integer, match As Predicate(Of T)) As Integer

Parâmetros

startIndex: Int32

O índice inicial com base em zero da pesquisa.

count: Int32

O número de elementos na seção a ser pesquisada.

match: Predicate<T>

O delegado Predicate<T> que define as condições do elemento a ser pesquisado.

Retornos

Int32

O índice baseado em zero da primeira ocorrência de um elemento que corresponde às condições definidas por match, se for encontrado; caso contrário, -1.

Exceções

ArgumentNullException

match é null.

ArgumentOutOfRangeException

startIndex está fora do intervalo de índices válidos para o List<T>.

- ou -

count é menor que 0.

- ou -

startIndex e count não especificam uma seção válida no List<T>.

Exemplos

O exemplo a seguir define uma Employee classe com dois campos, Name e Id. Ele também define uma EmployeeSearch classe com um único método, StartsWith, que indica se o Employee.Name campo começa com uma subcadeia de caracteres especificada que é fornecida ao construtor de EmployeeSearch classe. Observe a assinatura desse método

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde à assinatura do delegado que pode ser passada para o FindIndex método . O exemplo cria uma instância de Employee um List<Employee> objeto, adiciona vários objetos a ele e chama o FindIndex(Int32, Int32, Predicate<T>) método duas vezes para pesquisar a coleção inteira (ou seja, os membros do índice 0 para o índice Count - 1). Na primeira vez, ele procura o primeiro Employee objeto cujo Name campo começa com "J"; na segunda vez, ele procura o primeiro Employee objeto cujo Name campo começa com "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1, es.StartsWith));

      es = new EmployeeSearch("Ju");
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,es.StartsWith));
   }
}
// The example displays the following output:
//       'J' starts at index 3
//       'Ju' starts at index 5

Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,
                                            AddressOf es.StartsWith))
      es = New EmployeeSearch("Ju")
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(0, employees.Count - 1,
                                            AddressOf es.StartsWith))
   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 3
'       'Ju' starts at index 5

Comentários

O List<T> é pesquisado para frente começando em startIndex e terminando em startIndex mais count menos 1, se count for maior que 0.

O Predicate<T> é um representante para um método que retorna true caso o objeto passado para ele corresponda às condições definidas no representante. Os elementos do atual List<T> são passados individualmente para o Predicate<T> delegado. O delegado tem a assinatura:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Esse método executa uma pesquisa linear; portanto, esse método é uma operação O(n), em que n é count.

Confira também

Aplica-se a

FindIndex(Predicate<T>)

Origem:: List.cs

Origem:: List.cs

Origem:: List.cs

Pesquisa um elemento que corresponde às condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência em toda a List<T>.

public:
 int FindIndex(Predicate<T> ^ match);

public int FindIndex (Predicate<T> match);

member this.FindIndex : Predicate<'T> -> int

Public Function FindIndex (match As Predicate(Of T)) As Integer

Parâmetros

match: Predicate<T>

O delegado Predicate<T> que define as condições do elemento a ser pesquisado.

Retornos

Int32

O índice baseado em zero da primeira ocorrência de um elemento que corresponde às condições definidas por match, se for encontrado; caso contrário, -1.

Exceções

ArgumentNullException

match é null.

Exemplos

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde à assinatura do delegado que pode ser passada para o FindIndex método . O exemplo cria uma instância de um List<Employee> objeto, adiciona vários objetos a ele e chama o FindIndex(Int32, Int32, Predicate<T>) método duas vezes para pesquisar toda a coleção, a primeira vez para o primeiro Employee objeto cujo Name campo começa com "J" e a segunda vez para o primeiro Employee objeto cujo Name campo começa com "JuEmployee".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(es.StartsWith));

      es = new EmployeeSearch("Ju");
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(es.StartsWith));
   }
}
// The example displays the following output:
//       'J' starts at index 3
//       'Ju' starts at index 5

Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Console.WriteLine("'J' starts at index {0}",
                        employees.FindIndex(AddressOf es.StartsWith))
      es = New EmployeeSearch("Ju")
      Console.WriteLine("'Ju' starts at index {0}",
                        employees.FindIndex(AddressOf es.StartsWith))
   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 3
'       'Ju' starts at index 5

Comentários

O List<T> é pesquisado para frente começando no primeiro elemento e terminando no último elemento.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Esse método executa uma pesquisa linear; portanto, esse método é uma operação O(n), em que n é Count.

Confira também

Aplica-se a

FindIndex(Int32, Predicate<T>)

Origem:: List.cs

Origem:: List.cs

Origem:: List.cs

Pesquisa um elemento que corresponda às condições definidas pelo predicado especificado e retorna o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos no List<T> que se estende do índice especificado ao último elemento.

public:
 int FindIndex(int startIndex, Predicate<T> ^ match);

public int FindIndex (int startIndex, Predicate<T> match);

member this.FindIndex : int * Predicate<'T> -> int

Public Function FindIndex (startIndex As Integer, match As Predicate(Of T)) As Integer

Parâmetros

startIndex: Int32

O índice inicial com base em zero da pesquisa.

match: Predicate<T>

O delegado Predicate<T> que define as condições do elemento a ser pesquisado.

Retornos

Int32

O índice baseado em zero da primeira ocorrência de um elemento que corresponde às condições definidas por match, se for encontrado; caso contrário, -1.

Exceções

ArgumentNullException

match é null.

ArgumentOutOfRangeException

startIndex está fora do intervalo de índices válidos para o List<T>.

Exemplos

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde à assinatura do delegado que pode ser passada para o FindIndex método . O exemplo cria uma instância de Employee um List<Employee> objeto, adiciona vários objetos a ele e chama o FindIndex(Int32, Int32, Predicate<T>) método duas vezes para pesquisar a coleção começando com seu quinto membro (ou seja, o membro no índice 4). Na primeira vez, ele procura o primeiro Employee objeto cujo Name campo começa com "J"; na segunda vez, ele procura o primeiro Employee objeto cujo Name campo começa com "Ju".

using System;
using System.Collections.Generic;

public class Employee : IComparable
{
   public String Name { get; set; }
   public int Id { get; set; }

   public int CompareTo(Object o )
   {
      Employee e = o as Employee;
      if (e == null)
         throw new ArgumentException("o is not an Employee object.");

      return Name.CompareTo(e.Name);
   }
}

public class EmployeeSearch
{
   String _s;

   public EmployeeSearch(String s)
   {
      _s = s;
   }

   public bool StartsWith(Employee e)
   {
      return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase);
   }
}

public class Example
{
   public static void Main()
   {
      var employees = new List<Employee>();
      employees.AddRange( new Employee[] { new Employee { Name = "Frank", Id = 2 },
                                           new Employee { Name = "Jill", Id = 3 },
                                           new Employee { Name = "Dave", Id = 5 },
                                           new Employee { Name = "Jack", Id = 8 },
                                           new Employee { Name = "Judith", Id = 12 },
                                           new Employee { Name = "Robert", Id = 14 },
                                           new Employee { Name = "Adam", Id = 1 } } );
      employees.Sort();

      var es = new EmployeeSearch("J");
      int index = employees.FindIndex(4, es.StartsWith);
      Console.WriteLine("Starting index of'J': {0}",
                        index >= 0 ? index.ToString() : "Not found");

      es = new EmployeeSearch("Ju");
      index = employees.FindIndex(4, es.StartsWith);
      Console.WriteLine("Starting index of 'Ju': {0}",
                        index >= 0 ? index.ToString() : "Not found");
   }
}
// The example displays the following output:
//       'J' starts at index 4
//       'Ju' starts at index 5

Imports System.Collections.Generic

Public Class Employee : Implements IComparable
   Public Property Name As String
   Public Property Id As Integer
   
   Public Function CompareTo(o As Object) As Integer _
         Implements IComparable.CompareTo
      Dim e As Employee = TryCast(o, Employee)
      If e Is Nothing Then
         Throw New ArgumentException("o is not an Employee object.")
      End If

      Return Name.CompareTo(e.Name)
   End Function
End Class

Public Class EmployeeSearch
   Dim _s As String
   
   Public Sub New(s As String)
      _s = s
   End Sub
   
   Public Function StartsWith(e As Employee) As Boolean
      Return e.Name.StartsWith(_s, StringComparison.InvariantCultureIgnoreCase)
   End Function
End Class

Module Example
   Public Sub Main()
      Dim employees As New List(Of Employee)()
      employees.AddRange( { New Employee() With { .Name = "Frank", .Id = 2 },
                            New Employee() With { .Name = "Jill", .Id = 3 },
                            New Employee() With { .Name = "Dave", .Id = 5 },
                            New Employee() With { .Name = "Jack", .Id = 8 },
                            New Employee() With { .Name = "Judith", .Id = 12 },
                            New Employee() With { .Name = "Robert", .Id = 14 },
                            New Employee() With { .Name = "Adam", .Id = 1 } } )
      employees.Sort()

      Dim es As New EmployeeSearch("J")
      Dim index As Integer = employees.FindIndex(4, AddressOf es.StartsWith)        
      Console.WriteLine("Starting index of'J': {0}",
                        If(index >= 0, index.ToString(), "Not found"))

      es = New EmployeeSearch("Ju")
      index = employees.FindIndex(4, AddressOf es.StartsWith) 
      Console.WriteLine("Starting index of'Ju': {0}",
                        If(index >= 0, index.ToString(), "Not found"))

   End Sub
End Module
' The example displays the following output:
'       'J' starts at index 4
'       'Ju' starts at index 5

Comentários

O List<T> é pesquisado para frente começando em startIndex e terminando no último elemento.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Esse método executa uma pesquisa linear; portanto, esse método é uma operação O(n), em que n é o número de elementos de startIndex até o final do List<T>.

Confira também

Aplica-se a

Partilhar via

List<T>.FindIndex Método

Definição

Sobrecargas

FindIndex(Int32, Int32, Predicate<T>)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

FindIndex(Predicate<T>)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

FindIndex(Int32, Predicate<T>)

Parâmetros

Retornos

Exceções

Exemplos

Comentários

Confira também

Aplica-se a

Recursos adicionais