Pause café #209. 4 façons de rechercher des doublons dans la liste Java. Comment créer un lecteur multimédia simple à l'aide de Java

4 façons de rechercher des doublons dans la liste Java

Source : Codippa Cet article couvre différentes manières de rechercher des doublons dans une liste. Nous appelons des éléments en double qui apparaissent plus d’une fois.

1. Utilisation de l'ensemble

Vous trouverez ci-dessous un algorithme permettant de rechercher des éléments en double dans une liste Java à l'aide de Set .

• Nous créons un nouvel objet Java Set et un nouveau ArrayList pour stocker les éléments en double.
• Nous effectuons une itération ou une boucle dans la liste.
• Nous ajoutons chaque élément de la liste au Set en utilisant la méthode add() .
• Par conséquent, add() renvoie true si l'élément a été ajouté et false si l'élément était déjà présent dans le Set .
• Si l'élément est déjà dans le Set , il s'agit d'un doublon. Ensuite, nous l'ajoutons à ArrayList .
• À la fin de l'itération, la nouvelle ArrayList contiendra tous les éléments en double de la List d'origine ( List ).

Un exemple de programme basé sur cet algorithme est présenté ci-dessous.

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

Conclusion: Notez que nous avons utilisé la méthode forEach() pour parcourir List , mais vous pouvez utiliser n’importe quelle autre méthode.

2. Utiliser la carte

Vous trouverez ci-dessous les étapes de l'algorithme pour cette méthode de recherche de doublons dans un List .

• Créez un nouvel objet Map et un nouveau ArrayList pour contenir les éléments en double.
• Les clés de cette Map seront les éléments de la List d'origine , et ses valeurs seront le nombre de leurs occurrences dans la List .
• Parcourez la liste ( Liste ).
• Pour chaque élément de la List , vérifiez s'il existe en tant que clé dans la Map à l'aide de la méthode containKey() .
• S'il existe, incrémentez sa valeur dans la Map et ajoutez-la à nouveau en utilisant la méthode put() .
• S'il n'existe pas, ajoutez-le à la Carte avec une valeur de 1.
• Une fois l'itération de la liste terminée, tous les éléments Map ayant une valeur supérieure à 1 deviennent des doublons.
• Enfin, parcourez la carte et ajoutez les éléments dont la valeur est supérieure à 1 à une liste pour stocker les éléments en double.

Un exemple de programme est présenté ci-dessous :

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. Utiliser des boucles imbriquées

Si vous êtes invité à rechercher des éléments en double dans une liste sans utiliser de classes Collection telles que Set , Map , etc., cette méthode sera utile. Étapes de l'algorithme :

• Parcourez la liste ( Liste ).
• Une fois la boucle terminée une première fois, revenez au début et répétez les étapes pour retrouver chaque élément dans le reste de la liste.
• Si l’élément de boucle actuel est égal à l’un des éléments restants, il s’agit d’un doublon.

Un programme écrit à l'aide de cet algorithme ressemble à ceci :

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. Utilisation du flux Java

Cette méthode est basée sur les threads Java 8 et fonctionne comme ceci :

• Convertir la liste en flux .
• Convertissez le flux en Map à l'aide de la méthode collect() . Par exemple, key correspond à chaque élément de la liste et value correspond au nombre d'occurrences.
• La méthode collect() renvoie et Map prend Collector comme argument. L' implémentation Collector détermine les clés et les valeurs du Map résultant .
• Puisque nous voulons que les clés de la Map soient les éléments d'une List et que ses valeurs soient le nombre de leurs occurrences, nous pouvons utiliser Collectors.groupingBy() pour créer un collector .
• Une fois la carte créée à l'aide de groupingBy() , utilisez la méthode EntrySet() pour obtenir un ensemble d' objets Map.Entry .
• Filtrez les enregistrements en fonction d'une valeur (c'est-à-dire le nombre d'occurrences) supérieure à 1.
• Faites correspondre les enregistrements filtrés avec leurs clés.

