Pausa para café #209. 4 maneiras de encontrar duplicatas na lista Java. Como criar um reprodutor de mídia simples usando Java

4 maneiras de encontrar duplicatas na lista Java

Fonte: Codippa Este artigo aborda várias maneiras de localizar duplicatas em uma lista. Chamamos de elementos duplicados que aparecem mais de uma vez.

1. Usando Conjunto

Abaixo está um algoritmo para encontrar elementos duplicados em uma lista Java usando Set .

• Criamos um novo objeto Java Set e um novo ArrayList para armazenar elementos duplicados.
• Realizamos uma iteração ou loop pela lista.
• Adicionamos cada elemento da lista ao Conjunto usando o método add() .
• Como resultado, add() retorna true se o elemento foi adicionado e false se o elemento já estava presente no Set .
• Se o elemento já estiver no Set , é uma duplicata. Em seguida, adicionamos ao ArrayList .
• Ao final da iteração, o novo ArrayList conterá todos os elementos duplicados da Lista original ( List ).

Um exemplo de programa baseado neste algoritmo é mostrado abaixo.

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

Conclusão: Observe que usamos o método forEach() para iterar List , mas você pode usar qualquer outro método.

2. Usando Mapa

Abaixo estão as etapas do algoritmo para este método de localização de duplicatas em um List .

• Crie um novo objeto Map e um novo ArrayList para armazenar elementos duplicados.
• As chaves deste Mapa serão os elementos da Lista original , e seus valores serão o número de suas ocorrências na Lista .
• Percorra a lista ( List ).
• Para cada elemento da Lista , verifique se ele existe como chave no Mapa usando o método containsKey() .
• Caso exista, incremente seu valor no Mapa e adicione-o novamente utilizando o método put() .
• Se não existir, adicione-o ao Mapa com valor 1.
• Assim que a iteração da lista for concluída, todos os elementos do Mapa com valor maior que 1 se tornarão duplicados.
• Por fim, itere o Mapa e adicione os elementos cujo valor seja maior que 1 a uma lista para armazenar elementos duplicados.

Um exemplo de programa é mostrado abaixo:

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. Usando loops aninhados

Se você for solicitado a encontrar elementos duplicados em uma lista sem usar nenhuma classe Collection como Set , Map e assim por diante, esse método será útil. Etapas do algoritmo:

• Percorra a lista ( List ).
• Depois que o loop for concluído pela primeira vez, volte ao início e repita as etapas novamente para encontrar cada item no restante da lista.
• Se o elemento do loop atual for igual a qualquer um dos elementos restantes, será uma duplicata.

Um programa escrito usando este algoritmo se parece com isto:

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 é baseado em threads Java 8 e funciona assim:

• Converter lista em fluxo .
• Converta o fluxo em um mapa usando o método collect() . Por exemplo, chave é cada elemento da lista e valor é o número de ocorrências.
• O método collect() retorna e Map usa Collector como argumento. A implementação do Collector determina as chaves e os valores do Map resultante .
• Como queremos que as chaves do Mapa sejam os elementos de uma Lista e seus valores sejam o número de suas ocorrências, podemos usar Collectors.groupingBy() para criar um coletor .
• Depois que o mapa for criado usando groupingBy() , use o método entrySet() para obter um conjunto de objetos Map.Entry .
• Filtre registros com base em um valor (ou seja, número de ocorrências) maior que 1.
• Combine os registros filtrados com suas chaves.

Exemplo de programa:

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

O método groupingBy() é usado para agrupar itens em uma coleção com base em determinados critérios. Aqui está um exemplo de como esse método funciona:

• O critério é fornecido como uma expressão lambda porque groupingBy() aceita um argumento Function , que é uma interface de função.
• Neste caso, agrupamos por função de identidade n -> n , o que significa que agrupamos os elementos da lista pelos seus valores.
• O segundo argumento para groupingBy() é outro coletor que especifica como os elementos de cada grupo devem ser combinados.
• Aqui usamos Collectors.counting() que cria um Mapa contendo a contagem de cada elemento da lista.

Como resultado, o Mapa resultante conterá uma contagem de quantas vezes cada elemento aparece na lista. Em seguida, filtramos o mapa usando o método filter() para encontrar elementos cuja contagem seja maior que 1, indicando que são duplicados.

Como criar um reprodutor de mídia simples usando Java

Fonte: Médio Este tutorial irá ajudá-lo a criar um reprodutor de mídia simples em Java para reproduzir arquivos de áudio e vídeo. Desenvolver um reprodutor de mídia pode ser uma ótima maneira de aprender como usar as bibliotecas integradas do Java para trabalhar com arquivos de mídia. Para realizar esta tarefa, usaremos JavaFX e o kit de ferramentas Graphical User Interface (GUI) para Java.

Etapa 1: configuração do projeto

Primeiro, precisamos configurar nosso projeto Java. Usaremos o Eclipse como IDE, mas você pode usar qualquer IDE de sua escolha. Crie um novo projeto Java e nomeie-o “MediaPlayer”. Também precisaremos adicionar a biblioteca JavaFX ao nosso projeto. Para fazer isso, acesse as propriedades do projeto e adicione a biblioteca JavaFX ao caminho de construção do projeto.

Etapa 2: Crie a interface do usuário

A seguir criaremos a interface do usuário para nosso reprodutor de mídia. Será uma interface de usuário simples com um botão play, um botão stop e um painel media player que exibe o arquivo de vídeo ou áudio que queremos reproduzir. Para nossa interface usaremos o layout BorderPane . O painel do media player estará no centro do BorderPane, e os botões reproduzir e parar estarão na parte inferior do BorderPane. Aqui está o código da IU:

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

Neste código, criamos dois botões: playButton e stopButton . Quando o botão play é clicado, chamamos o método play() do objeto mediaPlayer . Quando o botão parar é clicado, chamamos o método stop() do objeto mediaPlayer . Também criamos um objeto Media com a URL do arquivo de vídeo de exemplo e um objeto mediaPlayer com um objeto Media . Finalmente, criamos um objeto MediaView com um objeto MediaPlayer e o definimos como o centro do BorderPane .

Etapa 3. Testando o reprodutor de mídia

Agora que configuramos a interface do media player, podemos testá-la iniciando o aplicativo. Ao iniciar o aplicativo, a interface do media player deve aparecer e podemos clicar no botão play para iniciar a reprodução do arquivo de vídeo. Também podemos clicar no botão Parar para interromper a reprodução do arquivo de vídeo.

Passo 4: Configurando seu reprodutor de mídia

Agora que temos um reprodutor de mídia funcional, podemos personalizá-lo ao nosso gosto. Podemos alterar o layout da interface do usuário, alterar o arquivo de vídeo que está sendo reproduzido, adicionar botões adicionais para ajustar o volume ou adicionar uma barra de progresso para mostrar o progresso do vídeo.