List<T>.FindIndex Método

Definição

Namespace:

System.Collections.Generic

Assembly:

System.Collections.dll

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

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.

C#

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

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

C#

public bool StartsWith(Employee e)

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".

C#

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

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:

C#

public bool methodName(T obj)

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

Confira também

• Exists(Predicate<T>)
• Find(Predicate<T>)
• FindLast(Predicate<T>)
• FindAll(Predicate<T>)
• FindLastIndex
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>

FindIndex(Predicate<T>)

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>.

C#

public int FindIndex (Predicate<T> match);

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

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

C#

public bool StartsWith(Employee e)

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".

C#

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

Comentários

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

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:

C#

public bool methodName(T obj)

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

Confira também

• Exists(Predicate<T>)
• Find(Predicate<T>)
• FindLast(Predicate<T>)
• FindAll(Predicate<T>)
• FindLastIndex
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>

FindIndex(Int32, Predicate<T>)

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.

C#

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

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

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

C#

public bool StartsWith(Employee e)

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".

C#

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

Comentários

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

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:

C#

public bool methodName(T obj)

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

• Exists(Predicate<T>)
• Find(Predicate<T>)
• FindLast(Predicate<T>)
• FindAll(Predicate<T>)
• FindLastIndex
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>