Kaffeepause Nr. 209. 4 Möglichkeiten, Duplikate in der Java-Liste zu finden. So erstellen Sie einen einfachen Media Player mit Java

4 Möglichkeiten, Duplikate in der Java-Liste zu finden

Quelle: Codippa Dieser Artikel behandelt verschiedene Möglichkeiten, Duplikate in einer Liste zu finden. Wir nennen Duplikate Elemente, die mehr als einmal vorkommen.

1. Verwenden von Set

Nachfolgend finden Sie einen Algorithmus zum Auffinden doppelter Elemente in einer Java- Liste mithilfe von Set .

• Wir erstellen ein neues Java- Set- Objekt und eine neue ArrayList , um doppelte Elemente zu speichern.
• Wir führen eine Iteration oder Schleife durch die Liste durch.
• Wir fügen jedes Element in der Liste mit der Methode add() zum Set hinzu .
• Als Ergebnis gibt add() true zurück , wenn das Element hinzugefügt wurde, und false, wenn das Element bereits im Set vorhanden war .
• Wenn das Element bereits im Set vorhanden ist , handelt es sich um ein Duplikat. Dann fügen wir es zur ArrayList hinzu .
• Am Ende der Iteration enthält die neue ArrayList alle doppelten Elemente aus der ursprünglichen Liste ( List ).

Ein Beispielprogramm, das auf diesem Algorithmus basiert, ist unten dargestellt.

List<Integer> numbers = List.of(1, 2, 3, 4, 3, 1, 2);
Set<Integer> set = new HashSet<>();
List<Object> duplicates = new ArrayList<>();
numbers.forEach(n -> {
  if (!set.add(n)) {
    duplicates.add(n);
  }
});
System.out.println("Duplicate elements: " + duplicates);

Abschluss: Beachten Sie, dass wir zum Durchlaufen der List die Methode forEach() verwendet haben , Sie können aber auch jede andere Methode verwenden.

2. Karte verwenden

Nachfolgend sind die Algorithmusschritte für diese Methode zum Suchen von Duplikaten in einer Liste aufgeführt .

• Erstellen Sie ein neues Map- Objekt und eine neue ArrayList , um doppelte Elemente aufzunehmen.
• Die Schlüssel dieser Map sind die Elemente der ursprünglichen List und ihre Werte sind die Anzahl ihrer Vorkommen in der List .
• Durchlaufen Sie die Liste ( List ).
• Überprüfen Sie für jedes Element in der Liste , ob es als Schlüssel in der Map vorhanden ist , indem Sie die Methode containsKey() verwenden .
• Wenn es existiert, erhöhen Sie seinen Wert in der Map und fügen Sie ihn erneut mit der Methode put() hinzu .
• Wenn es nicht vorhanden ist, fügen Sie es der Karte mit dem Wert 1 hinzu.
• Sobald die Listeniteration abgeschlossen ist, werden alle Map- Elemente mit einem Wert größer als 1 zu Duplikaten.
• Schließlich iterieren Sie die Map und fügen die Elemente, deren Wert größer als 1 ist, zu einer Liste hinzu, um doppelte Elemente zu speichern.

Ein Beispielprogramm ist unten dargestellt:

List<Integer> numbers = List.of(1, 2, 3, 4, 3, 1, 2);
Map<Integer, Integer> countMap = new HashMap<>();
List<Object> duplicates = new ArrayList<>();
numbers.forEach(n -> {
  if (countMap.containsKey(n)) {
    countMap.put(n, countMap.get(n) + 1);
  } else {
    countMap.put(n, 1);
  }
});
countMap.keySet().forEach(k -> {
  if(countMap.get(k)> 1) {
    duplicates.add(k);
  }
});

3. Verwendung verschachtelter Schleifen

Wenn Sie aufgefordert werden, doppelte Elemente in einer Liste zu finden, ohne Collection- Klassen wie Set , Map usw. zu verwenden, ist diese Methode hilfreich. Algorithmusstufen:

