Pausa caffè #209. 4 modi per trovare duplicati nell'elenco Java. Come creare un semplice lettore multimediale utilizzando Java

4 modi per trovare duplicati nell'elenco Java

Fonte: Codippa Questo articolo tratta vari modi per trovare duplicati in un elenco. Chiamiamo elementi duplicati che appaiono più di una volta.

1. Utilizzo di Imposta

Di seguito è riportato un algoritmo per trovare elementi duplicati in un elenco Java utilizzando Set .

• Creiamo un nuovo oggetto Java Set e un nuovo ArrayList per memorizzare elementi duplicati.
• Eseguiamo un'iterazione o eseguiamo il loop dell'elenco.
• Aggiungiamo ogni elemento dell'elenco al Set utilizzando il metodo add() .
• Di conseguenza, add() restituisce true se l'elemento è stato aggiunto e false se l'elemento era già presente in Set .
• Se l'elemento è già nel Set , è un duplicato. Quindi lo aggiungiamo a ArrayList .
• Al termine dell'iterazione, il nuovo ArrayList conterrà tutti gli elementi duplicati della List originale ( List ).

Di seguito è mostrato un programma di esempio basato su questo algoritmo.

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);

Conclusione: Tieni presente che abbiamo utilizzato il metodo forEach() per scorrere List , ma puoi utilizzare qualsiasi altro metodo.

2. Utilizzo della mappa

Di seguito sono riportati i passaggi dell'algoritmo per questo metodo di ricerca dei duplicati in un Elenco .

• Crea un nuovo oggetto Map e un nuovo ArrayList per contenere elementi duplicati.
• Le chiavi di questa Mappa saranno gli elementi della Lista originale , e i suoi valori saranno il numero delle loro occorrenze nella Lista .
• Passa in rassegna l'elenco ( List ).
• Per ogni elemento nella List , controlla se esiste come chiave nella Map utilizzando il metodo contieneKey() .
• Se esiste, incrementa il suo valore nella Map e aggiungilo nuovamente utilizzando il metodo put() .
• Se non esiste, aggiungilo alla mappa con un valore pari a 1.
• Una volta completata l'iterazione dell'elenco, tutti gli elementi della mappa con un valore maggiore di 1 diventano duplicati.
• Infine, itera la mappa e aggiungi gli elementi il ​​cui valore è maggiore di 1 a un elenco per memorizzare gli elementi duplicati.

Di seguito è mostrato un programma di esempio:

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. Utilizzo di cicli annidati

Se ti viene chiesto di trovare elementi duplicati in un elenco senza utilizzare alcuna classe Collection come Set , Map e così via, questo metodo sarà utile. Fasi dell'algoritmo:

• Passa in rassegna l'elenco ( List ).
• Dopo che il ciclo è stato completato la prima volta, torna all'inizio e ripeti nuovamente i passaggi per trovare ogni elemento nel resto dell'elenco.
• Se l'elemento del loop corrente è uguale a uno qualsiasi degli elementi rimanenti, è un duplicato.

Un programma scritto utilizzando questo algoritmo si presenta così:

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. Utilizzo di Java Stream

Questo metodo si basa sui thread Java 8 e funziona in questo modo:

• Converti elenco in flusso .
• Converti il ​​flusso in una mappa utilizzando il metodo collector() . Ad esempio, chiave è ogni elemento dell'elenco e valore è il numero di occorrenze.
• Il metodo Collect() restituisce e Map accetta Collector come argomento. L' implementazione del Collector determina le chiavi e i valori della Map risultante .
• Poiché vogliamo che le chiavi della Mappa siano gli elementi di una Lista e i suoi valori siano il numero delle loro occorrenze, possiamo usare Collectors.groupingBy() per creare un raccoglitore .
• Una volta creata la mappa utilizzando groupingBy() , utilizzare il metodo entrySet() per ottenere un set di oggetti Map.Entry .
• Filtra i record in base a un valore (ovvero il numero di occorrenze) maggiore di 1.
• Abbina i record filtrati alle rispettive chiavi.

