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

Définition

Espace de noms:

System

Assemblys:

netstandard.dll, System.Runtime.dll

Source:

Array.cs

Récupère tous les éléments qui correspondent aux conditions définies par le prédicat spécifié.

C#

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

Paramètres de type

T

Type des éléments du tableau.

Paramètres

array

T[]

Array de base zéro unidimensionnel à explorer.

match

Predicate<T>

Predicate<T> qui définit les conditions des éléments à rechercher.

Retours

T[]

Array contenant tous les éléments qui correspondent aux conditions définies par le prédicat spécifié, le cas échéant ; sinon, Array vide.

Exceptions

ArgumentNullException

array a la valeur null.

-ou-

match a la valeur null.

Exemples

L’exemple suivant crée un tableau de 50 nombres aléatoires dont les valeurs peuvent être comprises entre 0 et 1 000. Il appelle ensuite la FindAll méthode avec une expression lambda qui retourne les valeurs comprises entre 300 et 600. Notez que l’expression lambda est passée à un paramètre nommé x; il représente le membre de tableau individuel qui est passé à .Predicate<T> Notez également que les variables locales lBound et uBound sont accessibles dans l’expression lambda.

C#

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      // Get an array of n random integers.
      int[] values = GetArray(50, 0, 1000);
      int lBound = 300;
      int uBound = 600;
      int[] matchedItems = Array.FindAll(values, x =>
                                       x >= lBound && x <= uBound);
      for (int ctr = 0; ctr < matchedItems.Length; ctr++) {
         Console.Write("{0}  ", matchedItems[ctr]);
         if ((ctr + 1) % 12 == 0)
            Console.WriteLine();
      }
   }

   private static int[] GetArray(int n, int lower, int upper)
   {
      Random rnd = new Random();
      List<int> list = new List<int>();
      for (int ctr = 1; ctr <= n; ctr++)
         list.Add(rnd.Next(lower, upper + 1));

      return list.ToArray();
   }
}
// The example displays output similar to the following:
//       542  398  356  351  348  301  562  599  575  400  569  306
//       535  416  393  385

L’exemple de code suivant illustre les Findméthodes génériques , 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 Find méthode générique traverse le tableau depuis le début, passant chaque élément à son tour à la EndsWithSaurus méthode . La recherche s’arrête lorsque la EndsWithSaurus méthode retourne true l’élément « Amargasaurus ».

Note

En C#, F# et Visual Basic, il n’est pas nécessaire de créer explicitement le Predicate<string> délégué (Predicate(Of String) en Visual Basic). Ces langages déduisent le délégué correct à partir du contexte et le créent automatiquement.

La FindLast méthode générique est utilisée pour effectuer une recherche dans le tableau à partir de la fin. Il trouve l’élément « Dilophosaurus » à la position 5. La FindAll méthode générique 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 Exists méthodes génériques et TrueForAll .

C#

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

Remarques

est Predicate<T> un délégué à une méthode qui retourne true si l’objet qui lui a été transmis correspond aux conditions définies dans le délégué. Les éléments de array sont transmis individuellement au Predicate<T>, et les éléments qui correspondent aux conditions sont enregistrés dans le tableau retourné.

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

Dans F#, la fonction Array.filter peut être utilisée à la place.

S’applique à

Voir aussi

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