Array.FindAll<T>(T[], Predicate<T>) Metódus
Definíció
Fontos
Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.
Lekéri a megadott predikátum által meghatározott feltételeknek megfelelő összes elemet.
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()Típusparaméterek
- T
A tömb elemeinek típusa.
Paraméterek
- array
- T[]
Az egydimenziós, nulla alapú Array keresés.
- match
- Predicate<T>
Ez Predicate<T> határozza meg a keresendő elemek feltételeit.
Válaszok
A Array megadott predikátum által meghatározott feltételeknek megfelelő összes elemet tartalmazó elem, ha megtalálható; ellenkező esetben üres Array.
Kivételek
Példák
Az alábbi példa 50 véletlenszerű számból álló tömböt hoz létre 0 és 1000 közötti értékekkel. Ezután egy lambda kifejezéssel hívja meg a FindAll metódust, amely a 300 és 600 közötti értékeket adja vissza. Vegye figyelembe, hogy a lambda kifejezés egy névvel ellátott xparamétert ad át. Ez az adott tömbtagot jelöli, amelyet a rendszer ad át a Predicate<T>. Azt is vegye figyelembe, hogy a helyi lBound és uBound a változók elérhetők a lambda kifejezésben.
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
Az alábbi példakód a , Findés FindLast az FindAlláltalános metódusokat mutatja be. Létrejön egy sztringtömb, amely 8 dinoszaurusznevet tartalmaz, amelyek közül kettő (az 1. és az 5. pozícióban) "szinonimaszótár" végződéssel végződik. A példakód egy keresési predikátum metódust EndsWithSaurusis definiál, amely egy sztringparamétert fogad el, és logikai értéket ad vissza, amely jelzi, hogy a bemeneti sztring "szinonimaszótárban" végződik-e.
Az Find általános metódus az elejétől bejárja a tömböt, és minden elemet átad a EndsWithSaurus metódusnak. A keresés leáll, amikor a EndsWithSaurus metódus visszatér true az "Amargasaurus" elemhez.
Note
C#, F# és Visual Basic esetén nem szükséges explicit módon létrehozni a Predicate<string> delegáltat (Predicate(Of String) Visual Basic). Ezek a nyelvek a megfelelő delegáltat a környezetből következtetik, és automatikusan létrehozzák.
Az FindLast általános módszer a tömb a végétől visszafelé történő keresésre szolgál. A "Dilophosaurus" elemet az 5. pozícióban találja meg. Az FindAll általános metódus a "szinonimaszótárban" végződő összes elemet tartalmazó tömb visszaadására szolgál. Az elemek megjelennek.
A példakód az általános és Exists az TrueForAll általános metódusokat is bemutatja.
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
Megjegyzések
Ez Predicate<T> egy olyan metódus delegáltja, amely akkor ad vissza true , ha az átadott objektum megfelel a delegáltban meghatározott feltételeknek. A rendszer egyenként továbbítja az elemeket array a Predicate<T>, és a feltételeknek megfelelő elemeket a visszaadott tömbbe menti.
Ez a metódus egy O(n) művelet, ahol n a Length .array
Az F#-ban a Array.filter függvény használható helyette.
