Array.FindLast<T>(T[], Predicate<T>) Méthode

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

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

public static T? FindLast<T> (T[] array, Predicate<T> match);

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

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

Paramètres de type

Paramètres

Retours

Dernier élément qui correspond aux conditions définies par le prédicat spécifié, s’il est trouvé ; sinon, la valeur par défaut du type T.

Exceptions

Exemples

L’exemple de code suivant illustre les méthodes génériques Find, FindLastet FindAll. Un tableau de chaînes est créé, contenant 8 noms de dinosaures, dont deux (aux positions 1 et 5) se terminent par « saurus ». L’exemple de code définit également une méthode de prédicat de recherche nommée EndsWithSaurus, qui accepte un paramètre de chaîne et retourne une valeur booléenne indiquant si la chaîne d’entrée se termine par « saurus ».

La méthode générique Find traverse le tableau du début, en passant à son tour chaque élément à la méthode EndsWithSaurus. La recherche s’arrête lorsque la méthode EndsWithSaurus retourne true pour l’élément « Amargasaurus ».

La méthode générique FindLast est utilisée pour rechercher le tableau vers l’arrière à partir de la fin. Il trouve l’élément « Dilophosaurus » à la position 5. La méthode générique FindAll est utilisée pour retourner un tableau contenant tous les éléments qui se terminent par « saurus ». Les éléments sont affichés.

L’exemple de code illustre également les méthodes génériques Exists et TrueForAll.

using namespace System;

