Udostępnij za pośrednictwem

List<T>.FindIndex Metoda

  • Odwołanie

Definicja

Przestrzeń nazw:
System.Collections.Generic
Zestaw:
System.Collections.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll

Wyszukuje element pasujący do warunków zdefiniowanych przez określony predykat i zwraca zerowy indeks pierwszego wystąpienia w części List<T> lub. Ta metoda zwraca wartość -1, jeśli element zgodny z warunkami nie zostanie znaleziony.

Przeciążenia

FindIndex(Int32, Int32, Predicate<T>)

Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks pierwszego wystąpienia w zakresie elementów w List<T> zakresie elementów rozpoczynających się od określonego indeksu i zawiera określoną liczbę elementów.
FindIndex(Predicate<T>)

Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks oparty na zera pierwszego wystąpienia w całym List<T>obiekcie .
FindIndex(Int32, Predicate<T>)

Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks pierwszego wystąpienia w zakresie elementów w List<T> zakresie elementów, które rozciągają się od określonego indeksu do ostatniego elementu.

FindIndex(Int32, Int32, Predicate<T>)

Źródło:
List.cs
Źródło:
List.cs
Źródło:
List.cs

Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks pierwszego wystąpienia w zakresie elementów w List<T> zakresie elementów rozpoczynających się od określonego indeksu i zawiera określoną liczbę elementów.

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

Parametry

startIndex
Int32

Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.

count
Int32

Liczba elementów w sekcji do wyszukania.

match
Predicate<T>

Predicate<T> Delegat, który definiuje warunki elementu do wyszukania.

Zwraca

Int32

Indeks oparty na zerach pierwszego wystąpienia elementu zgodnego z warunkami zdefiniowanymi przez matchmetodę , jeśli zostanie znaleziony; w przeciwnym razie -1.

Wyjątki

ArgumentNullException

match to null.

ArgumentOutOfRangeException

startIndex znajduje się poza zakresem prawidłowych indeksów dla elementu List<T>.

-lub-

count wartość jest mniejsza niż 0.

-lub-

startIndex i count nie określają prawidłowej sekcji w pliku List<T>.

Przykłady

W poniższym przykładzie zdefiniowano klasę z dwoma Employee polami Name i Id. Definiuje również klasę EmployeeSearch z pojedynczą metodą , StartsWithktóra wskazuje, czy Employee.Name pole rozpoczyna się od określonego podciągu dostarczonego do konstruktora EmployeeSearch klasy. Zanotuj podpis tej metody

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

odpowiada podpisowi delegata, który można przekazać do FindIndex metody. Przykład tworzy wystąpienie List<Employee> obiektu, dodaje do niego wiele Employee obiektów, a następnie wywołuje FindIndex(Int32, Int32, Predicate<T>) metodę dwukrotnie, aby przeszukać całą kolekcję (czyli składowych z indeksu 0 do indeksu Count — 1). Po raz pierwszy wyszukuje pierwszy Employee obiekt, którego Name pole zaczyna się od "J", po raz drugi wyszukuje pierwszy Employee obiekt, którego Name pole zaczyna się od "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

Uwagi

Element List<T> jest wyszukiwany do przodu rozpoczynający się od i kończący startIndex się na startIndex plus count minus 1, jeśli count jest większy niż 0.

Jest Predicate<T> delegatem do metody, która zwraca true , jeśli obiekt przekazany do niego jest zgodny z warunkami zdefiniowanymi w delegatu. Elementy bieżące List<T> są indywidualnie przekazywane do delegata Predicate<T> . Pełnomocnik ma podpis:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Ta metoda wykonuje wyszukiwanie liniowe; dlatego ta metoda jest operacją O(n), gdzie n to count.

Zobacz też

Dotyczy

FindIndex(Predicate<T>)

Źródło:
List.cs
Źródło:
List.cs
Źródło:
List.cs

Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks oparty na zera pierwszego wystąpienia w całym List<T>obiekcie .

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

Parametry

match
Predicate<T>

Predicate<T> Delegat, który definiuje warunki elementu do wyszukania.

Zwraca

Int32

Indeks oparty na zerach pierwszego wystąpienia elementu zgodnego z warunkami zdefiniowanymi przez matchmetodę , jeśli zostanie znaleziony; w przeciwnym razie -1.

