List<T>.FindIndex 方法

定义

搜索与指定谓词所定义的条件相匹配的元素,返回 List<T> 或它的一部分中第一个匹配项的从零开始的索引。Searches for an element that matches the conditions defined by a specified predicate, and returns the zero-based index of the first occurrence within the List<T> or a portion of it. 如果未找到与条件匹配的项,则此方法返回 -1。This method returns -1 if an item that matches the conditions is not found.

重载

FindIndex(Predicate<T>)

搜索与指定谓词所定义的条件相匹配的元素,并返回整个 List<T> 中第一个匹配元素的从零开始的索引。Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire List<T>.

FindIndex(Int32, Predicate<T>)

搜索与指定谓词所定义的条件相匹配的元素,并返回 List<T> 中从指定索引到最后一个元素的元素范围内第一个匹配项的从零开始的索引。Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that extends from the specified index to the last element.

FindIndex(Int32, Int32, Predicate<T>)

搜索与指定谓词所定义的条件相匹配的一个元素,并返回 List<T> 中从指定的索引开始、包含指定元素个数的元素范围内第一个匹配项的从零开始的索引。Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that starts at the specified index and contains the specified number of elements.

FindIndex(Predicate<T>)

搜索与指定谓词所定义的条件相匹配的元素,并返回整个 List<T> 中第一个匹配元素的从零开始的索引。Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the entire 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

参数

match
Predicate<T>

Predicate<T> 委托,用于定义要搜索的元素的条件。The Predicate<T> delegate that defines the conditions of the element to search for.

返回

如果找到与 match 定义的条件相匹配的第一个元素,则为该元素的从零开始的索引;否则为 -1。The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, -1.

例外

matchnullmatch is null.

示例

下面的示例定义了一个具有两个字段的 Employee 类: NameIdThe following example defines an Employee class with two fields, Name and Id. 它还使用单个方法(StartsWith)定义一个 EmployeeSearch 类,该方法指示 Employee.Name 字段是否以提供给 EmployeeSearch 类构造函数的指定子字符串开头。It also defines an EmployeeSearch class with a single method, StartsWith, that indicates whether the Employee.Name field starts with a specified substring that is supplied to the EmployeeSearch class constructor. 记下此方法的签名Note the signature of this method

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

对应于可传递到 FindIndex 方法的委托签名。corresponds to the signature of the delegate that can be passed to the FindIndex method. 该示例实例化一个 List<Employee> 对象、向其中添加多个 Employee 对象,然后调用 FindIndex(Int32, Int32, Predicate<T>) 方法两次以搜索整个集合,第一次是第一个 Employee 对象(其 Name 字段以 "J" 开头),第二次第一个 Employee 对象的 Name 字段以 "Ju" 开头。The example instantiates a List<Employee> object, adds a number of Employee objects to it, and then calls the FindIndex(Int32, Int32, Predicate<T>) method twice to search the entire collection, the first time for the first Employee object whose Name field begins with "J", and the second time for the first Employee object whose Name field begins with "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

注解

将从第一个元素开始向前搜索 List<T>,并在最后一个元素结束。The List<T> is searched forward starting at the first element and ending at the last element.

Predicate<T> 是一个方法委托,如果传递给它的对象与委托中定义的条件相匹配,则该方法将返回 trueThe Predicate<T> is a delegate to a method that returns true if the object passed to it matches the conditions defined in the delegate. 当前 List<T> 的元素分别传递到 Predicate<T> 委托。The elements of the current List<T> are individually passed to the Predicate<T> delegate. 委托具有签名:The delegate has the signature:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

此方法执行线性搜索;因此,此方法的运算复杂度为 O (n),其中nCountThis method performs a linear search; therefore, this method is an O(n) operation, where n is Count.

另请参阅

FindIndex(Int32, Predicate<T>)

搜索与指定谓词所定义的条件相匹配的元素,并返回 List<T> 中从指定索引到最后一个元素的元素范围内第一个匹配项的从零开始的索引。Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that extends from the specified index to the last element.

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

参数

startIndex
Int32

从零开始的搜索的起始索引。The zero-based starting index of the search.

match
Predicate<T>

Predicate<T> 委托,用于定义要搜索的元素的条件。The Predicate<T> delegate that defines the conditions of the element to search for.

返回

如果找到与 match 定义的条件相匹配的第一个元素,则为该元素的从零开始的索引;否则为 -1。The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, -1.

例外

matchnullmatch is null.

startIndex 超出了 List<T> 的有效索引范围。startIndex is outside the range of valid indexes for the List<T>.

示例

下面的示例定义了一个具有两个字段的 Employee 类: NameIdThe following example defines an Employee class with two fields, Name and Id. 它还使用单个方法(StartsWith)定义一个 EmployeeSearch 类,该方法指示 Employee.Name 字段是否以提供给 EmployeeSearch 类构造函数的指定子字符串开头。It also defines an EmployeeSearch class with a single method, StartsWith, that indicates whether the Employee.Name field starts with a specified substring that is supplied to the EmployeeSearch class constructor. 记下此方法的签名Note the signature of this method

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

对应于可传递到 FindIndex 方法的委托签名。corresponds to the signature of the delegate that can be passed to the FindIndex method. 该示例实例化一个 List<Employee> 对象,向其中添加多个 Employee 对象,然后调用 FindIndex(Int32, Int32, Predicate<T>) 方法两次,以从第五个成员(即索引4处的成员)开始搜索集合。The example instantiates a List<Employee> object, adds a number of Employee objects to it, and then calls the FindIndex(Int32, Int32, Predicate<T>) method twice to search the collection starting with its fifth member (that is, the member at index 4). 第一次,它会搜索其 Name 字段以 "J" 开头的第一个 Employee 对象;第二次搜索时,将搜索第一个 Employee 对象,该对象的 Name 字段以 "Ju" 开头。The first time, it searches for the first Employee object whose Name field begins with "J"; the second time, it searches for the first Employee object whose Name field begins with "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

注解

将从 startIndex 开始向前搜索 List<T>,并在最后一个元素结束。The List<T> is searched forward starting at startIndex and ending at the last element.

Predicate<T> 是一个方法委托,如果传递给它的对象与委托中定义的条件相匹配,则该方法将返回 trueThe Predicate<T> is a delegate to a method that returns true if the object passed to it matches the conditions defined in the delegate. 当前 List<T> 的元素分别传递到 Predicate<T> 委托。The elements of the current List<T> are individually passed to the Predicate<T> delegate. 委托具有签名:The delegate has the signature:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

此方法执行线性搜索;因此,此方法的运算复杂度为 O (n),其中n是从 startIndexList<T>末尾的元素数。This method performs a linear search; therefore, this method is an O(n) operation, where n is the number of elements from startIndex to the end of the List<T>.

另请参阅

FindIndex(Int32, Int32, Predicate<T>)

搜索与指定谓词所定义的条件相匹配的一个元素,并返回 List<T> 中从指定的索引开始、包含指定元素个数的元素范围内第一个匹配项的从零开始的索引。Searches for an element that matches the conditions defined by the specified predicate, and returns the zero-based index of the first occurrence within the range of elements in the List<T> that starts at the specified index and contains the specified number of elements.

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

参数

startIndex
Int32

从零开始的搜索的起始索引。The zero-based starting index of the search.

count
Int32

要搜索的部分中的元素数。The number of elements in the section to search.

match
Predicate<T>

Predicate<T> 委托,用于定义要搜索的元素的条件。The Predicate<T> delegate that defines the conditions of the element to search for.

返回

如果找到与 match 定义的条件相匹配的第一个元素,则为该元素的从零开始的索引;否则为 -1。The zero-based index of the first occurrence of an element that matches the conditions defined by match, if found; otherwise, -1.

例外

matchnullmatch is null.

startIndex 超出了 List<T> 的有效索引范围。startIndex is outside the range of valid indexes for the List<T>.

-或--or- count 小于 0。count is less than 0.

-或--or- startIndexcount 未在 List<T> 中指定有效部分。startIndex and count do not specify a valid section in the List<T>.

示例

下面的示例定义了一个具有两个字段的 Employee 类: NameIdThe following example defines an Employee class with two fields, Name and Id. 它还使用单个方法(StartsWith)定义一个 EmployeeSearch 类,该方法指示 Employee.Name 字段是否以提供给 EmployeeSearch 类构造函数的指定子字符串开头。It also defines an EmployeeSearch class with a single method, StartsWith, that indicates whether the Employee.Name field starts with a specified substring that is supplied to the EmployeeSearch class constructor. 记下此方法的签名Note the signature of this method

public bool StartsWith(Employee e)  
Public Function StartsWith(e As Employee) As Boolean  

对应于可传递到 FindIndex 方法的委托签名。corresponds to the signature of the delegate that can be passed to the FindIndex method. 该示例实例化一个 List<Employee> 对象,向其中添加多个 Employee 对象,然后调用 FindIndex(Int32, Int32, Predicate<T>) 方法两次以搜索整个集合(即从索引0到索引 Count-1 的成员)。The example instantiates a List<Employee> object, adds a number of Employee objects to it, and then calls the FindIndex(Int32, Int32, Predicate<T>) method twice to search the entire collection (that is, the members from index 0 to index Count - 1). 第一次,它会搜索其 Name 字段以 "J" 开头的第一个 Employee 对象;第二次搜索时,将搜索第一个 Employee 对象,该对象的 Name 字段以 "Ju" 开头。The first time, it searches for the first Employee object whose Name field begins with "J"; the second time, it searches for the first Employee object whose Name field begins with "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

注解

如果 count 大于0,则从 startIndex 开始向前搜索 List<T>,在 startIndex count 减1处结束。The List<T> is searched forward starting at startIndex and ending at startIndex plus count minus 1, if count is greater than 0.

Predicate<T> 是一个方法委托,如果传递给它的对象与委托中定义的条件相匹配,则该方法将返回 trueThe Predicate<T> is a delegate to a method that returns true if the object passed to it matches the conditions defined in the delegate. 当前 List<T> 的元素分别传递到 Predicate<T> 委托。The elements of the current List<T> are individually passed to the Predicate<T> delegate. 委托具有签名:The delegate has the signature:

public bool methodName(T obj)  
Public Function methodName(obj As T) As Boolean  

此方法执行线性搜索;因此,此方法的运算复杂度为 O (n),其中ncountThis method performs a linear search; therefore, this method is an O(n) operation, where n is count.

另请参阅

适用于