List<T>.FindIndex Metoda

Definice

Obor názvů:

System.Collections.Generic

Sestavení:

System.Collections.dll

Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rámci List<T> nebo jeho části. Tato metoda vrátí hodnotu -1, pokud není nalezena položka, která odpovídá podmínkám.

Přetížení

FindIndex(Int32, Int32, Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rozsahu prvků v oblasti prvků, List<T> která začíná na zadaném indexu a obsahuje zadaný počet prvků.
FindIndex(Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rámci celého List<T>objektu .
FindIndex(Int32, Predicate<T>)	Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rozsahu prvků v List<T> oblasti, která se rozšiřuje od zadaného indexu k poslednímu elementu.

FindIndex(Int32, Int32, Predicate<T>)

Zdroj:

List.cs

Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rozsahu prvků v oblasti prvků, List<T> která začíná na zadaném indexu a obsahuje zadaný počet prvků.

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

Počáteční index hledání začínající od nuly.

count

Int32

Počet prvků v prohledávané části.

match

Predicate<T>

Delegát Predicate<T> , který definuje podmínky prvku, který se má hledat.

Návraty

Int32

Index založený na nule prvního výskytu elementu, který odpovídá podmínkám definovaným v match, pokud je nalezen; v opačném případě -1.

Výjimky

ArgumentNullException

match je null.

ArgumentOutOfRangeException

startIndex je mimo rozsah platných indexů pro List<T>.

-nebo-

count je menší než 0.

-nebo-

startIndex a count nezadávejte platný oddíl v List<T>souboru .

Příklady

Následující příklad definuje třídu se Employee dvěma poli Name a Id. Definuje také EmployeeSearch třídu s jedinou metodou , která označuje, StartsWithzda Employee.Name pole začíná zadaným podřetětěcem, který je dodán konstruktoru EmployeeSearch třídy. Všimněte si podpisu této metody.

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

odpovídá podpisu delegáta, který lze předat FindIndex metodě. Příklad vytvoří instanci objektu List<Employee> , přidá do něj několik Employee objektů a pak zavolá metodu FindIndex(Int32, Int32, Predicate<T>) dvakrát, aby prohledali celou kolekci (to znamená členy z indexu 0 do indexu Count - 1). Poprvé vyhledá první Employee objekt, jehož Name pole začíná na "J"; podruhé hledá první Employee objekt, jehož Name pole začíná na "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

Poznámky

Prohledá List<T> se dopředu od a startIndex končící na startIndex plus count minus 1, pokud count je větší než 0.

Je Predicate<T> delegátem metody, která vrací true , pokud objekt předaný do něj odpovídá podmínkám definovaným v delegátu. Prvky aktuálního jsou List<T> jednotlivě předány delegátu Predicate<T> . Delegát má podpis:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Tato metoda provádí lineární vyhledávání; Proto je tato metoda operací O(n), kde n je count.

Viz také

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

FindIndex(Predicate<T>)

Zdroj:

List.cs

Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rámci celého List<T>objektu .

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>

Delegát Predicate<T> , který definuje podmínky prvku, který se má hledat.

Návraty

Int32

Index založený na nule prvního výskytu elementu, který odpovídá podmínkám definovaným v match, pokud je nalezen; v opačném případě -1.

Výjimky

ArgumentNullException

match je null.

Příklady

Následující příklad definuje třídu se Employee dvěma poli Name a Id. Definuje také EmployeeSearch třídu s jedinou metodou , která označuje, StartsWithzda Employee.Name pole začíná zadaným podřetětěcem, který je dodán konstruktoru EmployeeSearch třídy. Všimněte si podpisu této metody.

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

odpovídá podpisu delegáta, který lze předat FindIndex metodě. Příklad vytvoří instanci objektu List<Employee> , přidá do něj několik Employee objektů a pak zavolá metodu FindIndex(Int32, Int32, Predicate<T>) dvakrát, aby prohledali celou kolekci, poprvé pro první Employee objekt, jehož Name pole začíná na "J", a podruhé pro první Employee objekt, jehož Name pole začíná na "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

Poznámky

Prohledá List<T> se dopředu počínaje prvním prvkem a končí posledním prvkem.

Je Predicate<T> delegátem metody, která vrací true , pokud objekt předaný do něj odpovídá podmínkám definovaným v delegátu. Prvky aktuálního jsou List<T> jednotlivě předány delegátu Predicate<T> . Delegát má podpis:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Tato metoda provádí lineární vyhledávání; Proto je tato metoda operací O(n), kde n je Count.

Viz také

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

FindIndex(Int32, Predicate<T>)

Zdroj:

List.cs

Vyhledá prvek, který odpovídá podmínkám definovaným zadaným predikátem, a vrátí nulový index prvního výskytu v rozsahu prvků v List<T> oblasti, která se rozšiřuje od zadaného indexu k poslednímu 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

Počáteční index hledání začínající od nuly.

match

Predicate<T>

Delegát Predicate<T> , který definuje podmínky prvku, který se má hledat.

Návraty

Int32

Index založený na nule prvního výskytu elementu, který odpovídá podmínkám definovaným v match, pokud je nalezen; v opačném případě -1.

Výjimky

ArgumentNullException

match je null.

ArgumentOutOfRangeException

startIndex je mimo rozsah platných indexů pro List<T>.

Příklady

Následující příklad definuje třídu se Employee dvěma poli Name a Id. Definuje také EmployeeSearch třídu s jedinou metodou , která označuje, StartsWithzda Employee.Name pole začíná zadaným podřetětěcem, který je dodán konstruktoru EmployeeSearch třídy. Všimněte si podpisu této metody.

public bool StartsWith(Employee e)

Public Function StartsWith(e As Employee) As Boolean

odpovídá podpisu delegáta, který lze předat FindIndex metodě. Příklad vytvoří instanci objektu List<Employee> , přidá do něj několik Employee objektů a pak zavolá metodu FindIndex(Int32, Int32, Predicate<T>) dvakrát, aby prohledali kolekci počínaje jejím pátým členem (to znamená člen v indexu 4). Poprvé vyhledá první Employee objekt, jehož Name pole začíná na "J"; podruhé hledá první Employee objekt, jehož Name pole začíná na "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

Poznámky

Prohledá List<T> se dopředu počínaje startIndex a končícím posledním prvkem.

Je Predicate<T> delegátem metody, která vrací true , pokud objekt předaný do něj odpovídá podmínkám definovaným v delegátu. Prvky aktuálního jsou List<T> jednotlivě předány delegátu Predicate<T> . Delegát má podpis:

public bool methodName(T obj)

Public Function methodName(obj As T) As Boolean

Tato metoda provádí lineární vyhledávání; proto je tato metoda operace O(n), kde n je počet prvků od startIndex do konce List<T>.

Viz také

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