public ref class DinoDiscoverySet
{
public:
    static void Main()
    {
        array<String^>^ dinosaurs =
        {
            "Compsognathus", "Amargasaurus", "Oviraptor",
            "Velociraptor",  "Deinonychus",  "Dilophosaurus",
            "Gallimimus",    "Triceratops"
        };

        DinoDiscoverySet^ GoMesozoic = gcnew DinoDiscoverySet(dinosaurs);

        GoMesozoic->DiscoverAll();
        GoMesozoic->DiscoverByEnding("saurus");
    }

    DinoDiscoverySet(array<String^>^ items)
    {
        dinosaurs = items;
    }

    void DiscoverAll()
    {
        Console::WriteLine();
        for each(String^ dinosaur in dinosaurs)
        {
            Console::WriteLine(dinosaur);
        }
    }

    void DiscoverByEnding(String^ Ending)
    {
        Predicate<String^>^ dinoType;

        if (Ending->ToLower() == "raptor")
        {
            dinoType =
                gcnew Predicate<String^>(&DinoDiscoverySet::EndsWithRaptor);
        }
        else if (Ending->ToLower() == "tops")
        {
            dinoType =
                gcnew Predicate<String^>(&DinoDiscoverySet::EndsWithTops);
        }
        else if (Ending->ToLower() == "saurus")
        {
            dinoType =
                gcnew Predicate<String^>(&DinoDiscoverySet::EndsWithSaurus);
        }
        else
        {
            dinoType =
                gcnew Predicate<String^>(&DinoDiscoverySet::EndsWithSaurus);
        }

        Console::WriteLine(
            "\nArray::Exists(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array::Exists(dinosaurs, dinoType));

        Console::WriteLine(
            "\nArray::TrueForAll(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array::TrueForAll(dinosaurs, dinoType));

        Console::WriteLine(
            "\nArray::Find(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array::Find(dinosaurs, dinoType));

        Console::WriteLine(
            "\nArray::FindLast(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array::FindLast(dinosaurs, dinoType));

        Console::WriteLine(
            "\nArray::FindAll(dinosaurs, \"{0}\"):", Ending);

        array<String^>^ subArray =
            Array::FindAll(dinosaurs, dinoType);

        for each(String^ dinosaur in subArray)
        {
            Console::WriteLine(dinosaur);
        }
    }

private:
    array<String^>^ dinosaurs;

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

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

    // Search predicate returns true if a string ends in "tops".
    static bool EndsWithTops(String^ s)
    {
        if ((s->Length > 3) &&
            (s->Substring(s->Length - 4)->ToLower() == "tops"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
};

int main()
{
    DinoDiscoverySet::Main();
}

/* This code example produces the following output:

Compsognathus
Amargasaurus
Oviraptor
Velociraptor
Deinonychus
Dilophosaurus
Gallimimus
Triceratops

Array.Exists(dinosaurs, "saurus"): True

Array.TrueForAll(dinosaurs, "saurus"): False

Array.Find(dinosaurs, "saurus"): Amargasaurus

Array.FindLast(dinosaurs, "saurus"): Dilophosaurus

Array.FindAll(dinosaurs, "saurus"):
Amargasaurus
Dilophosaurus
*/

using System;

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

        DinoDiscoverySet GoMesozoic = new DinoDiscoverySet(dinosaurs);

        GoMesozoic.DiscoverAll();
        GoMesozoic.DiscoverByEnding("saurus");
    }

    private string[] dinosaurs;

    public DinoDiscoverySet(string[] items)
    {
        dinosaurs = items;
    }

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

    public void DiscoverByEnding(string Ending)
    {
        Predicate<string> dinoType;

        switch (Ending.ToLower())
        {
            case "raptor":
                dinoType = EndsWithRaptor;
                break;
            case "tops":
                dinoType = EndsWithTops;
                break;
            case "saurus":
            default:
                dinoType = EndsWithSaurus;
                break;
        }
        Console.WriteLine(
            "\nArray.Exists(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.Exists(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.TrueForAll(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.TrueForAll(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.Find(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.Find(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.FindLast(dinosaurs, \"{0}\"): {1}",
            Ending,
            Array.FindLast(dinosaurs, dinoType));

        Console.WriteLine(
            "\nArray.FindAll(dinosaurs, \"{0}\"):", Ending);

        string[] subArray =
            Array.FindAll(dinosaurs, dinoType);

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

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

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

    // Search predicate returns true if a string ends in "tops".
    private bool EndsWithTops(String s)
    {
        if ((s.Length > 3) &&
            (s.Substring(s.Length - 4).ToLower() == "tops"))
        {
            return true;
        }
        else
        {
            return false;
        }
    }
}

/* This code example produces the following output:

Compsognathus
Amargasaurus
Oviraptor
Velociraptor
Deinonychus
Dilophosaurus
Gallimimus
Triceratops

Array.Exists(dinosaurs, "saurus"): True

Array.TrueForAll(dinosaurs, "saurus"): False

Array.Find(dinosaurs, "saurus"): Amargasaurus

Array.FindLast(dinosaurs, "saurus"): Dilophosaurus

Array.FindAll(dinosaurs, "saurus"):
Amargasaurus
Dilophosaurus
*/

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"

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

// Search predicate returns true if a string ends in "tops".
let endsWithTops (s: string) =
    s.Length > 3 && s.Substring(s.Length - 4).ToLower() = "tops"

type DinoDiscoverySet =
    { Dinosaurs: string [] }

    member this.DiscoverAll() =
        printfn ""
        for dino in this.Dinosaurs do
            printfn $"{dino}"

    member this.DiscoverByEnding(ending: string) =
        let dinoType =
            match ending.ToLower() with
            | "raptor" -> endsWithRaptor
            | "tops" -> endsWithTops
            | "saurus" | _ -> endsWithSaurus

        Array.Exists(this.Dinosaurs, dinoType)
        |> printfn "\nArray.Exists(dinosaurs, \"%s\"): %b" ending

        Array.TrueForAll(this.Dinosaurs, dinoType)
        |> printfn "\nArray.TrueForAll(dinosaurs, \"%s\"): %b" ending

        Array.Find(this.Dinosaurs, dinoType)
        |> printfn "\nArray.Find(dinosaurs, \"%s\"): %s" ending

        Array.FindLast(this.Dinosaurs, dinoType)
        |> printfn "\nArray.FindLast(dinosaurs, \"%s\"): %s" ending

        printfn $"\nArray.FindAll(dinosaurs, \"{ending}\"):"
        for dinosaur in Array.FindAll(this.Dinosaurs, dinoType) do
            printfn $"{dinosaur}"

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

let goMesozoic = { Dinosaurs = dinosaurs }

goMesozoic.DiscoverAll()
goMesozoic.DiscoverByEnding "saurus"


// This code example produces the following output:
//     Compsognathus
//     Amargasaurus
//     Oviraptor
//     Velociraptor
//     Deinonychus
//     Dilophosaurus
//     Gallimimus
//     Triceratops
//
//     Array.Exists(dinosaurs, "saurus"): true
//
//     Array.TrueForAll(dinosaurs, "saurus"): false
//
//     Array.Find(dinosaurs, "saurus"): Amargasaurus
//
//     Array.FindLast(dinosaurs, "saurus"): Dilophosaurus
//
//     Array.FindAll(dinosaurs, "saurus"):
//     Amargasaurus
//     Dilophosaurus

Public Class DinoDiscoverySet

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

        Dim GoMesozoic As New DinoDiscoverySet(dinosaurs)

        GoMesozoic.DiscoverAll()
        GoMesozoic.DiscoverByEnding("saurus")
    End Sub

    Private dinosaurs As String()

    Public Sub New(items() As String)
        dinosaurs = items
    End Sub

    Public Sub DiscoverAll()
        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next dinosaur
    End Sub

    Public Sub DiscoverByEnding(Ending As String)
        Dim dinoType As Predicate(Of String)

        Select Case Ending.ToLower()
            Case "raptor"
                dinoType = AddressOf EndsWithRaptor
            Case "tops"
                dinoType = AddressOf EndsWithTops
            Case "saurus"
                dinoType = AddressOf EndsWithSaurus
            Case Else
                dinoType = AddressOf EndsWithSaurus
        End Select

        Console.WriteLine(Environment.NewLine + _
            "Array.Exists(dinosaurs, ""{0}""): {1}", _
            Ending, _
            Array.Exists(dinosaurs, dinoType))

        Console.WriteLine(Environment.NewLine + _
            "Array.TrueForAll(dinosaurs, ""{0}""): {1}", _
            Ending, _
            Array.TrueForAll(dinosaurs, dinoType))

        Console.WriteLine(Environment.NewLine + _
            "Array.Find(dinosaurs, ""{0}""): {1}", _
            Ending, _
            Array.Find(dinosaurs, dinoType))

        Console.WriteLine(Environment.NewLine + _
            "Array.FindLast(dinosaurs, ""{0}""): {1}", _
            Ending, _
            Array.FindLast(dinosaurs, dinoType))

        Console.WriteLine(Environment.NewLine + _
            "Array.FindAll(dinosaurs, ""{0}""):", Ending)

        Dim subArray() As String = _
            Array.FindAll(dinosaurs, dinoType)

        For Each dinosaur As String In subArray
            Console.WriteLine(dinosaur)
        Next dinosaur
    End Sub

    ' Search predicate returns true if a string ends in "saurus".
    Private Function EndsWithSaurus(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.ToLower().EndsWith("saurus")) Then
            Return True
        Else
            Return False
        End If
    End Function

    ' Search predicate returns true if a string ends in "raptor".
    Private Function EndsWithRaptor(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.ToLower().EndsWith("raptor")) Then
            Return True
        Else
            Return False
        End If
    End Function

    ' Search predicate returns true if a string ends in "tops".
    Private Function EndsWithTops(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 > 3) AndAlso _
            (s.ToLower().EndsWith("tops")) 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.Exists(dinosaurs, "saurus"): True
'
' Array.TrueForAll(dinosaurs, "saurus"): False
'
' Array.Find(dinosaurs, "saurus"): Amargasaurus
'
' Array.FindLast(dinosaurs, "saurus"): Dilophosaurus
'
' Array.FindAll(dinosaurs, "saurus"):
' Amargasaurus
' Dilophosaurus

Remarques

Le Predicate<T> est un délégué à une méthode qui retourne true si l’objet passé à celui-ci correspond aux conditions définies dans le délégué. Les éléments de array sont transmis individuellement à l'Predicate<T>, se déplaçant vers l’arrière dans le Array, en commençant par le dernier élément et en se terminant par le premier élément. Le traitement est arrêté lorsqu’une correspondance est trouvée.

Cette méthode est une opération O(n), où n est la Length de array.

S’applique à

Voir aussi

• Exists<T>(T[], Predicate<T>)
• Find<T>(T[], Predicate<T>)
• FindAll<T>(T[], Predicate<T>)
• BinarySearch
• IndexOf
• LastIndexOf
• Predicate<T>