Array.FindLast<T>(T[], Predicate<T>) Yöntem

Tanım

Belirtilen koşul tarafından tanımlanan koşullarla eşleşen bir öğeyi arar ve içindeki son oluşumu döndürür Array.

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

Tür Parametreleri

T

Dizinin öğelerini türü.

Parametreler

array
T[]

Arama için tek boyutlu, sıfır tabanlı Array .

match
Predicate<T>

Predicate<T> Aranacak öğenin koşullarını tanımlayan.

Döndürülenler

T

Bulunursa belirtilen koşul tarafından tanımlanan koşullarla eşleşen son öğe; aksi takdirde, türü Tiçin varsayılan değerdir.

Özel durumlar

array, null değeridir.

-veya-

match, null değeridir.

Örnekler

Aşağıdaki kod örneği , FindLastve FindAll genel yöntemlerini gösterirFind. 8 dinozor adı içeren dizelerden oluşan bir dizi oluşturulur, bunlardan ikisi (1 ve 5 konumundakiler) "saurus" ile bitmektedir. Kod örneği ayrıca, bir dize parametresi kabul eden ve giriş dizesinin "eş anlamlılar" ile bitip bitmediğini belirten bir Boole değeri döndüren adlı EndsWithSaurusarama koşulu yöntemini tanımlar.

Genel Find yöntem, her öğeyi sırayla yöntemine geçirerek diziyi EndsWithSaurus baştan geçirir. Yöntem "Amargasaurus" öğesini döndürdüğünde EndsWithSaurus true arama durdurulur.

Not

C# ve Visual Basic'da, temsilcininPredicate<string> (Predicate(Of String)Visual Basic içinde) açıkça oluşturulması gerekmez. Bu diller doğru temsilciyi bağlamdan çıkarır ve otomatik olarak oluşturur.

Diziyi FindLast sondan geriye doğru aramak için genel yöntem kullanılır. Bu, 5 konumundaki "Dilophosaurus" öğesini bulur. Genel FindAll yöntem, "eş anlamlılar" ile biten tüm öğeleri içeren bir dizi döndürmek için kullanılır. Öğeler görüntülenir.

Kod örneğinde ve TrueForAll genel yöntemleri de gösterilmektedirExists.

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

Açıklamalar

, Predicate<T> nesnesine geçirilen nesnenin temsilcide tanımlanan koşullarla eşleşmesi durumunda döndüren true bir yöntemin temsilcisidir. öğeleri array son öğeden başlayıp ilk öğeyle biten öğesinde Arraygeriye doğru hareket ederek öğesine tek tek geçirilirPredicate<T>. Eşleşme bulunduğunda işlem durdurulur.

Bu yöntem bir O(n) işlemidir ve burada n değeridir Length array.

Şunlara uygulanır

Ayrıca bkz.