Array.FindAll<T>(T[], Predicate<T>) Metodo

Riferimento

Definizione

Spazio dei nomi:: System

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Recupera tutti gli elementi che soddisfano le condizioni definite nel predicato specificato.

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

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

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

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

Parametri di tipo

T

Tipo degli elementi della matrice.

Parametri

array: T[]

Oggetto Array unidimensionale in base zero in cui eseguire la ricerca.

match: Predicate<T>

Oggetto Predicate<T> che definisce le condizioni degli elementi da cercare.

Restituisce

T[]

Oggetto Array contenente tutti gli elementi che corrispondono alle condizioni definite dal predicato specificato, se presente; in caso contrario, un oggetto Array vuoto.

Eccezioni

ArgumentNullException

array è null.

-oppure-

match è null.

Esempio

Nell'esempio seguente viene creata una matrice di 50 numeri casuali con valori che possono variare da 0 a 1.000. Chiama quindi il FindAll metodo con un'espressione lambda che restituisce i valori compresi tra 300 e 600. Si noti che all'espressione lambda viene passato un parametro denominato x; rappresenta il singolo membro della matrice passato all'oggetto Predicate<T>. Si noti anche che le variabili e uBound locali lBound sono accessibili all'interno dell'espressione lambda.

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

open System

let getArray n lower upper =
    let rnd = Random()
    [|  for _ = 1 to n do 
            rnd.Next(lower, upper + 1) |]

// Get an array of n random integers.
let values = getArray 50 0 1000
let lBound = 300
let uBound = 600
let matchedItems = Array.FindAll(values, fun x -> x >= lBound && x <= uBound)

for i = 0 to matchedItems.Length - 1 do
    printf $"{matchedItems[i]}  "
    if (i + 1) % 12 = 0 then printfn ""

// The example displays output similar to the following:
//       542  398  356  351  348  301  562  599  575  400  569  306
//       535  416  393  385

Imports System.Collections.Generic

Module Example
   Public Sub Main()
      ' Get an array of n random integers.
      Dim values() As Integer = GetArray(50, 0, 1000)
      Dim lBound As Integer = 300
      Dim uBound As Integer = 600
      Dim matchedItems() As Integer = Array.FindAll(values, 
                                            Function(x) x >= lBound And x <= uBound)  
      For ctr As Integer = 0 To matchedItems.Length - 1
         Console.Write("{0}  ", matchedItems(ctr))
         If (ctr + 1) Mod 12 = 0 Then Console.WriteLine()
      Next
   End Sub
   
   Private Function GetArray(n As Integer, lower As Integer, 
                             upper As Integer) As Integer()
      Dim rnd As New Random()
      Dim list As New List(Of Integer)
      For ctr As Integer = 1 To n
         list.Add(rnd.Next(lower, upper + 1))
      Next
      Return list.ToArray()
   End Function
End Module
' The example displays output similar to the following:
'       542  398  356  351  348  301  562  599  575  400  569  306
'       535  416  393  385

Nell'esempio di codice seguente vengono illustrati i Findmetodi generici , FindLaste FindAll . Viene creata una matrice di stringhe contenente 8 nomi di dinosauro, due dei quali (in corrispondenza delle posizioni 1 e 5) terminano con "saurus". L'esempio di codice definisce anche un metodo di predicato di ricerca denominato EndsWithSaurus, che accetta un parametro stringa e restituisce un valore booleano che indica se la stringa di input termina in "saurus".

Il Find metodo generico attraversa la matrice dall'inizio, passando ogni elemento a sua volta al EndsWithSaurus metodo . La ricerca si interrompe quando il EndsWithSaurus metodo restituisce true l'elemento "Amargasaurus".

Nota

In C#, F# e Visual Basic non è necessario creare il Predicate<string> delegato (Predicate(Of String) in Visual Basic) in modo esplicito. Questi linguaggi deducono il delegato corretto dal contesto e lo creano automaticamente.

Il FindLast metodo generico viene usato per cercare la matrice all'indietro dalla fine. Trova l'elemento "Dilophosaurus" nella posizione 5. Il FindAll metodo generico viene usato per restituire una matrice contenente tutti gli elementi che terminano nel "saurus". Gli elementi vengono visualizzati.

L'esempio di codice illustra anche i Exists metodi generici e 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

Commenti

L'oggetto Predicate<T> è un delegato a un metodo che restituisce true se l'oggetto passato corrisponde alle condizioni definite nel delegato. Gli elementi di array vengono passati singolarmente a Predicate<T>e gli elementi corrispondenti alle condizioni vengono salvati nella matrice restituita.

Questo metodo è un'operazione O(n), dove n è l'oggetto Length di array.

In F# è possibile usare invece la funzione Array.filter .

Si applica a

Condividi tramite