Como Verificar se uma Coleção Contém Duplicatas em Java

Introdução

Neste laboratório, você aprenderá como verificar eficientemente a existência de elementos duplicados dentro de uma coleção Java. Exploraremos o uso de HashSet, uma ferramenta poderosa do Java Collections Framework, para identificar duplicatas.

Através de passos práticos, você aprenderá primeiro como aproveitar a propriedade de elementos únicos do HashSet para detectar duplicatas. Em seguida, descobrirá um método alternativo comparando os tamanhos da coleção original e um HashSet criado a partir dela. Finalmente, examinaremos como lidar com elementos nulos ao verificar duplicatas.

Usar HashSet para Verificação de Duplicatas

Nesta etapa, exploraremos como usar um HashSet em Java para verificar eficientemente a existência de elementos duplicados dentro de uma coleção. HashSet faz parte do Java Collections Framework e é particularmente útil porque armazena elementos únicos e fornece pesquisas muito rápidas.

Primeiro, vamos criar um novo arquivo Java chamado DuplicateCheck.java no seu diretório ~/project. Você pode fazer isso diretamente no WebIDE File Explorer, clicando com o botão direito na área da lista de arquivos e selecionando "New File" (Novo Arquivo), em seguida, digitando DuplicateCheck.java.

Agora, abra o arquivo DuplicateCheck.java no Code Editor e adicione o seguinte código:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateCheck {

    public static void main(String[] args) {
        // Create a list with some duplicate elements
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Alice"); // Duplicate
        names.add("Charlie");
        names.add("Bob"); // Duplicate

        System.out.println("Original List: " + names);

        // Use a HashSet to find duplicates
        Set<String> uniqueNames = new HashSet<>();
        Set<String> duplicates = new HashSet<>();

        for (String name : names) {
            if (!uniqueNames.add(name)) {
                // If add returns false, the element is already in the set
                duplicates.add(name);
            }
        }

        System.out.println("Duplicates found: " + duplicates);
    }
}

Vamos detalhar as novas partes deste código:

• import java.util.ArrayList;, import java.util.HashSet;, import java.util.List;, import java.util.Set;: Estas linhas importam as classes necessárias da biblioteca de utilidades Java para trabalhar com listas e conjuntos.
• List<String> names = new ArrayList<>();: Isso cria uma List chamada names que pode conter objetos String. Usamos ArrayList como uma implementação específica da interface List.
• names.add(...): Isso adiciona elementos à nossa lista names. Observe que "Alice" e "Bob" são adicionados duas vezes.
• Set<String> uniqueNames = new HashSet<>();: Isso cria um Set chamado uniqueNames usando a implementação HashSet. Um Set garante que conterá apenas elementos únicos.
• Set<String> duplicates = new HashSet<>();: Isso cria outro Set para armazenar os elementos duplicados que encontramos.
• for (String name : names): Este é um loop for-each que itera por cada name na lista names.
• if (!uniqueNames.add(name)): O método add() de um HashSet retorna true se o elemento foi adicionado com sucesso (o que significa que ele não estava no conjunto), e false se o elemento já estava presente. O ! nega o resultado, então o código dentro do bloco if é executado somente quando add() retorna false, indicando uma duplicata.
• duplicates.add(name);: Se uma duplicata for encontrada, adicionamos ao nosso conjunto duplicates.

Salve o arquivo DuplicateCheck.java (Ctrl+S ou Cmd+S).

Agora, abra o Terminal na parte inferior do WebIDE. Certifique-se de estar no diretório ~/project. Você pode confirmar isso digitando pwd e pressionando Enter. A saída deve ser /home/labex/project.

Compile o programa Java usando o comando javac:

javac DuplicateCheck.java

Se não houver erros, você não deverá ver nenhuma saída. Isso significa que a compilação foi bem-sucedida e um arquivo DuplicateCheck.class foi criado no diretório ~/project. Você pode verificar isso executando o comando ls.

Finalmente, execute o programa Java compilado usando o comando java:

java DuplicateCheck

Você deve ver uma saída semelhante a esta:

Original List: [Alice, Bob, Alice, Charlie, Bob]
Duplicates found: [Alice, Bob]

A ordem dos elementos na saída "Duplicates found" pode variar porque HashSet não mantém a ordem de inserção.

Você usou com sucesso um HashSet para identificar elementos duplicados em uma lista!

Comparar os Tamanhos da Coleção e do Set

Na etapa anterior, usamos um HashSet para encontrar elementos duplicados. Uma característica chave de um Set é que ele armazena apenas elementos únicos. Isso significa que, se você adicionar elementos duplicados a um Set, apenas uma instância de cada elemento será mantida. Essa propriedade é muito útil para tarefas como remover duplicatas de uma lista.

Nesta etapa, modificaremos nosso programa DuplicateCheck.java para demonstrar essa propriedade, comparando o tamanho da lista original (que pode conter duplicatas) com o tamanho de um HashSet criado a partir dessa lista (que conterá apenas elementos únicos).

Abra o arquivo DuplicateCheck.java no Code Editor do WebIDE.

Modifique o método main para que se pareça com isto:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateCheck {

    public static void main(String[] args) {
        // Create a list with some duplicate elements
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Alice"); // Duplicate
        names.add("Charlie");
        names.add("Bob"); // Duplicate
        names.add("David");

        System.out.println("Original List: " + names);
        System.out.println("Size of Original List: " + names.size());

        // Create a HashSet from the list
        Set<String> uniqueNamesSet = new HashSet<>(names);

        System.out.println("Set created from List: " + uniqueNamesSet);
        System.out.println("Size of Set: " + uniqueNamesSet.size());

        // The difference in size tells us how many duplicates were removed
        int duplicatesCount = names.size() - uniqueNamesSet.size();
        System.out.println("Number of duplicates (excluding first occurrence): " + duplicatesCount);
    }
}