Programma di esempio:

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());

Il metodo groupingBy() viene utilizzato per raggruppare gli elementi in una raccolta in base a determinati criteri. Ecco un esempio di come funziona questo metodo:

• Il criterio viene fornito come espressione lambda perché groupingBy() accetta un argomento Function , che è un'interfaccia di funzione.
• In questo caso, raggruppiamo per funzione identità n -> n , il che significa che raggruppiamo gli elementi della lista in base ai loro valori.
• Il secondo argomento di groupingBy() è un altro raccoglitore che specifica come devono essere combinati gli elementi di ciascun gruppo.
• Qui utilizziamo Collectors.counting() che crea una mappa contenente il conteggio di ciascun elemento nell'elenco.

Di conseguenza, la mappa risultante conterrà il conteggio di quante volte ciascun elemento appare nell'elenco. Quindi filtriamo la mappa utilizzando il metodo filter() per trovare elementi il ​​cui conteggio è maggiore di 1, indicando che sono duplicati.

Come creare un semplice lettore multimediale utilizzando Java

Fonte: Medium Questo tutorial ti aiuterà a creare un semplice lettore multimediale in Java per riprodurre file audio e video. Sviluppare un lettore multimediale può essere un ottimo modo per imparare a utilizzare le librerie integrate di Java per lavorare con i file multimediali. Per eseguire questa attività, utilizzeremo JavaFX e il toolkit Graphical User Interface (GUI) per Java.

Passaggio 1: impostazione del progetto

Per prima cosa dobbiamo impostare il nostro progetto Java. Utilizzeremo Eclipse come IDE, ma puoi utilizzare qualsiasi IDE di tua scelta. Crea un nuovo progetto Java e chiamalo "MediaPlayer". Dovremo anche aggiungere la libreria JavaFX al nostro progetto. Per fare ciò, vai alle proprietà del progetto e aggiungi la libreria JavaFX al percorso di compilazione del progetto.

Passaggio 2: creare l'interfaccia utente

Successivamente creeremo l'interfaccia utente per il nostro lettore multimediale. Sarà un'interfaccia utente semplice con un pulsante di riproduzione, un pulsante di arresto e un pannello del lettore multimediale che visualizzerà il file video o audio che vogliamo riprodurre. Per la nostra interfaccia utilizzeremo il layout BorderPane . Il pannello del lettore multimediale si troverà al centro del BorderPane e i pulsanti di riproduzione e interruzione si troveranno nella parte inferiore del BorderPane. Ecco il codice dell'interfaccia utente:

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 questo codice creiamo due pulsanti: playButton e stopButton . Quando si fa clic sul pulsante di riproduzione, chiamiamo il metodo play() dell'oggetto mediaPlayer . Quando si fa clic sul pulsante di arresto, chiamiamo il metodo stop() dell'oggetto mediaPlayer . Creiamo anche un oggetto Media con l'URL del file video di esempio e un oggetto mediaPlayer con un oggetto Media . Infine, creiamo un oggetto MediaView con un oggetto MediaPlayer e lo impostiamo come centro del BorderPane .

Passaggio 3. Testare il lettore multimediale

Ora che abbiamo configurato l'interfaccia utente del lettore multimediale, possiamo testarla avviando l'applicazione. Quando avviamo l'applicazione, dovrebbe apparire l'interfaccia utente del lettore multimediale e possiamo fare clic sul pulsante di riproduzione per avviare la riproduzione del file video. Possiamo anche fare clic sul pulsante Interrompi per interrompere la riproduzione del file video.

Passaggio 4: configurazione del lettore multimediale

Ora che abbiamo un lettore multimediale funzionante, possiamo personalizzarlo a nostro piacimento. Possiamo cambiare il layout dell'interfaccia utente, cambiare il file video riprodotto, aggiungere ulteriori pulsanti per regolare il volume o aggiungere una barra di avanzamento per mostrare l'avanzamento del video.