• Durchlaufen Sie die Liste ( List ).
• Nachdem die Schleife zum ersten Mal abgeschlossen wurde, kehren Sie zum Anfang zurück und wiederholen Sie die Schritte erneut, um jedes Element im Rest der Liste zu finden.
• Wenn das aktuelle Schleifenelement einem der übrigen Elemente entspricht, handelt es sich um ein Duplikat.

Ein mit diesem Algorithmus geschriebenes Programm sieht folgendermaßen aus:

List<Integer> numbers = List.of(1, 2, 3, 4, 3, 1, 2);
List<Object> duplicates = new ArrayList<>();
for (int i = 0; i < numbers.size() - 1; i++) {
  for (int j = i + 1; j < numbers.size(); j++) {
    if (numbers.get(i).equals(numbers.get(j))) {
      duplicates.add(numbers.get(i));
    }
  }
}

4. Verwendung von Java Stream

Diese Methode basiert auf Java 8-Threads und funktioniert folgendermaßen:

• Liste in Stream konvertieren .
• Konvertieren Sie den Stream mithilfe der Methode „collect()“ in eine Map . Beispielsweise ist „key“ jedes Element in der Liste und „value“ die Anzahl der Vorkommen.
• Die Methode „collect()“ gibt zurück und Map verwendet Collector als Argument. Die Collector- Implementierung bestimmt die Schlüssel und Werte der resultierenden Map .
• Da wir möchten, dass die Schlüssel der Map die Elemente einer Liste sind und ihre Werte die Anzahl ihrer Vorkommen darstellen, können wir Collectors.groupingBy() verwenden, um einen Collector zu erstellen .
• Sobald die Map mit groupingBy() erstellt wurde , verwenden Sie die Methode enterSet() , um einen Satz von Map.Entry- Objekten abzurufen .
• Filtern Sie Datensätze basierend auf einem Wert (d. h. der Anzahl der Vorkommen) größer als 1.
• Ordnen Sie die gefilterten Datensätze ihren Schlüsseln zu.

Beispielprogramm:

List<Integer> numbers = List.of(1, 2, 3, 4, 3, 1, 2);
Map<Object, Long> map = numbers.
                        stream().
                        collect(
                          Collectors.
                          groupingBy(n -> n, Collectors.counting())
                        );
List<Object> duplicates = map.
                          entrySet().
                          stream().
                          filter(e -> e.getValue() > 1).
                          map(e -> e.getKey()).
        collect(Collectors.toList());

Die Methode groupingBy() wird verwendet, um Elemente in einer Sammlung basierend auf bestimmten Kriterien zu gruppieren. Hier ist ein Beispiel dafür, wie diese Methode funktioniert:

• Das Kriterium wird als Lambda-Ausdruck bereitgestellt, da groupingBy() ein Funktionsargument akzeptiert , bei dem es sich um eine Funktionsschnittstelle handelt.
• In diesem Fall gruppieren wir nach der Identitätsfunktion n -> n , was bedeutet, dass wir die Listenelemente nach ihren Werten gruppieren.
• Das zweite Argument für groupingBy() ist ein weiterer Kollektor, der angibt, wie die Elemente in jeder Gruppe kombiniert werden sollen.
• Hier verwenden wir Collectors.counting() , das eine Map erstellt , die die Anzahl jedes Elements in der Liste enthält.

Infolgedessen enthält die resultierende Karte eine Zählung, wie oft jedes Element in der Liste erscheint. Anschließend filtern wir die Map mit der Methode filter(), um Elemente zu finden, deren Anzahl größer als 1 ist, was darauf hinweist, dass es sich um Duplikate handelt.

So erstellen Sie einen einfachen Media Player mit Java

Quelle: Medium Dieses Tutorial hilft Ihnen, einen einfachen Mediaplayer in Java zu erstellen, um Audio- und Videodateien abzuspielen. Die Entwicklung eines Mediaplayers kann eine großartige Möglichkeit sein, zu lernen, wie man die integrierten Java-Bibliotheken für die Arbeit mit Mediendateien nutzt. Um diese Aufgabe zu erfüllen, verwenden wir JavaFX und das Graphical User Interface (GUI)-Toolkit für Java.