Aqui está o que adicionamos ou alteramos:

• Adicionamos outro nome, "David", à lista names para ter uma lista um pouco maior.
• System.out.println("Size of Original List: " + names.size());: Imprimimos o tamanho da lista original usando o método size().
• Set<String> uniqueNamesSet = new HashSet<>(names);: Esta é uma maneira conveniente de criar um HashSet diretamente de outra Collection (como nosso ArrayList). Quando você faz isso, o HashSet adiciona automaticamente todos os elementos da lista e, como é um Set, ele descartará quaisquer duplicatas.
• System.out.println("Size of Set: " + uniqueNamesSet.size());: Imprimimos o tamanho do HashSet. Este tamanho representa o número de elementos únicos.
• int duplicatesCount = names.size() - uniqueNamesSet.size();: Calculamos a diferença entre o tamanho da lista e o tamanho do conjunto. Essa diferença nos diz quantos elementos eram duplicatas (além de sua primeira aparição).

Salve o arquivo DuplicateCheck.java modificado.

Agora, compile o programa novamente no Terminal:

javac DuplicateCheck.java

Se a compilação for bem-sucedida, execute o programa:

java DuplicateCheck

Você deve ver uma saída semelhante a esta:

Original List: [Alice, Bob, Alice, Charlie, Bob, David]
Size of Original List: 6
Set created from List: [Alice, Bob, Charlie, David]
Size of Set: 4
Number of duplicates (excluding first occurrence): 2

Observe que o tamanho da lista original é 6, mas o tamanho do HashSet criado a partir dela é 4. A diferença (6 - 4 = 2) indica corretamente que havia dois nomes duplicados ("Alice" e "Bob" cada um apareceu uma vez após sua primeira ocorrência).

Isso demonstra como você pode usar facilmente um HashSet para encontrar o número de elementos únicos ou o número de duplicatas em uma coleção.

Testar com Elementos Nulos

Nas etapas anteriores, vimos como o HashSet lida com elementos duplicados não nulos. Agora, vamos explorar como o HashSet se comporta quando tentamos adicionar elementos null. Entender como as coleções lidam com null é importante porque, às vezes, pode levar a comportamentos ou erros inesperados se não for tratado com cuidado.

Um HashSet permite um elemento null. Se você tentar adicionar null várias vezes, apenas o primeiro null será armazenado.

Vamos modificar nosso programa DuplicateCheck.java mais uma vez para testar isso.

Abra o arquivo DuplicateCheck.java no Code Editor do WebIDE.

Modifique o método main para incluir valores null na lista:

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class DuplicateCheck {

    public static void main(String[] args) {
        // Create a list with some duplicate and null elements
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add(null); // Add null
        names.add("Alice"); // Duplicate
        names.add("Charlie");
        names.add(null); // Add null again
        names.add("Bob"); // Duplicate
        names.add("David");
        names.add(null); // Add null a third time

        System.out.println("Original List: " + names);
        System.out.println("Size of Original List: " + names.size());

        // Create a HashSet from the list
        Set<String> uniqueNamesSet = new HashSet<>(names);

        System.out.println("Set created from List: " + uniqueNamesSet);
        System.out.println("Size of Set: " + uniqueNamesSet.size());

        // The difference in size tells us how many duplicates were removed
        // Note: This calculation is less straightforward with nulls and duplicates combined
        // int duplicatesCount = names.size() - uniqueNamesSet.size();
        // System.out.println("Number of duplicates (excluding first occurrence): " + duplicatesCount);
    }
}

Aqui, adicionamos null à lista names várias vezes. Também comentamos o cálculo da contagem de duplicatas porque ele se torna menos significativo quando null está envolvido e estamos focando no comportamento do conjunto com null.

Salve o arquivo DuplicateCheck.java modificado.

Compile o programa no Terminal:

javac DuplicateCheck.java

Se a compilação for bem-sucedida, execute o programa:

java DuplicateCheck

Você deve ver uma saída semelhante a esta:

Original List: [Alice, Bob, null, Alice, Charlie, null, Bob, David, null]
Size of Original List: 9
Set created from List: [null, Alice, Bob, Charlie, David]
Size of Set: 5

Observe a saída:

• A Original List mostra todos os elementos, incluindo os múltiplos valores null. Seu tamanho é 9.
• O Set created from List contém apenas elementos únicos. Observe que null aparece apenas uma vez no conjunto, embora tenha sido adicionado várias vezes à lista. O tamanho do conjunto é 5 (Alice, Bob, Charlie, David e null).

Isso confirma que o HashSet permite um elemento null e trata as adições subsequentes de null como duplicatas, assim como qualquer outro elemento.

Você agora testou com sucesso como o HashSet lida com elementos null. Isso conclui nossa exploração do uso de HashSet para verificação de duplicatas e a compreensão de seu comportamento com elementos únicos e nulos.

Resumo

Neste laboratório, aprendemos como verificar eficientemente a existência de elementos duplicados em uma coleção Java usando um HashSet. Criamos uma List com elementos duplicados e, em seguida, iteramos por ela, tentando adicionar cada elemento a um HashSet. Ao verificar o valor de retorno do método add(), que retorna false se o elemento já estiver presente, fomos capazes de identificar e coletar os elementos duplicados em um HashSet separado. Este método aproveita a propriedade de elemento único e os recursos de busca rápida do HashSet para uma detecção eficaz de duplicatas.