Das Finden doppelter Elemente in einem Datenstrom ist eine der häufigsten Fragen in Java-Interviews und sogar vielen Studentenprüfungen. Java bietet eine Vielzahl von Methoden zum Auffinden doppelter Elemente. Wir konzentrieren uns hauptsächlich auf zwei Methoden: Die erste besteht darin, das Set des Java Collection Framework zu verwenden, und die andere darin, die integrierte Methode Collections.Frequency() des Streams zu verwenden .
Bevor wir die verschiedenen Methoden zum Abrufen von Duplikaten aus einer Datensammlung besprechen, ist es notwendig, die Methode filter() zu besprechen. Es wird ein wichtiger Teil des Beispielprogramms sein.
Es ermöglicht uns, die Elemente des Streams basierend auf bestimmten Bedingungen zu filtern. Es ist Teil einer Funktion höherer Ordnung, die ein bestimmtes Verhalten auf den Flussterm anwendet. Diese Methode verwendet ein Prädikat als Parameter und gibt eine Liste von Elementen zurück, die mit dem Prädikat übereinstimmen.
filter(predicate);
Es handelt sich um eine Unterschnittstelle des Java Collection Interface und erlaubt keine doppelten Werte. Es ist mathematischen Mengen sehr ähnlich. Wir können die Methode add() verwenden, die der Menge nur die unterschiedlichen Elemente hinzufügt. Um die Eigenschaften der Set-Schnittstelle nutzen zu können, müssen wir die HashSet-Klasse verwenden, die diese Schnittstelle implementiert.
Das folgende Beispiel veranschaulicht, wie Sie die Set-Schnittstelle verwenden, um doppelte Elemente aus einem Stream zu finden.
Verwenden Sie die Methode Arrays.asList(), um eine Liste zum Speichern einer Liste fester Größe zu erstellen.
Dann verwenden Sie die HashSet-Klasse, um ein Set zu definieren, um nur unterschiedliche Elemente zu speichern.
Verwenden Sie nun die Methode filter() zusammen mit stream() und forEach(), um nur doppelte Elemente herauszufiltern. Hier spezifiziert stream() die Eingabe in Form eines Streams und wir verwenden forEach(), um die wiederholten Elemente zu iterieren und auszugeben.
import java.util.*;
public class Duplicate {
public static void main(String []args) {
// create a list with duplicate items
List<Integer> itemsList = Arrays.asList(10, 12, 10, 33, 40, 40, 61, 61);
// declaring a new Set
Set<Integer> newitemSet = new HashSet<>();
System.out.println("The list of duplicate Items: ");
itemsList.stream() // converting list to stream
.filter(nums -> !newitemSet.add(nums)) // to filter out the elementsthat are not added to the set
.forEach(System.out::println); // print the duplicates
}
}
The list of duplicate Items: 10 40 61
Eine weitere einfachste Möglichkeit, doppelte Elemente aus einem Stream oder einer Sammlung zu filtern, ist die Verwendung der Collections.Frequency()-Methode des Pakets „java.util“, mit der die Gesamtzahl der Elemente in der angegebenen Sammlung zurückgegeben wird.
Collections.frequency(nameOfCollection, obj);
hier,
nameOfCollection stellt den Stream dar und obj stellt das Element dar, dessen Häufigkeit bestimmt werden muss.
Im folgenden Beispiel verwenden wir die Methode Collections.Frequency(), um das Vorkommen jedes Elements im Stream zu zählen und dann die Elemente zurückzugeben, die mehr als einmal vorkommen. Wir drucken die gesamte Liste des Vorkommens wiederholter Elemente zusammen mit der Anzahl aus.
import java.util.*;
public class FindDuplicates {
public static void main(String[] args) {
// create a list with duplicate items
List<Integer> itemslist = Arrays.asList(10, 12, 10, 10, 33, 40, 40, 61, 61);
System.out.println("The list of duplicate Items with frequency: ");
itemslist.stream() // converting list to stream
.filter(itr -> Collections.frequency(itemslist, itr) > 1) // checking the frequency of duplicate items
.forEach(System.out::println); // printing the frequency of duplicate items
System.out.println("Count of duplicate items: ");
// to count the duplicate items
System.out.println(itemslist.stream()
.filter(itr -> Collections.frequency(itemslist, itr) > 1)
.count());
}
}
The list of duplicate Items with frequency: 10 10 10 40 40 61 61 Count of duplicate items: 7
Hier ist ein weiteres Beispiel, bei dem wir sowohl die Set Interface- als auch die Collections.Frequency()-Methode verwenden, um nur doppelte Elemente abzurufen. Die Collections.Frequency()-Methode zählt die Vorkommen jedes Elements im Stream und sammelt dann Elemente mit einer Anzahl größer als 1 in einem Set, um Duplikate zu entfernen. Das resultierende Set enthält nur wiederholte Elemente aus dem Stream.
import java.util.stream.*;
import java.util.*;
public class FindDuplicates {
public static void main(String[] args) {
// create a list with duplicate items
List<Integer> itemslist = Arrays.asList(10, 12, 10, 10, 33,40, 40, 61, 61);
// set to store duplicate items
Set<Integer> duplicates = itemslist.stream()
.filter(itr -> Collections.frequency(itemslist, itr) > 1) // checking the frequency of duplicate items
.collect(Collectors.toSet()); // adding only duplicate items to set
// printing the duplicate items
System.out.println("The list of duplicate Items:" + duplicates);
}
}
The list of duplicate Items:[40, 10, 61]
In diesem Abschnitt schließen wir unsere Diskussion mit einigen Schlüsselpunkten aus den oben genannten Beispielen und Konzepten ab. Mit der Methode filter() können wir bestimmte Elementtypen aus der Datensammlung herausfiltern. Es funktioniert hinter den Kulissen, indem es auf jedes Element ein Prädikat anwendet. Die Fähigkeit von Set Interface, nur unterschiedliche Elemente zu speichern, macht es zu einer hervorragenden Wahl für eine bestimmte Aufgabe.
Das obige ist der detaillierte Inhalt vonSo finden Sie doppelte Elemente in einem Stream in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
