Este método se usa para buscar un elemento que coincida con las condiciones definidas por un predicado especificado y devuelve el índice de base cero de la última aparición dentro de List<T> o una parte de ella. Hay 3 métodos en la lista de sobrecarga de este método:
- Método FindLastIndex(Predicado<T>)
- Método FindLastIndex(Int32, Predicado<T>)
- Método FindLastIndex(Int32, Int32, Predicate<T>)
Aquí, discutiremos solo los dos últimos métodos.
Método FindLastIndex(Int32, Predicado<T>)
Este método busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición dentro del rango de elementos en List <T> que se extiende desde el primer elemento hasta el índice especificado.
Sintaxis: public int FindLastIndex (int start, Predicate<T> match);
Parámetros:
start : Es el índice de inicio desde el inicio de la búsqueda.
match : Es el predicado delegado que define las condiciones del elemento buscado.
Valor devuelto: si se encuentra el elemento, devuelve el índice basado en cero de tipo Int32 de la última aparición de un elemento que coincide con una condición especificada por el parámetro » coincidencia «. Y si no se encuentra, devuelve » -1 «.
Excepciones:
- ArgumentNullException: si la coincidencia es nula .
- ArgumentOutOfRangeException: si el inicio está fuera del rango de índices válidos para List<T>.
Los siguientes programas ilustran el uso del método mencionado anteriormente:
Ejemplo 1:
// C# program to illustrate the
// List<T>.FindLastIndex(Int32,
// Predicate <T>) Method
using System;
using System.Collections.Generic;
class GFG {
// Main Method
public static void Main()
{
// List creation
// List name is "PC"
List<string> PC = new List<string>();
// elements in the List
PC.Add("Computer");
PC.Add("keyboard");
PC.Add("laptop");
PC.Add("mouse");
// the search will starts from index 2
int indx = PC.FindLastIndex(2, FindIndex);
Console.WriteLine(indx);
}
// Conditional method
private static bool FindIndex(string g)
{
if (g == "Computer")
{
return true;
}
else
{
return false;
}
}
}
Producción:
0
Ejemplo 2:
// C# program to illustrate the
// List<T>.FindLastIndex(Int32,
// Predicate <T>) Method
using System;
using System.Collections.Generic;
class GFG {
// Main Method
public static void Main()
{
// List creation
// List name is "PC"
List<int> PC = new List<int>();
// elements in the List
PC.Add(3);
PC.Add(4);
PC.Add(5);
PC.Add(6);
// condition is "FindIndex"
int indx = PC.FindLastIndex(2, FindIndex);
Console.WriteLine(indx);
}
// Conditional method
private static bool FindIndex(int g)
{
// search for "5"
if (g == 5)
{
return true;
}
else
{
return false;
}
}
}
Producción:
2
Ejemplo 3: En este ejemplo, usamos un archivo XML y buscamos un elemento desde un índice de inicio e imprimimos el índice de ese elemento, si no se encuentra el elemento, imprime «-1″ y, si lo encuentra, imprime el índice. El artículo es » GeeksForGeeks «. Pero aquí no tenemos el archivo XML, y aquí el compilador da una excepción.
// C# program to illustrate the
// List<T>.FindLastIndex(Int32,
// Predicate <T>) Method
using System;
using System.Collections.Generic;
using System.Linq;
class GFG {
// here List<T> contains the object "gfg" using
// data from a sample XML file
// List initialize
private static List<gfg> geeks = new List<gfg>();
public static void Main()
{
// if the item is found then
// it prints the index
// if not found prints "-1"
int x = geeks.FindLastIndex(3, FindGFG);
Console.WriteLine(x);
}
// conditional method
private static bool FindGFG(gfg g)
{
// item is "GeeksForGeeks"
if (g.G == "GeeksForGeeks")
{
return true;
}
else
{
return false;
}
}
}
public class gfg {
public string G
{
get;
set;
}
}
Error de tiempo de ejecución:
Excepción no controlada:
System.ArgumentOutOfRangeException: ArgumentOutOfRange_Index
Nombre del parámetro: startIndex
Método FindLastIndex(Int32, Int32, Predicate<T>)
Este método busca un elemento que coincida con las condiciones definidas por el predicado especificado y devuelve el índice de base cero de la última aparición dentro de toda la Lista y la lista contiene el número especificado de elementos y termina en el índice especificado.
Sintaxis: public int FindLastIndex (int startIndex, int count, Predicate<T> match);
Parámetros:
startIndex : Es el índice inicial de base cero de la búsqueda hacia atrás.
count : Es el número de elementos de la sección a buscar.
match : Es el delegado Predicate<T> que define las condiciones del elemento a buscar.
Valor devuelto: si se encuentra el elemento, devuelve el índice basado en cero del tipo Int32 del último elemento que coincide con una condición especificada por el parámetro «coincidencia». Y si no se encuentra, devuelve «-1».
Excepciones:
- ArgumentNullException: si la » coincidencia » es nula.
- ArgumentOutOfRangeException: si «startIndex» está fuera del rango o «count» es menor que 0 (cero) o «startIndex» y «count» no especifican una sección válida en la Lista
Ejemplo:
// C# Program to illustrate the
// FindLastIndex(Int32, Int32,
// Predicate<T>) Method
using System;
using System.Collections.Generic;
class GFG
{
public static void Main()
{
// List name is "mylist"
List<string> mylist = new List<string>();
// Elements in the List
mylist.Add("C");
mylist.Add("C++");
mylist.Add("Java");
mylist.Add("Python");
mylist.Add("C#");
mylist.Add("HTML");
mylist.Add("Java");
mylist.Add("PHP");
// the search will starts from index 2
// the number of element is 3
int indx = mylist.FindLastIndex(2, 3, FindIndex);
Console.WriteLine("The index of Java is: "+indx);
}
// Conditional method
private static bool FindIndex(string g)
{
if (g == "Java")
{
return true;
}
else
{
return false;
}
}
}
Producción:
The index of Java is: 2
Nota:
- El List<T> se busca hacia atrás comenzando en startIndex y terminando en el primer elemento.
- El Predicate<T> es un delegado de un método que devuelve verdadero si el objeto que se le pasa coincide con las condiciones definidas en el delegado. Los elementos del List<T> actual se pasan individualmente al delegado de Predicate<T>.
- 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 desde el principio de List<T> hasta el comienzo.
Publicación traducida automáticamente
Artículo escrito por SoumikMondal y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA