Array.FindLastIndex Metódus

Definíció

Névtér:: System

Szerelvények:: mscorlib.dll, System.Runtime.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Olyan elemet keres, amely megfelel egy adott predikátum által meghatározott feltételeknek, és az utolsó előfordulás nulla alapú indexét adja vissza annak egy Array vagy egy részén belül.

Túlterhelések

Name	Description
FindLastIndex<T>(T[], Predicate<T>)	Olyan elemet keres, amely megfelel a megadott predikátum által meghatározott feltételeknek, és az utolsó előfordulás nulla alapú indexét adja vissza az egészben Array.
FindLastIndex<T>(T[], Int32, Predicate<T>)	Olyan elemet keres, amely megfelel a megadott predikátum által meghatározott feltételeknek, és visszaadja az utolsó előfordulás nulla alapú indexét az elemek tartományán Array belül, amely az első elemtől a megadott indexig terjed.
FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)	Olyan elemet keres, amely megfelel a megadott predikátum által meghatározott feltételeknek, és visszaadja az utolsó előfordulás nulla alapú indexét azon elemek tartományán belül, amelyek a Array megadott számú elemet tartalmazzák, és a megadott indexben végződnek.

Példák

Az alábbi példakód az általános metódus mindhárom túlterhelését FindLastIndex mutatja be. Létrejön egy sztringtömb, amely 8 dinoszaurusznevet tartalmaz, amelyek közül kettő (az 1. és az 5. pozícióban) "szinonimaszótár" végződéssel végződik. A példakód egy keresési predikátum metódust EndsWithSaurusis definiál, amely egy sztringparamétert fogad el, és logikai értéket ad vissza, amely jelzi, hogy a bemeneti sztring "szinonimaszótárban" végződik-e.

A FindLastIndex<T>(T[], Predicate<T>) metódus túlterhelése visszafelé halad a tömbön a végétől, és minden elemet átad a EndsWithSaurus metódusnak. A keresés leáll, ha a EndsWithSaurus metódus az 5. pozícióban adja vissza true az elemet.

Note

C#, F# és Visual Basic esetén nem szükséges explicit módon létrehozni a Predicate<string> delegáltat (Predicate(Of String) Visual Basic). Ezek a nyelvek a megfelelő delegáltat a környezetből következtetik, és automatikusan létrehozzák.

A FindLastIndex<T>(T[], Int32, Predicate<T>) metódus túlterhelése a tömb 4. pozíciótól kezdődő és a tömb elejéig visszafelé történő keresésére szolgál. Az 1. pozícióban találja meg az elemet. Végül a FindLastIndex<T>(T[], Int32, Int32, Predicate<T>) metódus túlterhelése három elem tartományának keresésére szolgál a 4. pozíciótól kezdve a visszafelé (azaz a 4., 3. és 2. elemig). -1 ad vissza, mert ebben a tartományban nincsenek olyan dinoszaurusznevek, amelyek "szinonimaszótárral" végződnek.

using System;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = { "Compsognathus",
            "Amargasaurus",   "Oviraptor",      "Velociraptor",
            "Deinonychus",    "Dilophosaurus",  "Gallimimus",
            "Triceratops" };

        Console.WriteLine();
        foreach(string dinosaur in dinosaurs)
        {
            Console.WriteLine(dinosaur);
        }

        Console.WriteLine(
            "\nArray.FindLastIndex(dinosaurs, EndsWithSaurus): {0}",
            Array.FindLastIndex(dinosaurs, EndsWithSaurus));

        Console.WriteLine(
            "\nArray.FindLastIndex(dinosaurs, 4, EndsWithSaurus): {0}",
            Array.FindLastIndex(dinosaurs, 4, EndsWithSaurus));

        Console.WriteLine(
            "\nArray.FindLastIndex(dinosaurs, 4, 3, EndsWithSaurus): {0}",
            Array.FindLastIndex(dinosaurs, 4, 3, EndsWithSaurus));
    }

    // Search predicate returns true if a string ends in "saurus".
    private static bool EndsWithSaurus(String s)
    {
        if ((s.Length > 5) &&
            (s.Substring(s.Length - 6).ToLower() == "saurus"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

/* This code example produces the following output:

Compsognathus
Amargasaurus
Oviraptor
Velociraptor
Deinonychus
Dilophosaurus
Gallimimus
Triceratops

Array.FindLastIndex(dinosaurs, EndsWithSaurus): 5

Array.FindLastIndex(dinosaurs, 4, EndsWithSaurus): 1

Array.FindLastIndex(dinosaurs, 4, 3, EndsWithSaurus): -1
 */

open System

// Search predicate returns true if a string ends in "saurus".
let endsWithSaurus (s: string) =
    s.Length > 5 && s.Substring(s.Length - 6).ToLower() = "saurus"

let dinosaurs =
    [| "Compsognathus"; "Amargasaurus"
       "Oviraptor"; "Velociraptor"
       "Deinonychus"; "Dilophosaurus"
       "Gallimimus"; "Triceratops" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

Array.FindLastIndex(dinosaurs, endsWithSaurus)
|> printfn "\nArray.FindLastIndex(dinosaurs, EndsWithSaurus): %i"

Array.FindLastIndex(dinosaurs, 4, endsWithSaurus)
|> printfn "\nArray.FindLastIndex(dinosaurs, 4, EndsWithSaurus): %i"

Array.FindLastIndex(dinosaurs, 4, 3, endsWithSaurus)
|> printfn "\nArray.FindLastIndex(dinosaurs, 4, 3, EndsWithSaurus): %i"


// This code example produces the following output:
//
//     Compsognathus
//     Amargasaurus
//     Oviraptor
//     Velociraptor
//     Deinonychus
//     Dilophosaurus
//     Gallimimus
//     Triceratops
//
//     Array.FindLastIndex(dinosaurs, EndsWithSaurus): 5
//
//     Array.FindLastIndex(dinosaurs, 4, EndsWithSaurus): 1
//
//     Array.FindLastIndex(dinosaurs, 4, 3, EndsWithSaurus): -1

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { "Compsognathus", _
            "Amargasaurus",   "Oviraptor",      "Velociraptor", _
            "Deinonychus",    "Dilophosaurus",  "Gallimimus", _
            "Triceratops" }

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "Array.FindLastIndex(dinosaurs, AddressOf EndsWithSaurus): {0}", _
            Array.FindLastIndex(dinosaurs, AddressOf EndsWithSaurus))

        Console.WriteLine(vbLf & _
            "Array.FindLastIndex(dinosaurs, 4, AddressOf EndsWithSaurus): {0}", _
            Array.FindLastIndex(dinosaurs, 4, AddressOf EndsWithSaurus))

        Console.WriteLine(vbLf & _
            "Array.FindLastIndex(dinosaurs, 4, 3, AddressOf EndsWithSaurus): {0}", _
            Array.FindLastIndex(dinosaurs, 4, 3, AddressOf EndsWithSaurus))

    End Sub

    ' Search predicate returns true if a string ends in "saurus".
    Private Shared Function EndsWithSaurus(ByVal s As String) _
        As Boolean

        ' AndAlso prevents evaluation of the second Boolean
        ' expression if the string is so short that an error
        ' would occur.
        If (s.Length > 5) AndAlso _
            (s.Substring(s.Length - 6).ToLower() = "saurus") Then
            Return True
        Else
            Return False
        End If
    End Function
End Class

' This code example produces the following output:
'
'Compsognathus
'Amargasaurus
'Oviraptor
'Velociraptor
'Deinonychus
'Dilophosaurus
'Gallimimus
'Triceratops
'
'Array.FindLastIndex(dinosaurs, AddressOf EndsWithSaurus): 5
'
'Array.FindLastIndex(dinosaurs, 4, AddressOf EndsWithSaurus): 1
'
'Array.FindLastIndex(dinosaurs, 4, 3, AddressOf EndsWithSaurus): -1

FindLastIndex<T>(T[], Predicate<T>)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Olyan elemet keres, amely megfelel a megadott predikátum által meghatározott feltételeknek, és az utolsó előfordulás nulla alapú indexét adja vissza az egészben Array.

public:
generic <typename T>
 static int FindLastIndex(cli::array <T> ^ array, Predicate<T> ^ match);

public static int FindLastIndex<T>(T[] array, Predicate<T> match);

static member FindLastIndex : 'T[] * Predicate<'T> -> int

Public Shared Function FindLastIndex(Of T) (array As T(), match As Predicate(Of T)) As Integer

Típusparaméterek

T

A tömb elemeinek típusa.

Paraméterek

array: T[]

Az egydimenziós, nulla alapú Array keresés.

match: Predicate<T>

Ez Predicate<T> határozza meg a keresendő elem feltételeit.

Válaszok

Int32

Egy elem utolsó előfordulásának nullaalapú indexe, amely megfelel az adott elem által matchmeghatározott feltételeknek, ha található; ellenkező esetben -1.

Kivételek

ArgumentNullException

array az null.

-vagy-

match az null.

Megjegyzések

A Array rendszer az utolsó elemtől kezdve visszafelé keres, és az első elemnél végződik.

Ez Predicate<T> egy olyan metódus delegáltja, amely akkor ad vissza true , ha az átadott objektum megfelel a delegáltban meghatározott feltételeknek. A rendszer array az elemeket egyenként továbbítja a Predicate<T>.

Ez a metódus egy O(n) művelet, ahol n a Length .array

Lásd még

A következőre érvényes:

FindLastIndex<T>(T[], Int32, Predicate<T>)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Olyan elemet keres, amely megfelel a megadott predikátum által meghatározott feltételeknek, és visszaadja az utolsó előfordulás nulla alapú indexét az elemek tartományán Array belül, amely az első elemtől a megadott indexig terjed.

public:
generic <typename T>
 static int FindLastIndex(cli::array <T> ^ array, int startIndex, Predicate<T> ^ match);

public static int FindLastIndex<T>(T[] array, int startIndex, Predicate<T> match);

static member FindLastIndex : 'T[] * int * Predicate<'T> -> int

Public Shared Function FindLastIndex(Of T) (array As T(), startIndex As Integer, match As Predicate(Of T)) As Integer

Típusparaméterek

T

A tömb elemeinek típusa.

Paraméterek

array: T[]

Az egydimenziós, nulla alapú Array keresés.

startIndex: Int32

A visszamenőleges keresés nulla alapú kezdőindexe.

match: Predicate<T>

Ez Predicate<T> határozza meg a keresendő elem feltételeit.

Válaszok

Int32

Egy elem utolsó előfordulásának nullaalapú indexe, amely megfelel az adott elem által matchmeghatározott feltételeknek, ha található; ellenkező esetben -1.

Kivételek

ArgumentNullException

array az null.

-vagy-

match az null.

ArgumentOutOfRangeException

startIndex az érvényes indexek tartományán kívül esik a következőhöz array: .

Megjegyzések

A Array rendszer az első elemtől startIndex kezdődően visszafelé keres.

Ez a metódus egy O(n) művelet, ahol n az elemek száma az elejétől array aig startIndex.

Lásd még

A következőre érvényes:

FindLastIndex<T>(T[], Int32, Int32, Predicate<T>)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Olyan elemet keres, amely megfelel a megadott predikátum által meghatározott feltételeknek, és visszaadja az utolsó előfordulás nulla alapú indexét azon elemek tartományán belül, amelyek a Array megadott számú elemet tartalmazzák, és a megadott indexben végződnek.

public:
generic <typename T>
 static int FindLastIndex(cli::array <T> ^ array, int startIndex, int count, Predicate<T> ^ match);

public static int FindLastIndex<T>(T[] array, int startIndex, int count, Predicate<T> match);

static member FindLastIndex : 'T[] * int * int * Predicate<'T> -> int

Public Shared Function FindLastIndex(Of T) (array As T(), startIndex As Integer, count As Integer, match As Predicate(Of T)) As Integer

Típusparaméterek

T

A tömb elemeinek típusa.

Paraméterek

array: T[]

Az egydimenziós, nulla alapú Array keresés.

startIndex: Int32

A visszamenőleges keresés nulla alapú kezdőindexe.

count: Int32

A keresendő szakasz elemeinek száma.

match: Predicate<T>

Ez Predicate<T> határozza meg a keresendő elem feltételeit.

Válaszok

Int32

Egy elem utolsó előfordulásának nullaalapú indexe, amely megfelel az adott elem által matchmeghatározott feltételeknek, ha található; ellenkező esetben -1.

Kivételek

ArgumentNullException

array az null.

-vagy-

match az null.

ArgumentOutOfRangeException

startIndex az érvényes indexek tartományán kívül esik a következőhöz array: .

-vagy-

count kisebb, mint nulla.

-vagy-

startIndex és count ne adjon meg érvényes szakaszt a következőben array: .

Megjegyzések

A Array rendszer visszafelé startIndex keres, és mínusz startIndex plusz 1 értékre count végződik, ha count nagyobb, mint 0.

Ez a metódus egy O(n) művelet, ahol n van count.

Lásd még

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?