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.

返回

Int32

如果找到与 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 具有两个字段 Name 和的类 IdThe following example defines an Employee class with two fields, Name and Id. 它还 EmployeeSearch 使用单个方法定义一个类, StartsWith 该方法指示 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  

对应于可传递给方法的委托签名 FindIndexcorresponds 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>是一个方法委托, true 如果传递给它的对象与委托中定义的条件相匹配,则它将返回。The 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.

返回

Int32

如果找到与 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 具有两个字段 Name 和的类 IdThe following example defines an Employee class with two fields, Name and Id. 它还 EmployeeSearch 使用单个方法定义一个类, StartsWith 该方法指示 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  

对应于可传递给方法的委托签名 FindIndexcorresponds 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). 第一次,它会搜索 EmployeeName 字段以 "J" 开头的第一个对象; 第二次搜索其 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

注解

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

Predicate<T>是一个方法委托, true 如果传递给它的对象与委托中定义的条件相匹配,则它将返回。The 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 是从到末尾的元素数 startIndex List<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.

返回

Int32

如果找到与 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 具有两个字段 Name 和的类 IdThe following example defines an Employee class with two fields, Name and Id. 它还 EmployeeSearch 使用单个方法定义一个类, StartsWith 该方法指示 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  

对应于可传递给方法的委托签名 FindIndexcorresponds 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). 第一次,它会搜索 EmployeeName 字段以 "J" 开头的第一个对象; 第二次搜索其 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

注解

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

Predicate<T>是一个方法委托, true 如果传递给它的对象与委托中定义的条件相匹配,则它将返回。The 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.

另请参阅

适用于