Array.FindAll<T>(T[], Predicate<T>) Methode
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Ruft alle Elemente ab, die die vom angegebenen Prädikat definierten Bedingungen erfüllen.
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()Typparameter
- T
Der Typ der Elemente des Arrays.
Parameter
- array
- T[]
Das zu durchsuchende eindimensionale und nullbasierte Array.
- match
- Predicate<T>
Das Predicate<T>, das die Bedingungen für die Elemente definiert, nach denen gesucht werden soll.
Gibt zurück
T[]
Ein Array mit allen Elementen, die ggf. die durch das angegebene Prädikat definierten Bedingungen erfüllen, andernfalls ein leeres Array.
Ausnahmen
Beispiele
Im folgenden Beispiel wird ein Array von 50 Zufallszahlen mit Werten erstellt, die zwischen 0 und 1.000 liegen können. Anschließend wird die FindAll -Methode mit einem Lambdaausdruck aufgerufen, der die Werte zwischen 300 und 600 zurückgibt. Beachten Sie, dass dem Lambdaausdruck ein Parameter mit dem Namen xübergeben wird. Dieser stellt den einzelnen Arraymember dar, der an den Predicate<T>übergeben wird. Beachten Sie außerdem, dass auf die lokalen lBound Variablen und uBound innerhalb des Lambdaausdrucks zugegriffen werden kann.
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
Im folgenden Codebeispiel werden die Findgenerischen Methoden , FindLastund FindAll veranschaulicht. Es wird ein Array von Zeichenfolgen erstellt, das 8 Dinosauriernamen enthält, von denen zwei (an Position 1 und 5) mit "saurus" enden. Das Codebeispiel definiert auch eine Suchprädikatmethode namens EndsWithSaurus, die einen Zeichenfolgenparameter akzeptiert und einen booleschen Wert zurückgibt, der angibt, ob die Eingabezeichenfolge auf "saurus" endet.
Die Find generische Methode durchläuft das Array von Anfang an und übergibt jedes Element nacheinander an die EndsWithSaurus -Methode. Die Suche wird beendet, wenn die EndsWithSaurus Methode das Element "Amargasaurus" zurückgibt true .
Hinweis
In C#, F# und Visual Basic ist es nicht erforderlich, den Predicate<string> Delegaten (Predicate(Of String) in Visual Basic) explizit zu erstellen. Diese Sprachen leiten den richtigen Delegat aus dem Kontext ab und erstellen ihn automatisch.
Die FindLast generische Methode wird verwendet, um das Array rückwärts vom Ende aus zu durchsuchen. Es findet das Element "Dilophosaurus" an Position 5. Die FindAll generische Methode wird verwendet, um ein Array zurückzugeben, das alle Elemente enthält, die auf "saurus" enden. Die Elemente werden angezeigt.
Im Codebeispiel werden auch die Exists generischen Methoden und TrueForAll veranschaulicht.
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
Hinweise
Der Predicate<T> ist ein Delegat an eine Methode, die zurückgibt true , wenn das an sie übergebene Objekt den im Delegaten definierten Bedingungen entspricht. Die Elemente von array werden einzeln an das Predicate<T>übergeben, und die Elemente, die den Bedingungen entsprechen, werden im zurückgegebenen Array gespeichert.
Diese Methode ist ein O(n)-Vorgang, wobei n der Length von arrayist.
In F# kann stattdessen die Funktion Array.filter verwendet werden.
Gilt für:
Weitere Informationen
Arbeiten Sie mit uns auf GitHub zusammen
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
