A interface definida está presente no pacote java.util e estende a interface Collection é uma coleção desordenada de objetos em que valores duplicados não podem ser armazenados. É uma interface que implementa o conjunto matemático. Esta interface contém os métodos herdados da interface Collection e adiciona um recurso que restringe a inserção dos elementos duplicados. Existem duas interfaces que estendem a implementação do conjunto: SortedSet e NavigableSet .

Na imagem acima, o conjunto navegável estende a interface do conjunto classificado. Como um conjunto não retém a ordem de inserção, a interface do conjunto navegável fornece a implementação para navegar pelo Conjunto. A classe que implementa o conjunto navegável é um TreeSet, que é uma implementação de uma árvore de auto-equilíbrio. Portanto, essa interface nos fornece uma maneira de navegar por essa árvore.

Declaração: A interface Set é declarada como:

public interface Set extends Collection 

Criando Objetos de Conjunto
Visto que Set é uma interface , os objetos não podem ser criados do conjunto. Sempre precisamos de uma classe que estenda essa lista para criar um objeto. E também, após a introdução dos Genéricos no Java 1.5, é possível restringir o tipo de objeto que pode ser armazenado no Conjunto. Este conjunto de tipo seguro pode ser definido como:

// Obj is the type of the object to be stored in Set 
Set<Obj> set = new HashSet<Obj> (); 

Vamos discutir os métodos presentes na interface Set fornecida abaixo em um formato tabular a seguir:

Ilustração: Programa de amostra para ilustrar a interface do conjunto

// Java program Illustrating Set Interface
 
// Importing utility classes
import java.util.*;
 
// Main class
public class GFG {
   
    // Main driver method
    public static void main(String[] args)
    {
        // Demonstrating Set using HashSet
        // Declaring object of type String
        Set<String> hash_Set = new HashSet<String>();
 
        // Adding elements to the Set
        // using add() method
        hash_Set.add("Geeks");
        hash_Set.add("For");
        hash_Set.add("Geeks");
        hash_Set.add("Example");
        hash_Set.add("Set");
 
        // Printing elements of HashSet object
        System.out.println(hash_Set);
    }
}

[Definir, Exemplo, Geeks, For]

Operações na interface do conjunto

A interface do conjunto permite que os usuários realizem a operação matemática básica no conjunto. Vamos pegar duas matrizes para entender essas operações básicas. Seja conjunto1 = [1, 3, 2, 4, 8, 9, 0] e conjunto2 = [1, 3, 7, 5, 4, 0, 7, 5]. Então, as operações possíveis nos conjuntos são:

1. Intersecção: Esta operação retorna todos os elementos comuns dos dois conjuntos fornecidos. Para os dois conjuntos acima, a interseção seria:

Intersection = [0, 1, 3, 4] 

2. União: esta operação adiciona todos os elementos de um conjunto com o outro. Para os dois conjuntos acima, a união seria: 

Union = [0, 1, 2, 3, 4, 5, 7, 8, 9] 

3. Diferença: Esta operação remove todos os valores presentes em um conjunto do outro conjunto. Para os dois conjuntos acima, a diferença seria: 

Difference = [2, 8, 9]

Agora, vamos implementar as seguintes operações, conforme definido acima, da seguinte maneira:

Implementação:

Exemplo 

// Java Program Demonstrating Operations on the Set
// such as Union, Intersection and Difference operations
 
// Importing all utility classes
import java.util.*;
 
// Main class
public class SetExample {
   
    // Main driver method
    public static void main(String args[])
    {
        // Creating an object of Set class
        // Declaring object of Integer type
        Set<Integer> a = new HashSet<Integer>();
       
        // Adding all elements to List
        a.addAll(Arrays.asList(
            new Integer[] { 1, 3, 2, 4, 8, 9, 0 }));
       
      // Again declaring object of Set class
      // with reference to HashSet
        Set<Integer> b = new HashSet<Integer>();
         
      b.addAll(Arrays.asList(
            new Integer[] { 1, 3, 7, 5, 4, 0, 7, 5 }));
 
         
        // To find union
        Set<Integer> union = new HashSet<Integer>(a);
        union.addAll(b);
        System.out.print("Union of the two Set");
        System.out.println(union);
 
        // To find intersection
        Set<Integer> intersection = new HashSet<Integer>(a);
        intersection.retainAll(b);
        System.out.print("Intersection of the two Set");
        System.out.println(intersection);
 
        // To find the symmetric difference
        Set<Integer> difference = new HashSet<Integer>(a);
        difference.removeAll(b);
        System.out.print("Difference of the two Set");
        System.out.println(difference);
    }
}

União dos dois Conjunto [0, 1, 2, 3, 4, 5, 7, 8, 9]
Intersecção dos dois Conjuntos [0, 1, 3, 4]
Diferença dos dois conjuntos [2, 8, 9]

Execução de várias operações no SortedSet