Schritt 1: Projekteinrichtung

Zuerst müssen wir unser Java-Projekt einrichten. Wir verwenden Eclipse als IDE, Sie können jedoch jede IDE Ihrer Wahl verwenden. Erstellen Sie ein neues Java-Projekt und nennen Sie es „MediaPlayer“. Wir müssen unserem Projekt auch die JavaFX-Bibliothek hinzufügen. Gehen Sie dazu zu den Projekteigenschaften und fügen Sie die JavaFX-Bibliothek zum Build-Pfad des Projekts hinzu.

Schritt 2: Erstellen Sie die Benutzeroberfläche

Als nächstes erstellen wir die Benutzeroberfläche für unseren Mediaplayer. Es wird eine einfache Benutzeroberfläche mit einer Wiedergabetaste, einer Stopptaste und einem Mediaplayer-Panel sein, das die Video- oder Audiodatei anzeigt, die wir abspielen möchten. Für unsere Schnittstelle verwenden wir das BorderPane-Layout . Das Media Player-Feld befindet sich in der Mitte des BorderPane und die Wiedergabe- und Stoppschaltflächen befinden sich am unteren Rand des BorderPane. Hier ist der UI-Code:

import javafx.application.Application;
import javafx.scene.Scene;
import javafx.scene.control.Button;
import javafx.scene.layout.BorderPane;
import javafx.scene.media.Media;
import javafx.scene.media.MediaPlayer;
import javafx.scene.media.MediaView;
import javafx.stage.Stage;

public class MediaPlayerApp extends Application {

    private MediaPlayer mediaPlayer;

    @Override
    public void start(Stage primaryStage) throws Exception {
        primaryStage.setTitle("Media Player");

        Button playButton = new Button("Play");
        playButton.setOnAction(e -> mediaPlayer.play());

        Button stopButton = new Button("Stop");
        stopButton.setOnAction(e -> mediaPlayer.stop());

        BorderPane borderPane = new BorderPane();

        Media media = new Media("http://www.example.com/sample.mp4");
        mediaPlayer = new MediaPlayer(media);
        MediaView mediaView = new MediaView(mediaPlayer);
        borderPane.setCenter(mediaView);
        borderPane.setBottom(stopButton);
        borderPane.setRight(playButton);

        Scene scene = new Scene(borderPane, 600, 400);
        primaryStage.setScene(scene);
        primaryStage.show();
    }

    public static void main(String[] args) {
        launch(args);
    }
}

In diesem Code erstellen wir zwei Schaltflächen: playButton und stopButton . Wenn auf die Wiedergabeschaltfläche geklickt wird, rufen wir die Methode play() des mediaPlayer- Objekts auf . Wenn auf die Stopp-Schaltfläche geklickt wird, rufen wir die stop()- Methode des mediaPlayer- Objekts auf . Wir erstellen außerdem ein Media- Objekt mit der URL der Beispielvideodatei und ein mediaPlayer- Objekt mit einem Media- Objekt . Schließlich erstellen wir ein MediaView- Objekt mit einem MediaPlayer- Objekt und legen es als Mittelpunkt des BorderPane fest .

Schritt 3. Testen des Mediaplayers

Nachdem wir nun die Benutzeroberfläche des Media Players konfiguriert haben, können wir sie testen, indem wir die Anwendung starten. Wenn wir die Anwendung starten, sollte die Benutzeroberfläche des Media Players erscheinen und wir können auf die Wiedergabeschaltfläche klicken, um mit der Wiedergabe der Videodatei zu beginnen. Wir können auch auf die Stopp-Schaltfläche klicken, um die Wiedergabe der Videodatei zu stoppen.

Schritt 4: Einrichten Ihres Mediaplayers

Da wir nun über einen funktionierenden Mediaplayer verfügen, können wir ihn nach unseren Wünschen anpassen. Wir können das Layout der Benutzeroberfläche ändern, die abgespielte Videodatei ändern, zusätzliche Schaltflächen zum Anpassen der Lautstärke hinzufügen oder einen Fortschrittsbalken hinzufügen, um den Fortschritt des Videos anzuzeigen.