List<T>.FindIndex Método

Definição

Espaço de Nomes:: System.Collections.Generic

Assemblagens:: mscorlib.dll, System.Collections.dll

Assemblagem:: mscorlib.dll

Assemblagem:: System.Collections.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

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

Sobrecargas

Name	Description
FindIndex(Predicate<T>)	Procura um elemento que corresponda às condições definidas pelo predicado especificado e devolve o índice base zero da primeira ocorrência dentro de todo List<T>o .
FindIndex(Int32, Predicate<T>)	Procura um elemento que corresponda às condições definidas pelo predicado especificado, e devolve o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos em que List<T> se estende do índice especificado até ao último elemento.
FindIndex(Int32, Int32, Predicate<T>)	Procura 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 em que List<T> começa no índice especificado e contém o número especificado de elementos.

FindIndex(Predicate<T>)

Procura um elemento que corresponda às condições definidas pelo predicado especificado e devolve o índice base zero da primeira ocorrência dentro de todo List<T>o .

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 Predicate<T> delegado que define as condições do elemento a procurar.

Devoluções

Int32

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

Exceções

ArgumentNullException

match é null.

Exemplos

O exemplo seguinte define uma Employee classe com dois corpos, Name e Id. Também define uma EmployeeSearch classe com um único método, StartsWith, que indica se o Employee.Name corpo começa com uma substring especificada que é fornecida ao EmployeeSearch construtor da classe. Note a assinatura deste método

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde à assinatura do delegado que pode ser passada ao FindIndex método. O exemplo instancia um List<Employee> objeto, adiciona-lhe vários Employee objetos e depois chama o FindIndex(Int32, Int32, Predicate<T>) método duas vezes para pesquisar em toda a coleção, a primeira para o primeiro Employee objeto cujo Name campo começa por "J" e a segunda para o primeiro Employee objeto cujo Name campo começa por "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(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

Observações

É List<T> procurado para a frente começando pelo primeiro elemento e terminando no último elemento.

O Predicate<T> é um delegado a um método que retorna true se o objeto passado corresponder às condições definidas no delegado. Os elementos da corrente List<T> são entregues individualmente ao Predicate<T> delegado. O delegado tem a assinatura:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Este método realiza uma pesquisa linear; portanto, este método é uma operação O(n), onde n é Count.

Ver também

Aplica-se a

FindIndex(Int32, Predicate<T>)

Procura um elemento que corresponda às condições definidas pelo predicado especificado, e devolve o índice baseado em zero da primeira ocorrência dentro do intervalo de elementos em que List<T> se estende do índice especificado até 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 baseado em zero da pesquisa.

match: Predicate<T>

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

Devoluções

Int32

O índice baseado em zero da primeira ocorrência de um elemento que corresponde às condições definidas por match, se 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 ao FindIndex método. O exemplo instancia um List<Employee> objeto, adiciona-lhe vários Employee objetos e depois chama o FindIndex(Int32, Int32, Predicate<T>) método duas vezes para pesquisar a coleção começando pelo seu quinto membro (ou seja, o membro no índice 4). Na primeira vez, procura o primeiro Employee objeto cujo Name campo começa por "J"; na segunda vez, procura o primeiro Employee objeto cujo Name campo começa por "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

Observações

A List<T> procura para a frente começando e startIndex terminando no último elemento.

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Este método realiza uma pesquisa linear; portanto, este método é uma operação O(n), onde n é o número de elementos de startIndex até ao fim do List<T>.

Ver também

Aplica-se a

FindIndex(Int32, Int32, Predicate<T>)

Procura 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 em que List<T> começa no índice especificado e contém o número especificado de elementos.

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 baseado em zero da pesquisa.

count: Int32

O número de elementos na secção a pesquisar.

match: Predicate<T>

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

Devoluções

Int32

O índice baseado em zero da primeira ocorrência de um elemento que corresponde às condições definidas por match, se 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 é inferior a 0.

-ou-

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

Exemplos

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

corresponde à assinatura do delegado que pode ser passada ao FindIndex método. O exemplo instancia um List<Employee> objeto, adiciona-lhe vários Employee objetos e depois chama o FindIndex(Int32, Int32, Predicate<T>) método duas vezes para pesquisar em toda a coleção (isto é, os membros do índice 0 ao índice Count - 1). Na primeira vez, procura o primeiro Employee objeto cujo Name campo começa por "J"; na segunda vez, procura o primeiro Employee objeto cujo Name campo começa por "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

Observações

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

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Este método realiza uma pesquisa linear; portanto, este método é uma operação O(n), onde n é count.

Ver também

Aplica-se a

Comentários

Esta página foi útil?