List<T>.FindIndex Método
Definición
Importante
Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.
Busca un elemento que cumpla las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en List<T> o en una parte. Este método devuelve -1 si no se encuentra un elemento que cumpla las condiciones.
Sobrecargas
FindIndex(Int32, Int32, Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz List<T> que comienza en el índice especificado y contiene el número especificado de elementos. |
FindIndex(Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en toda la matriz List<T>. |
FindIndex(Int32, Predicate<T>) |
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz List<T> que va desde el índice especificado hasta el último elemento. |
FindIndex(Int32, Int32, Predicate<T>)
- Source:
- List.cs
- Source:
- List.cs
- Source:
- List.cs
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz List<T> que comienza en el índice especificado y contiene el número especificado de elementos.
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
Parámetros
- startIndex
- Int32
Índice inicial de base cero de la búsqueda.
- count
- Int32
Número de elementos de la sección en la que se va a realizar la búsqueda.
- match
- Predicate<T>
Delegado Predicate<T> que define las condiciones del elemento que se va a buscar.
Devoluciones
Índice de base cero de la primera aparición de un elemento que coincide con las condiciones definidas por match
, si se encuentra; en caso contrario, -1.
Excepciones
match
es null
.
startIndex
está fuera del intervalo de índices válidos para List<T>.
o bien
count
es menor que 0.
o bien
startIndex
y count
no especifican una sección válida en List<T>.
Ejemplos
En el ejemplo siguiente se define una Employee
clase con dos campos y Id
Name
. También define una EmployeeSearch
clase con un único método, StartsWith
, que indica si el Employee.Name
campo comienza con una subcadena especificada que se proporciona al constructor de clase EmployeeSearch
. Tenga en cuenta la firma de este método
public bool StartsWith(Employee e)
Public Function StartsWith(e As Employee) As Boolean
corresponde a la firma del delegado que se puede pasar al FindIndex método . En el ejemplo se crea una instancia de un List<Employee>
objeto, se le agregan varios Employee
objetos y, a continuación, se llama al FindIndex(Int32, Int32, Predicate<T>) método dos veces para buscar en toda la colección (es decir, los miembros del índice 0 al índice Count - 1). La primera vez, busca el primer Employee
objeto cuyo Name
campo comienza por "J"; la segunda vez, busca el primer Employee
objeto cuyo Name
campo comienza por "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
Comentarios
List<T> Se busca hacia delante a partir startIndex
de y finalizando en startIndex
más count
menos 1, si count
es mayor que 0.
Predicate<T> es un delegado de un método que devuelve true
si el objeto pasado a él coincide con las condiciones definidas en el delegado. Los elementos del actual List<T> se pasan individualmente al Predicate<T> delegado. El delegado tiene la firma :
public bool methodName(T obj)
Public Function methodName(obj As T) As Boolean
Este método realiza una búsqueda lineal; por lo tanto, este método es una operación de O(n), donde n es count
.
Consulte también
- Exists(Predicate<T>)
- Find(Predicate<T>)
- FindLast(Predicate<T>)
- FindAll(Predicate<T>)
- FindLastIndex
- BinarySearch
- IndexOf
- LastIndexOf
- Predicate<T>
Se aplica a
FindIndex(Predicate<T>)
- Source:
- List.cs
- Source:
- List.cs
- Source:
- List.cs
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en toda la matriz 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
Parámetros
- match
- Predicate<T>
Delegado Predicate<T> que define las condiciones del elemento que se va a buscar.
Devoluciones
Índice de base cero de la primera aparición de un elemento que coincide con las condiciones definidas por match
, si se encuentra; en caso contrario, -1.
Excepciones
match
es null
.
Ejemplos
En el ejemplo siguiente se define una Employee
clase con dos campos y Id
Name
. También define una EmployeeSearch
clase con un único método, StartsWith
, que indica si el Employee.Name
campo comienza con una subcadena especificada que se proporciona al constructor de clase EmployeeSearch
. Tenga en cuenta la firma de este método
public bool StartsWith(Employee e)
Public Function StartsWith(e As Employee) As Boolean
corresponde a la firma del delegado que se puede pasar al FindIndex método . En el ejemplo se crea una instancia de un List<Employee>
objeto, se le agrega una serie de Employee
objetos y, a continuación, se llama al FindIndex(Int32, Int32, Predicate<T>) método dos veces para buscar en toda la colección, la primera vez para el primer Employee
objeto cuyo Name
campo comienza por "J" y la segunda vez para el primer Employee
objeto cuyo Name
campo comienza por "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
Comentarios
List<T> Se busca hacia delante comenzando en el primer elemento y finalizando en el último elemento.
Predicate<T> es un delegado de un método que devuelve true
si el objeto pasado a él coincide con las condiciones definidas en el delegado. Los elementos del actual List<T> se pasan individualmente al Predicate<T> delegado. El delegado tiene la firma :
public bool methodName(T obj)
Public Function methodName(obj As T) As Boolean
Este método realiza una búsqueda lineal; por lo tanto, este método es una operación de O(n), donde n es Count.
Consulte también
- Exists(Predicate<T>)
- Find(Predicate<T>)
- FindLast(Predicate<T>)
- FindAll(Predicate<T>)
- FindLastIndex
- BinarySearch
- IndexOf
- LastIndexOf
- Predicate<T>
Se aplica a
FindIndex(Int32, Predicate<T>)
- Source:
- List.cs
- Source:
- List.cs
- Source:
- List.cs
Busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la primera aparición en el intervalo de elementos de la matriz List<T> que va desde el índice especificado hasta el último elemento.
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
Parámetros
- startIndex
- Int32
Índice inicial de base cero de la búsqueda.
- match
- Predicate<T>
Delegado Predicate<T> que define las condiciones del elemento que se va a buscar.
Devoluciones
Índice de base cero de la primera aparición de un elemento que coincide con las condiciones definidas por match
, si se encuentra; en caso contrario, -1.
Excepciones
match
es null
.
startIndex
está fuera del intervalo de índices válidos para List<T>.
Ejemplos
En el ejemplo siguiente se define una Employee
clase con dos campos y Id
Name
. También define una EmployeeSearch
clase con un único método, StartsWith
, que indica si el Employee.Name
campo comienza con una subcadena especificada que se proporciona al constructor de clase EmployeeSearch
. Tenga en cuenta la firma de este método
public bool StartsWith(Employee e)
Public Function StartsWith(e As Employee) As Boolean
corresponde a la firma del delegado que se puede pasar al FindIndex método . En el ejemplo se crea una instancia de un List<Employee>
objeto, se le agrega una serie de Employee
objetos y, a continuación, se llama al FindIndex(Int32, Int32, Predicate<T>) método dos veces para buscar en la colección a partir de su quinto miembro (es decir, el miembro en el índice 4). La primera vez, busca el primer Employee
objeto cuyo Name
campo comienza por "J"; la segunda vez, busca el primer Employee
objeto cuyo Name
campo comienza por "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
Comentarios
List<T> Se busca hacia delante comenzando en startIndex
y finalizando en el último elemento.
Predicate<T> es un delegado de un método que devuelve true
si el objeto pasado a él coincide con las condiciones definidas en el delegado. Los elementos del actual List<T> se pasan individualmente al Predicate<T> delegado. El delegado tiene la firma :
public bool methodName(T obj)
Public Function methodName(obj As T) As Boolean
Este método realiza una búsqueda lineal; por lo tanto, este método es una operación O(n), donde n es el número de elementos de startIndex
hasta el final de List<T>.
Consulte también
- Exists(Predicate<T>)
- Find(Predicate<T>)
- FindLast(Predicate<T>)
- FindAll(Predicate<T>)
- FindLastIndex
- BinarySearch
- IndexOf
- LastIndexOf
- Predicate<T>
Se aplica a
Comentarios
https://aka.ms/ContentUserFeedback.
Próximamente: A lo largo de 2024 iremos eliminando gradualmente GitHub Issues como mecanismo de comentarios sobre el contenido y lo sustituiremos por un nuevo sistema de comentarios. Para más información, vea:Enviar y ver comentarios de