Stream.filter() ist eine Methode in Java, die wir bei der Arbeit mit Streams verwenden. Es durchläuft alle vorhandenen Elemente und entfernt oder filtert alle Elemente heraus, die nicht mit der angegebenen Bedingung über ein signifikantes Argument übereinstimmen. Dies ist im Grunde ein Vorgang, der zwischen der Stream-Schnittstelle stattfindet. Die Funktion gibt einen Ausgabestream zurück, dessen Elemente des Eingabestreams den angegebenen Bedingungen entsprechen.
Starten Sie Ihren kostenlosen Softwareentwicklungskurs
Webentwicklung, Programmiersprachen, Softwaretests und andere
Das mit filter() übergebene Argument ist ein zustandsloses Prädikat und gilt für jedes einzelne Element, um zu identifizieren, ob es einbezogen werden soll oder nicht. Wir können den Lambda-Ausdruck auch hierüber übergeben, da das Prädikat in die Kategorie der funktionalen Schnittstelle fällt. Die Ausgabe enthält einen neuen Stream, der für alle anderen für jeden Stream relevanten Vorgänge verwendet werden kann.
Syntax:
Stream<T> filter(Predicate<? super T> condition)d
Prädikat stellt eine funktionale Schnittstelle dar und zeigt die Bedingung an, die wir verwenden, um Elemente herauszufiltern, die nicht mit dem Stream übereinstimmen.
Lassen Sie uns einige Beispiele anführen, um die Funktionalität der Java-Funktion stream() zu verstehen.
Code:
import java.util.Arrays;
import java.util.List;
public class Main
{
public static void main(String[] args)
{
List<Integer> arr = Arrays.asList(11, 12, 13, 14, 15, 16, 17, 18, 19, 20);
arr.stream()
.filter(i -> i % 3 == 0)
.forEach(System.out::println);
}
}Ausgabe:
Erklärung: Dies ist ein sehr einfaches und einfaches Beispiel, das zeigt, wie die Java-Stream-Filterfunktion verwendet wird. In diesem Beispiel deklarieren wir ein Array von Zufallszahlen und weisen sie einer Liste zu. Dann verwenden wir den Stream-Filter, um alle Elemente im angegebenen Array herauszufiltern, die die angegebene Bedingung erfüllen, d. h. alle Zahlen im Array, die einen Modul von 3 als 0 ergeben, werden gefiltert und in der Ausgabe angezeigt.
Code:
import java.util.Arrays;
import java.util.List;
import java.util.function.Predicate;
public class Main
{
public static void main(String[] args)
{
List<Integer> arr = Arrays.asList(21, 22, 23, 24, 25, 26, 27, 28, 29, 30);
Predicate<Integer> condition = new Predicate<Integer>()
{
@Override
public boolean test(Integer i) {
if (i % 4 == 0) {
return true;
}
return false;
}
};
arr.stream().filter(condition).forEach(System.out::println);
}
}Ausgabe:
Erklärung: In diesem Beispiel deklarieren wir zunächst ein Eingabearray, das aus einer zufälligen Menge von Zahlen besteht, und weisen ihnen eine Liste zu. Hier zeigen wir auch, wie man ein Prädikat zusammen mit der Stream-Filterfunktion verwendet und deklariert, indem man zunächst ein gleichnamiges Objekt mit dem Namen „Bedingung“ erstellt. Dann wird eine Klasse des Namenstests mit dem Eingabeparameter Integer I erstellt, in der wir den Modulus von 4 des gegebenen Arrays überprüfen. Diese Funktion gibt einen booleschen Wert von „true“ zurück, wenn Module von 4 0 zurückgeben, andernfalls „false“. Unter Verwendung dieses Rückgabewerts wird die Stream-Funktion dann verwendet, um die Elemente aus dem Array abzurufen, deren Bedingung wahr ist.
Code:
import java.util.*;
public class Example {
public static void main(String[] args) {
//Array creation
List<String> arr1 = Arrays.asList("trial", "simple", "node");
//Calling usingFiltOutput function
List<String> op = usingFiltOutput(arr1, "node");
//for loop to print array
for (String arr : op) {
System.out.print(arr);
System.out.print("\n");
}
}
private static List<String> usingFiltOutput(List<String> arr2, String filter) {
List<String> op = new ArrayList<>();
for (String arr1 : arr2) {
if (!"node".equals(arr1)) {
op.add(arr1);
}
}
return op;
}
}Ausgabe:
Erklärung: Im obigen Beispiel zeigen wir die Filterung von Array-Elementen, wobei wir das Element „Knoten“ mithilfe der Stream-Filtermethode filtern
Code:
import java.util.ArrayList;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Car> listCar = new ArrayList<>();
listCar.add(new Car("Maruti", 350000));
listCar.add(new Car("Toyota", 400000));
listCar.add(new Car("Mahindra", 500000));
listCar.add(new Car("Honda", 600000));
// displaying all cars with cost more than 4lakh
listCar.stream().filter(c -> (c.getID() > 400000))
.forEach(c -> System.out.println(c.getCompany()));
}
}
class Car {
private String company;
private int ID;
public Car() {
}
public Car(String n, int a) {
this.company = n;
this.ID = a;
}
public String getCompany() {
return company;
}
public void setCompany(String company) {
this.company = company;
}
public int getID() {
return ID;
}
public void setID(int ID) {
this.ID = ID;
}
}Ausgabe:
Erklärung: In diesem Beispiel sehen wir eine Art Echtzeitanwendung, bei der die Liste verschiedener Autofirmen und deren Grundkosten wie gezeigt einer Array-Liste zugewiesen wurden. Anschließend definieren wir im Folgenden einige Methoden, um die einzelnen Werte aus der Array-Liste abzurufen. Die getcost-Methode wird verwendet, um die Kosten für dieses bestimmte Auto abzurufen, und getCompany wird verwendet, um den Firmennamen aus der Eingabearray-Liste abzurufen. Dann verwenden wir in der Hauptfunktion die Java-Stream-Filterfunktion, um nur die Namen der Autofirmen abzurufen, deren ungefähre Kosten über 400.000 Rupien liegen.
Code:
import java.util.*;
import java.util.stream.Collectors;
class Example{
int pro_id;
String pro_name;
float pro_cost;
public Example(int pro_id, String pro_name, float pro_cost) {
this.pro_id = pro_id;
this.pro_name = pro_name;
this.pro_cost = pro_cost;
}
}
public class JavaStreamExample {
public static void main(String[] args) {
List<Example> productsList = new ArrayList<Example>();
//Here we are listing the products
productsList.add(new Example(1,"Shirt",1500f));
productsList.add(new Example(2,"Long Sleeve Top",1000f));
productsList.add(new Example(3,"Crop Top",1600f));
productsList.add(new Example(4,"Jeans",2100f));
productsList.add(new Example(5,"Skirt",1800f));
List<Float> pricesList = productsList.stream()
.filter(p ->p.pro_cost> 1500)
.map(pm ->pm.pro_cost)
.collect(Collectors.toList());
System.out.println(pricesList);
}
}Ausgabe:
Erklärung: In diesem Beispiel deklarieren wir zunächst einige Parameter zu den Produkten eines Bekleidungsgeschäfts, wie z. B. Produkt-ID, Name und Kosten. Und indem wir die ArrayList verwenden, fügen wir ihr bestimmte Produkte zusammen mit ihren Parametern hinzu. Am Ende filtern wir mithilfe des Java-Stream-Filters einige Produkte heraus, deren Kosten über 1500 Rupien liegen. Dies zeigt eine Echtzeitanwendung dieser Methode.
Wir haben alle möglichen Kombinationen gesehen, mit denen der Java-Stream-Filter verwendet werden kann, um bestimmte Elemente im Array basierend auf der von uns angegebenen Bedingung herauszufiltern. Es kann je nach Anforderung auch mit Java-Streams, Array-Listen, Sammlungen und vielen anderen kombiniert werden.
Das obige ist der detaillierte Inhalt vonJava-Stream-Filter. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