Wyjątki

ArgumentNullException

match to null.

Przykłady

W poniższym przykładzie zdefiniowano klasę z dwoma Employee polami Name i Id. Definiuje również klasę EmployeeSearch z pojedynczą metodą , StartsWithktóra wskazuje, czy Employee.Name pole rozpoczyna się od określonego podciągu dostarczonego do konstruktora EmployeeSearch klasy. Zanotuj podpis tej metody

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

odpowiada podpisowi delegata, który można przekazać do FindIndex metody. Przykład tworzy wystąpienie List<Employee> obiektu, dodaje do niego wiele Employee obiektów, a następnie wywołuje FindIndex(Int32, Int32, Predicate<T>) metodę dwukrotnie, aby przeszukać całą kolekcję, po raz pierwszy dla pierwszego obiektu, którego Name pole zaczyna się od "J", a drugi raz dla pierwszego EmployeeEmployee obiektu, którego Name pole zaczyna się od "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

Uwagi

Element List<T> jest wyszukiwany do przodu, zaczynając od pierwszego elementu i kończąc na ostatnim elemecie.

Jest Predicate<T> delegatem do metody, która zwraca true , jeśli obiekt przekazany do niego jest zgodny z warunkami zdefiniowanymi w delegatu. Elementy bieżące List<T> są indywidualnie przekazywane do delegata Predicate<T> . Pełnomocnik ma podpis:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Ta metoda wykonuje wyszukiwanie liniowe; dlatego ta metoda jest operacją O(n), gdzie n to Count.

Zobacz też

Dotyczy

FindIndex(Int32, Predicate<T>)

Źródło:
List.cs
Źródło:
List.cs
Źródło:
List.cs

Wyszukuje element zgodny z warunkami zdefiniowanymi przez określony predykat i zwraca indeks pierwszego wystąpienia w zakresie elementów w List<T> zakresie elementów, które rozciągają się od określonego indeksu do ostatniego elementu.

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

Parametry

startIndex
Int32

Wartość początkowa indeksu zaczynającego się od zera dla wyszukiwania.

match
Predicate<T>

Predicate<T> Delegat, który definiuje warunki elementu do wyszukania.

Zwraca

Int32

Indeks oparty na zerach pierwszego wystąpienia elementu zgodnego z warunkami zdefiniowanymi przez matchmetodę , jeśli zostanie znaleziony; w przeciwnym razie -1.

Wyjątki

ArgumentNullException

match to null.

ArgumentOutOfRangeException

startIndex znajduje się poza zakresem prawidłowych indeksów dla elementu List<T>.

Przykłady

W poniższym przykładzie zdefiniowano klasę z dwoma Employee polami Name i Id. Definiuje również klasę EmployeeSearch z pojedynczą metodą , StartsWithktóra wskazuje, czy Employee.Name pole rozpoczyna się od określonego podciągu dostarczonego do konstruktora EmployeeSearch klasy. Zanotuj podpis tej metody

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

odpowiada podpisowi delegata, który można przekazać do FindIndex metody. Przykład tworzy wystąpienie List<Employee> obiektu, dodaje do niego wiele Employee obiektów, a następnie wywołuje FindIndex(Int32, Int32, Predicate<T>) metodę dwukrotnie, aby wyszukać kolekcję, zaczynając od piątego elementu członkowskiego (czyli elementu członkowskiego w indeksie 4). Po raz pierwszy wyszukuje pierwszy Employee obiekt, którego Name pole zaczyna się od "J", po raz drugi wyszukuje pierwszy Employee obiekt, którego Name pole zaczyna się od "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

Uwagi

Element List<T> jest przeszukiwany dalej rozpoczynający się od startIndex i kończący się na ostatnim elemecie.

Jest Predicate<T> delegatem do metody, która zwraca true , jeśli obiekt przekazany do niego jest zgodny z warunkami zdefiniowanymi w delegatu. Elementy bieżące List<T> są indywidualnie przekazywane do delegata Predicate<T> . Pełnomocnik ma podpis:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Ta metoda wykonuje wyszukiwanie liniowe; w związku z tym ta metoda jest operacją O(n), gdzie n jest liczbą elementów od startIndex do końca List<T>elementu .

Zobacz też

Dotyczy