Após a introdução dos Genéricos no Java 1.5, é possível restringir o tipo de objeto que pode ser armazenado no Conjunto. Como Set é uma interface, ele pode ser usado apenas com uma classe que implementa essa interface. HashSet é uma das classes amplamente utilizadas que implementa a interface Set. Agora, vamos ver como realizar algumas operações usadas com frequência no HashSet. Vamos realizar as seguintes operações da seguinte forma:

1. Adicionando elementos
2. Acessando elementos
3. Removendo elementos
4. Elementos iterativos
5. Iterando por meio de conjunto

Agora, vamos discutir essas operações individualmente da seguinte maneira:

Operações 1: adicionar elementos

Para adicionar um elemento ao Conjunto, podemos usar o método add() . No entanto, o pedido de inserção não é retido no Conjunto. Internamente, para cada elemento, um hash é gerado e os valores são armazenados em relação ao hash gerado. os valores são comparados e classificados em ordem crescente. Precisamos manter uma nota que elementos duplicados não são permitidos e todos os elementos duplicados são ignorados. E também, valores nulos são aceitos pelo Conjunto.

Exemplo  

// Java Program Demonstrating Working of Set by
// Adding elements using add() method
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of Set and
        // declaring object of type String
        Set<String> hs = new HashSet<String>();
 
        // Adding elements to above object
        // using add() method
        hs.add("B");
        hs.add("B");
        hs.add("C");
        hs.add("A");
 
        // Printing the elements inside the Set object
        System.out.println(hs);
    }
}

[A, B, C]

Operação 2: Acessando os Elementos

Depois de adicionar os elementos, se desejarmos acessar os elementos, podemos usar métodos embutidos como contains() .

Exemplo 

// Java code to demonstrate Working of Set by
// Accessing the Elements og the Set object
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating an object of Set and
        // declaring object of type String
        Set<String> hs = new HashSet<String>();
 
        // Elements are added using add() method
        // Later onwards we wil show accessing the same
 
        // Custom input elements
        hs.add("A");
        hs.add("B");
        hs.add("C");
        hs.add("A");
 
        // Print the Set object elements
        System.out.println("Set is " + hs);
 
        // Declaring a string
        String check = "D";
 
        // Check if the above string exists in
        // the SortedSet or not
        // using contains() method
        System.out.println("Contains " + check + " "
                           + hs.contains(check));
    }
}

O conjunto é [A, B, C]
Contém D falso

Operação 3: Removendo os Valores

Os valores podem ser removidos do Conjunto usando o método remove() .

Exemplo

// Java Program Demonstrating Working of Set by
// Removing Element/s from the Set
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring object of Set of type String
        Set<String> hs = new HashSet<String>();
 
        // Elements are added
        // using add() method
 
        // Custom input elements
        hs.add("A");
        hs.add("B");
        hs.add("C");
        hs.add("B");
        hs.add("D");
        hs.add("E");
 
        // Printing initial Set elements
        System.out.println("Initial HashSet " + hs);
 
        // Removing custom element
        // using remove() method
        hs.remove("B");
 
        // Printing Set elements after removing an element
        // and printing updated Set elements
        System.out.println("After removing element " + hs);
    }
}

HashSet inicial [A, B, C, D, E]
Depois de remover o elemento [A, C, D, E]

Operação 4: Iterando através do conjunto

Existem várias maneiras de iterar por meio do Conjunto. O mais famoso é usar o loop for aprimorado.

Exemplo 

// Java Program to Demonstrate Working of Set by
// Iterating through the Elements
 
// Importing utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of Set and declaring String type
        Set<String> hs = new HashSet<String>();
 
        // Adding elements to Set 
        // using add() method
 
        // Custom input elements
        hs.add("A");
        hs.add("B");
        hs.add("C");
        hs.add("B");
        hs.add("D");
        hs.add("E");
 
        // Iterating though the Set
        // via for-each loop
        for (String value : hs)
 
            // Printing all the values inside the object
            System.out.print(value + ", ");
         
        System.out.println();
    }
}

A, B, C, D, E, 

As classes que implementam a interface Set em Coleções Java podem ser facilmente percebidas na imagem abaixo como segue e são listadas a seguir:

• HashSet
• EnumSet
• LinkedHashSet
• TreeSet

Classe 1: HashSet 

A classe HashSet que é implementada na estrutura de coleta é uma implementação inerente da estrutura de dados da tabela de hash . Os objetos que inserimos no HashSet não garantem que sejam inseridos na mesma ordem. Os objetos são inseridos com base em seu hashcode. Esta classe também permite a inserção de elementos NULL. Vamos ver como criar um objeto definido usando esta classe. 

Exemplo

// Java program Demonstrating Creation of Set object
// Using the Hashset class
 
// Importing utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating object of Set of type String
        Set<String> h = new HashSet<String>();
 
        // Adding elements into the HashSet
        // using add() method
 
        // Custom input elements
        h.add("India");
        h.add("Australia");
        h.add("South Africa");
 
        // Adding the duplicate element
        h.add("India");
 
        // Displaying the HashSet
        System.out.println(h);
 
        // Removing items from HashSet
        // using remove() method
        h.remove("Australia");
        System.out.println("Set after removing "
                           + "Australia:" + h);
 
        // Iterating over hash set items
        System.out.println("Iterating over set:");
 
        // Iterating through iterators
        Iterator<String> i = h.iterator();
 
        // It holds true till there is a single element
        // remaining in the object
        while (i.hasNext())
 
            System.out.println(i.next());
    }
}

[África do Sul, Austrália, Índia]
Definido após a remoção da Austrália: [África do Sul, Índia]
Iterando sobre o conjunto:
África do Sul
Índia

Classe 2: EnumSet

A classe EnumSet que é implementada na estrutura de coleções é uma das implementações especializadas da interface Set para uso com o tipo de enumeração . É uma implementação de conjunto de alto desempenho, muito mais rápida do que HashSet. Todos os elementos em um conjunto enum devem vir de um único tipo de enumeração que é especificado quando o conjunto é criado explicitamente ou implicitamente. Vamos ver como criar um objeto definido usando esta classe. 

Exemplo

// Java program to demonstrate the
// creation of the set object
// using the EnumSet class
import java.util.*;
 
enum Gfg { CODE, LEARN, CONTRIBUTE, QUIZ, MCQ }
;
 
public class GFG {
 
    public static void main(String[] args)
    {
        // Creating a set
        Set<Gfg> set1;
 
        // Adding the elements
        set1 = EnumSet.of(Gfg.QUIZ, Gfg.CONTRIBUTE,
                          Gfg.LEARN, Gfg.CODE);
 
        System.out.println("Set 1: " + set1);
    }
}

Conjunto 1: [CODE, LEARN, CONTRIBUTE, QUIZ]

Classe 3: LinkedHashSet

A classe LinkedHashSet que é implementada na estrutura de coleções é uma versão ordenada de HashSet que mantém uma lista duplamente vinculada em todos os elementos. Quando a ordem de iteração precisa ser mantida, essa classe é usada. Ao iterar por meio de um HashSet, a ordem é imprevisível, enquanto um LinkedHashSet nos permite iterar através dos elementos na ordem em que foram inseridos. Vamos ver como criar um objeto definido usando esta classe. 

Exemplo

// Java program to demonstrate the
// creation of Set object using
// the LinkedHashset class
import java.util.*;
 
class GFG {
 
    public static void main(String[] args)
    {
        Set<String> lh = new LinkedHashSet<String>();
 
        // Adding elements into the LinkedHashSet
        // using add()
        lh.add("India");
        lh.add("Australia");
        lh.add("South Africa");
 
        // Adding the duplicate
        // element
        lh.add("India");
 
        // Displaying the LinkedHashSet
        System.out.println(lh);
 
        // Removing items from LinkedHashSet
        // using remove()
        lh.remove("Australia");
        System.out.println("Set after removing "
                           + "Australia:" + lh);
 
        // Iterating over linked hash set items
        System.out.println("Iterating over set:");
        Iterator<String> i = lh.iterator();
        while (i.hasNext())
            System.out.println(i.next());
    }
}

[Índia, Austrália, África do Sul]
Definido após a remoção da Austrália: [Índia, África do Sul]
Iterando sobre o conjunto:
Índia
África do Sul

Classe 4: TreeSet

A classe TreeSet que é implementada na estrutura de coleções e a implementação da Interface SortedSet e SortedSet estende a Interface Set. Ele se comporta como um conjunto simples, com a exceção de que armazena elementos em um formato classificado. TreeSet usa uma estrutura de dados em árvore para armazenamento. Os objetos são armazenados em ordem crescente. Mas podemos iterar em ordem decrescente usando o método TreeSet.descendingIterator(). Vamos ver como criar um objeto definido usando esta classe.

Exemplo

// Java Program Demonstrating Creation of Set object
// Using the TreeSet class
 
// Importing utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a Set object and declaring it of String
        // type
        // with reference to TreeSet
        Set<String> ts = new TreeSet<String>();
 
        // Adding elements into the TreeSet
        // using add()
        ts.add("India");
        ts.add("Australia");
        ts.add("South Africa");
 
        // Adding the duplicate
        // element
        ts.add("India");
 
        // Displaying the TreeSet
        System.out.println(ts);
 
        // Removing items from TreeSet
        // using remove()
        ts.remove("Australia");
        System.out.println("Set after removing "
                           + "Australia:" + ts);
 
        // Iterating over Tree set items
        System.out.println("Iterating over set:");
        Iterator<String> i = ts.iterator();
 
        while (i.hasNext())
            System.out.println(i.next());
    }
}

[Austrália, Índia, África do Sul]
Definido após a remoção da Austrália: [Índia, África do Sul]
Iterando sobre o conjunto:
Índia
África do Sul