Pausa para el café #209. 4 formas de encontrar duplicados en la lista de Java. Cómo crear un reproductor multimedia sencillo utilizando Java

4 formas de encontrar duplicados en la lista de Java

Fuente: Codippa Este artículo cubre varias formas de encontrar duplicados en una Lista. Llamamos duplicados a los elementos que aparecen más de una vez.

1. Usando Conjunto

A continuación se muestra un algoritmo para encontrar elementos duplicados en una lista de Java usando Set .

• Creamos un nuevo objeto Java Set y un nuevo ArrayList para almacenar elementos duplicados.
• Realizamos una iteración o bucle a través de la lista.
• Agregamos cada elemento de la lista al Conjunto usando el método add() .
• Como resultado, add() devuelve verdadero si el elemento fue agregado y falso si el elemento ya estaba presente en el Set .
• Si el elemento ya está en el Set , es un duplicado. Luego lo agregamos a ArrayList .
• Al final de la iteración, la nueva ArrayList contendrá todos los elementos duplicados de la Lista original ( List ).

A continuación se muestra un programa de ejemplo basado en este 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);

Conclusión: Tenga en cuenta que usamos el método forEach() para recorrer la Lista , pero puede usar cualquier otro método.

2. Usando el mapa

A continuación se detallan los pasos del algoritmo para este método de encontrar duplicados en una Lista .

• Cree un nuevo objeto Map y una nueva ArrayList para contener elementos duplicados.
• Las claves de este Mapa serán los elementos de la Lista original , y sus valores serán el número de sus apariciones en la Lista .
• Recorre la lista ( List ).
• Para cada elemento de la Lista , compruebe si existe como clave en el Mapa utilizando el método contieneKey() .
• Si existe, incremente su valor en el Mapa y agréguelo nuevamente usando el método put() .
• Si no existe, agréguelo al Mapa con un valor de 1.
• Una vez que se completa la iteración de la lista, todos los elementos del mapa con un valor mayor que 1 se duplican.
• Finalmente, itere el Mapa y agregue aquellos elementos cuyo valor sea mayor que 1 a una lista para almacenar elementos duplicados.

A continuación se muestra un programa de ejemplo:

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. Usar bucles anidados

Si se le pide que busque elementos duplicados en una lista sin utilizar ninguna clase de Colección como Set , Map , etc., este método le resultará útil. Etapas del algoritmo:

• Recorre la lista ( List ).
• Una vez que se haya completado el ciclo por primera vez, regrese al principio y repita los pasos nuevamente para encontrar cada elemento en el resto de la lista.
• Si el elemento del bucle actual es igual a cualquiera de los elementos restantes, es un duplicado.

Un programa escrito usando este algoritmo se ve así:

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. Usando Java Stream

Este método se basa en subprocesos de Java 8 y funciona así:

• Convertir lista en secuencia .
• Convierta la transmisión en un mapa usando el método Collect() . Por ejemplo, la clave es cada elemento de la lista y el valor es el número de apariciones.
• El método Collect() regresa y Map toma Collector como argumento. La implementación del Collector determina las claves y valores del Map resultante .
• Como queremos que las claves del Mapa sean los elementos de una Lista y sus valores sean el número de apariciones, podemos usar Collectors.groupingBy() para crear un recopilador .
• Una vez que se haya creado el mapa usando groupingBy() , use el método EntrySet() para obtener un conjunto de objetos Map.Entry .
• Filtrar registros según un valor (es decir, número de apariciones) mayor que 1.
• Relaciona los registros filtrados con sus claves.

Programa de ejemplo:

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

El método groupingBy() se utiliza para agrupar elementos de una colección según ciertos criterios. A continuación se muestra un ejemplo de cómo funciona este método:

• El criterio se proporciona como una expresión lambda porque groupingBy() toma un argumento Function , que es una interfaz de función.
• En este caso, agrupamos por función de identidad n -> n , lo que significa que agrupamos los elementos de la lista por sus valores.
• El segundo argumento de groupingBy() es otro recopilador que especifica cómo se deben combinar los elementos de cada grupo.
• Aquí usamos Collectors.counting() que crea un mapa que contiene el recuento de cada elemento de la lista.

Como resultado, el mapa resultante contendrá un recuento de cuántas veces aparece cada elemento en la lista. Luego filtramos el mapa usando el método filter() para encontrar elementos cuyo recuento sea mayor que 1, lo que indica que están duplicados.

Cómo crear un reproductor multimedia sencillo utilizando Java

Fuente: Medio Este tutorial lo ayudará a crear un reproductor multimedia simple en Java para reproducir archivos de audio y video. Desarrollar un reproductor multimedia puede ser una excelente manera de aprender a utilizar las bibliotecas integradas de Java para trabajar con archivos multimedia. Para realizar esta tarea, utilizaremos JavaFX y el kit de herramientas de interfaz gráfica de usuario (GUI) para Java.

Paso 1: configuración del proyecto

Primero, necesitamos configurar nuestro proyecto Java. Usaremos Eclipse como IDE, pero usted puede usar cualquier IDE de su elección. Cree un nuevo proyecto Java y asígnele el nombre "MediaPlayer". También necesitaremos agregar la biblioteca JavaFX a nuestro proyecto. Para hacer esto, vaya a las propiedades del proyecto y agregue la biblioteca JavaFX a la ruta de compilación del proyecto.

Paso 2: cree la interfaz de usuario

A continuación crearemos la interfaz de usuario para nuestro reproductor multimedia. Será una interfaz de usuario sencilla con un botón de reproducción, un botón de parada y un panel de reproductor multimedia que muestra el archivo de vídeo o audio que queremos reproducir. Para nuestra interfaz usaremos el diseño BorderPane . El panel del reproductor multimedia estará en el centro del BorderPane, y los botones de reproducción y parada estarán en la parte inferior del BorderPane. Aquí está el código de la interfaz de usuario:

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

En este código, creamos dos botones: playButton y stopButton . Cuando se hace clic en el botón de reproducción, llamamos al método play() del objeto mediaPlayer . Cuando se hace clic en el botón detener, llamamos al método stop() del objeto mediaPlayer . También creamos un objeto Media con la URL del archivo de vídeo de ejemplo y un objeto mediaPlayer con un objeto Media . Finalmente, creamos un objeto MediaView con un objeto MediaPlayer y lo configuramos como el centro del BorderPane .

Paso 3. Probar el reproductor multimedia

Ahora que tenemos configurada la interfaz de usuario del reproductor multimedia, podemos probarla iniciando la aplicación. Cuando iniciamos la aplicación, debería aparecer la interfaz de usuario del reproductor multimedia y podemos hacer clic en el botón de reproducción para comenzar a reproducir el archivo de video. También podemos hacer clic en el botón Detener para detener la reproducción del archivo de vídeo.

Paso 4: Configura tu reproductor multimedia

Ahora que tenemos un reproductor multimedia que funciona, podemos personalizarlo a nuestro gusto. Podemos cambiar el diseño de la interfaz de usuario, cambiar el archivo de vídeo que se está reproduciendo, agregar botones adicionales para ajustar el volumen o agregar una barra de progreso para mostrar el progreso del vídeo.