Array.FindLast<T>(T[], Predicate<T>) 方法

定义

命名空间:

System

程序集:

netstandard.dll, System.Runtime.dll

Source:

Array.cs

搜索与指定谓词定义的条件匹配的元素，并返回整个 Array中的最后一个匹配项。

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

类型参数

T

数组元素的类型。

参数

array

T[]

要搜索的从零开始的一维 Array。

match

Predicate<T>

定义要搜索的元素条件的 Predicate<T>。

返回

T

与指定谓词定义的条件匹配的最后一个元素（如果找到）;否则，类型为 T的默认值。

例外

ArgumentNullException

array null。

-或-

match null。

示例

下面的代码示例演示 Find、FindLast和 FindAll 泛型方法。 将创建一个字符串数组，其中包含 8 个恐龙名称，其中两个名称（在位置 1 和 5）以“saurus”结尾。 该代码示例还定义了一个名为 EndsWithSaurus的搜索谓词方法，该方法接受字符串参数并返回一个布尔值，该值指示输入字符串是否以“saurus”结尾。

Find 泛型方法从头遍历数组，将每个元素依次传递给 EndsWithSaurus 方法。 当 EndsWithSaurus 方法返回元素“Amargasaurus”的 true 时，搜索将停止。

备注

在 C# 和 Visual Basic 中，无需显式创建Predicate<string> 委托（在 Visual Basic 中Predicate(Of String)）。 这些语言从上下文推断出正确的委托，并自动创建它。

FindLast 泛型方法用于从末尾向后搜索数组。 它查找位置 5 处的元素“Dilophosaurus”。 FindAll 泛型方法用于返回包含以“saurus”结尾的所有元素的数组。 将显示元素。

该代码示例还演示了 Exists 和 TrueForAll 泛型方法。

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
*/

注解

Predicate<T> 是方法的委托，如果传递给该方法的对象与委托中定义的条件匹配，则返回 true。 array 的元素分别传递给 Predicate<T>，在 Array中向后移动，从最后一个元素开始，以第一个元素结尾。 找到匹配项时，将停止处理。

此方法是 O（n） 操作，其中 n 是 array的 Length。

适用于

另请参阅

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