Exemple de programme :

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

La méthode groupingBy() est utilisée pour regrouper les éléments d’une collection en fonction de certains critères. Voici un exemple du fonctionnement de cette méthode :

• Le critère est fourni sous forme d'expression lambda car groupingBy() prend un Function argument , qui est une interface de fonction.
• Dans ce cas, nous regroupons par fonction d'identité n -> n , ce qui signifie que nous regroupons les éléments de la liste par leurs valeurs.
• Le deuxième argument de groupingBy() est un autre collecteur qui spécifie comment les éléments de chaque groupe doivent être combinés.
• Ici, nous utilisons Collectors.counting() qui crée une carte contenant le nombre de chaque élément de la liste.

En conséquence, la carte résultante contiendra le nombre de fois où chaque élément apparaît dans la liste. Nous filtrons ensuite la carte à l'aide de la méthode filter() pour trouver les éléments dont le nombre est supérieur à 1, indiquant qu'il s'agit de doublons.

Comment créer un lecteur multimédia simple à l'aide de Java

Source : Medium Ce tutoriel vous aidera à créer un simple lecteur multimédia en Java pour lire des fichiers audio et vidéo. Développer un lecteur multimédia peut être un excellent moyen d'apprendre à utiliser les bibliothèques intégrées de Java pour travailler avec des fichiers multimédias. Pour accomplir cette tâche, nous utiliserons JavaFX et la boîte à outils de l'interface utilisateur graphique (GUI) pour Java.

Étape 1 : Configuration du projet

Tout d’abord, nous devons configurer notre projet Java. Nous utiliserons Eclipse comme IDE, mais vous pouvez utiliser n'importe quel IDE de votre choix. Créez un nouveau projet Java et nommez-le « MediaPlayer ». Nous devrons également ajouter la bibliothèque JavaFX à notre projet. Pour ce faire, accédez aux propriétés du projet et ajoutez la bibliothèque JavaFX au chemin de construction du projet.

Étape 2 : Créer l'interface utilisateur

Ensuite, nous allons créer l'interface utilisateur de notre lecteur multimédia. Ce sera une interface utilisateur simple avec un bouton de lecture, un bouton d'arrêt et un panneau de lecteur multimédia qui affiche le fichier vidéo ou audio que nous voulons lire. Pour notre interface, nous utiliserons la disposition BorderPane . Le panneau du lecteur multimédia sera au centre du BorderPane et les boutons de lecture et d'arrêt seront en bas du BorderPane. Voici le code de l'interface utilisateur :

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

Dans ce code, nous créons deux boutons : playButton et stopButton . Lorsque l'on clique sur le bouton de lecture, nous appelons la méthode play() de l' objet mediaPlayer . Lorsque l'on clique sur le bouton stop, nous appelons la méthode stop() de l' objet mediaPlayer . Nous créons également un objet Media avec l'URL de l'exemple de fichier vidéo et un objet mediaPlayer avec un objet Media . Enfin, nous créons un objet MediaView avec un objet MediaPlayer et le définissons comme centre du BorderPane .

Étape 3. Test du lecteur multimédia

Maintenant que l'interface utilisateur du lecteur multimédia est configurée, nous pouvons la tester en lançant l'application. Lorsque nous lançons l'application, l'interface utilisateur du lecteur multimédia devrait apparaître et nous pouvons cliquer sur le bouton de lecture pour commencer la lecture du fichier vidéo. Nous pouvons également cliquer sur le bouton d'arrêt pour arrêter la lecture du fichier vidéo.

Étape 4 : Configuration de votre lecteur multimédia

Maintenant que nous disposons d'un lecteur multimédia fonctionnel, nous pouvons le personnaliser à notre guise. Nous pouvons changer la disposition de l'interface utilisateur, changer le fichier vidéo en cours de lecture, ajouter des boutons supplémentaires pour régler le volume ou ajouter une barre de progression pour montrer la progression de la vidéo.