set interface java
Este tutorial do conjunto Java explica tudo sobre a interface do conjunto em Java. Ele cobre como iterar por meio de um conjunto, métodos de conjunto, implementação, conjunto para lista, etc .:
Set in Java é uma interface que faz parte do Java Collection Framework e implementa a interface Collection. Uma coleção de conjuntos fornece os recursos de um conjunto matemático.
Um conjunto pode ser definido como uma coleção de objetos não ordenados e não pode conter valores duplicados. Como a interface set herda a interface Collection, ela implementa todos os métodos da interface Collection.
=> Confira o guia de treinamento Java perfeito aqui.
O que você aprenderá:
Conjunto Java
A interface definida é implementada por classes e interfaces, conforme mostrado no diagrama abaixo.
Conforme mostrado no diagrama acima, a interface Set é herdada por classes, HashSet, TreeSet, LinkedHashSet e EnumSet. As interfaces SortedSet e NavigableSet também implementam a interface Set.
Algumas das características importantes da interface Set são fornecidas abaixo:
- A interface definida faz parte do Java Collections Framework.
- A interface definida permite valores únicos.
- Ele pode ter no máximo um valor nulo.
- Java 8 fornece um método padrão para a interface definida - Spliterator.
- A interface do conjunto não suporta os índices dos elementos.
- A interface do conjunto suporta genéricos.
Como criar um conjunto?
A interface definida em Java é parte do pacote java.util. Para incluir uma interface definida no programa, temos que usar uma das seguintes instruções de importação.
import java.util.*; ou
import java.util.Set; Uma vez que a funcionalidade da interface definida é incluída no programa, podemos criar um conjunto em Java usando qualquer uma das classes definidas (classes que implementam a interface definida) como mostrado abaixo.
Set colors_Set = new HashSet(); Podemos então inicializar este objeto definido adicionando alguns elementos a ele usando o método add.
colors_Set.add(“Red”); colors_Set.add(“Green”); colors_Set.add(“Blue”); Definir exemplo em Java
Vamos implementar um exemplo simples em Java para demonstrar a interface Set.
import java.util.*; public class Main { public static void main(String() args) { // Set demo with HashSet Set Colors_Set = new HashSet(); Colors_Set.add('Red'); Colors_Set.add('Green'); Colors_Set.add('Blue'); Colors_Set.add('Cyan'); Colors_Set.add('Magenta'); //print set contents System.out.print('Set contents:'); System.out.println(Colors_Set); // Set demo with TreeSet System.out.print('
Sorted Set after converting to TreeSet:'); Set tree_Set = new TreeSet(Colors_Set); System.out.println(tree_Set); } }Resultado:
Definir conteúdo: (Vermelho, Ciano, Azul, Magenta, Verde)
Conjunto classificado após a conversão para TreeSet: (Azul, Ciano, Verde, Magenta, Vermelho)
Iterar por meio de conjunto em Java
Podemos acessar cada um dos elementos de um Conjunto usando várias abordagens. Discutiremos essas abordagens a seguir.
Usando o Iterator
Podemos definir um iterador para percorrer um objeto definido. Usando este iterador, podemos acessar cada elemento no Conjunto e processá-lo.
O programa Java a seguir demonstra a iteração por meio do conjunto e imprime os elementos do conjunto.
import java.util.*; import java.util.HashSet; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); // Create an iterator for the cities_Set Iterator iter = cities_Set.iterator(); // print the set contents using iterator System.out.println('Values using Iterator: '); while (iter.hasNext()) { System.out.print(iter.next()+ ' '); } } }Resultado:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Valores usando Iterator:
Bangalore Pune Kolkata Hyderabad
Usando o loop For-each
Também podemos usar o loop for-each para acessar os elementos de um conjunto. Aqui, iteramos através do conjunto em um loop.
O programa a seguir demonstra isso.
import java.util.*; import java.util.HashSet; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); System.out.println('
Set contents using forEach loop:'); // print the set contents using forEach loop for(String val : cities_Set) { System.out.print(val + ' '); } } } Resultado:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Defina o conteúdo usando o loop forEach:
Bangalore Pune Kolkata Hyderabad
Usando Java 8 Stream API
Também podemos iterar e acessar elementos definidos usando a API de fluxo Java 8. Nesse caso, geramos um fluxo de um conjunto e, em seguida, iteramos por meio do fluxo usando o loop forEach.
O programa Java abaixo demonstra a iteração do conjunto usando a API de fluxo Java 8.
import java.util.*; import java.util.HashSet; import java.util.stream.*; public class Main { public static void main(String args()) { // Create a HashSet object and initialize it Set cities_Set = new HashSet(); cities_Set.add('Bangaluru'); cities_Set.add('Pune'); cities_Set.add('Hyderabad'); cities_Set.add('Kolkata'); // Print the set contents System.out.println('HashSet: ' + cities_Set); System.out.println('
Set contents using Java 8 stream API:'); //generate a stream from set Stream stream = cities_Set.stream(); //iterate the stream using forEach loop to print the elements stream.forEach((element) -> { System.out.print(element + ' '); }); } }Resultado:
HashSet: (Bangaluru, Pune, Kolkata, Hyderabad)
Defina o conteúdo usando a API de fluxo Java 8:
Bangalore Pune Kolkata Hyderabad
API Set Methods
A seguir, são apresentados os métodos suportados pela interface Set. Esses métodos realizam operações básicas como adicionar, remover, contém, etc. junto com as outras operações.
é uma chave de segurança de rede igual a uma senha
| Método | Protótipo de Método | Descrição |
|---|---|---|
| está vazia | boolean isEmpty () | Verifica se o conjunto está vazio |
| adicionar | adição booleana (E e) | Adiciona o elemento e ao conjunto se não estiver presente no conjunto |
| addAll | boolean addAll (coleção c) | Adiciona o elemento da coleção c ao conjunto. |
| retirar | boolean remove (objeto o) | Exclui o elemento o fornecido do conjunto. |
| deletar tudo | boolean removeAll (coleção c) | Remove os elementos presentes na coleção c fornecida do conjunto. |
| contém | boolean contém (objeto o) | Verifica se o elemento o está presente no conjunto. Retorna verdadeiro se sim. |
| containsAll | boolean containsAll (coleção c) | Verifica se o conjunto contém todos os elementos da coleção especificada; Retorna verdadeiro se sim. |
| reter tudo | boolean reterAll (coleção c) | Conjunto retém todos os elementos da coleção c fornecida |
| Claro | void clear () | Limpa o conjunto excluindo todos os elementos do conjunto |
| iterador | Iterator iterator () | Usado para obter o iterador para o conjunto |
| toArray | Object () toArray () | Converte o conjunto em representação de matriz que contém todos os elementos do conjunto. |
| Tamanho | tamanho interno () | Retorna o número total de elementos ou tamanho do conjunto. |
| hashCode | hashCode () | Retorna hashCode do conjunto. |
Agora, vamos implementar alguns dos métodos que discutimos acima em um programa Java. Também veremos as seguintes operações específicas que envolvem dois conjuntos.
Definir implementação em Java
Interseção: Retemos valores comuns entre os dois conjuntos. Realizamos um cruzamento usando o reter tudo método.
União: Aqui combinamos os dois conjuntos. Isso é feito com o addAll método.
Diferença: Esta operação remove um conjunto do outro. Esta operação é realizada usando o deletar tudo método.
import java.util.*; public class Main { public static void main(String args()) { //declare a set class (HashSet) Set numSet = new HashSet(); //add an element => add numSet.add(13); //add a list to the set using addAll method numSet.addAll(Arrays.asList(new Integer() {1,6,4,7,3,9,8,2,12,11,20})); //print the set System.out.println('Original Set (numSet):' + numSet); //size() System.out.println('
numSet Size:' + numSet.size()); //create a new set class and initialize it with list elements Set oddSet = new HashSet(); oddSet.addAll(Arrays.asList(new Integer() {1, 3, 7, 5, 9})); //print the set System.out.println('
OddSet contents:' + oddSet); //contains () System.out.println('
numSet contains element 2:' + numSet.contains(3)); //containsAll () System.out.println('
numSet contains collection oddset:' + numSet.containsAll(oddSet)); // retainAll () => intersection Set set_intersection = new HashSet(numSet); set_intersection.retainAll(oddSet); System.out.print('
Intersection of the numSet & oddSet:'); System.out.println(set_intersection); // removeAll () => difference Set set_difference = new HashSet(numSet); set_difference.removeAll(oddSet); System.out.print('Difference of the numSet & oddSet:'); System.out.println(set_difference); // addAll () => union Set set_union = new HashSet(numSet); set_union.addAll(oddSet); System.out.print('Union of the numSet & oddSet:'); System.out.println(set_union); } }Resultado:
Conjunto original (numSet): (1, 2, 3, 4, 20, 6, 7, 8, 9, 11, 12, 13)
Tamanho numSet: 12
Conteúdo do OddSet: (1, 3, 5, 7, 9)
numSet contém o elemento 2: true
numSet contém coleção oddset: false
Intersecção de numSet e oddSet: (1, 3, 7, 9)
Diferença de numSet e oddSet: (2, 4, 6, 8, 11, 12, 13, 20)
União do conjunto numérico e conjunto ímpar: (1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 13, 20)
Definir para matriz
Vimos o método ‘toArray’ na seção acima sobre métodos. Este método toArray pode ser usado para converter o conjunto em um Array.
O programa Java abaixo converte o conjunto em um array.
como fazer uma lista de inteiros em java
import java.util.*; public class Main { public static void main(String() args) { //declare a set class (HashSet) Set setOfColors= new HashSet(); // add data to HashSet setOfColors.add('Red'); setOfColors.add('Green'); setOfColors.add('Blue'); setOfColors.add('Cyan'); setOfColors.add('Magenta'); //print the set System.out.println('The set contents:' + setOfColors); //convert Set to Array using toArray () method String colors_Array() = setOfColors.toArray(new String(setOfColors.size())); //print the Array System.out.println('Set converted to Array:' + Arrays.toString(colors_Array)); } }Resultado:
O conteúdo do conjunto: (Vermelho, Ciano, Azul, Magenta, Verde)
Conjunto convertido em matriz: (vermelho, ciano, azul, magenta, verde)
Matriz para definir
Para converter um Array em um conjunto em Java, podemos seguir duas abordagens, conforme mostrado abaixo.
# 1) Podemos converter o Array em uma lista usando o método asList e, em seguida, passar essa lista como um argumento para o construtor do conjunto. Isso resulta no objeto definido sendo criado com os elementos da matriz.
#dois) Como alternativa, podemos usar o método Collections.addAll para copiar os elementos do array para o objeto definido.
O programa Java abaixo implementa ambas as abordagens para converter uma matriz em conjunto.
import java.util.*; public class Main { public static void main(String() args) { //declare an array Integer() numArray = {10,50,40,20,60,30,80,70}; System.out.println('The input array:' + Arrays.toString(numArray)); //Approach 1: create a set class and provide array //converted to list as constructor arg Set numSet = new HashSet(Arrays.asList(numArray)); //print the set System.out.println('
Array converted to set through asList:' + numSet); //create another set Set intSet = new HashSet(); //Approach 2: use Collections.addAll method to copy array elements to the set Collections.addAll(intSet, numArray); //print the set System.out.println('
Array converted to set using Collections.addAll:' + intSet); } }Resultado:
A matriz de entrada: (10, 50, 40, 20, 60, 30, 80, 70)
Array convertido para definir por meio de asList: (80, 50, 20, 70, 40, 10, 60, 30)
Array convertido em conjunto usando Collections.addAll: (80, 50, 20, 70, 40, 10, 60, 30)
Definir para a lista
Para converter conjunto em uma lista em Java, podemos usar o método ‘addAll’ da classe de lista. Este método copia o conteúdo do conjunto ou qualquer coleção fornecida como um argumento para a lista que invoca o método addAll.
O programa Java abaixo converte o conjunto em um ArrayList.
import java.util.*; public class Main { public static void main(String() args) { //declare a set class and initialize it Set strSet= new HashSet(); strSet.add('one'); strSet.add('two'); strSet.add('three'); strSet.add('four'); strSet.add('five'); //print the set System.out.println('The set contents: ' + strSet); //declare an ArrayList List strList = new ArrayList(); //using addAll method,copy set elements to ArrayList strList.addAll(strSet); //print the ArrayList System.out.println('The ArrayList from set : ' + strList); } }Resultado:
O conteúdo do conjunto: (quatro, um, dois, três, cinco)
A ArrayList do conjunto: (quatro, um, dois, três, cinco)
Lista para definir
Para converter a lista fornecida como ArrayList em um conjunto em Java, passamos o objeto de lista como um argumento para o construtor do conjunto.
O programa Java a seguir implementa essa conversão.
import java.util.*; public class Main { public static void main(String() args) { //declare an ArrayList and initialize it List strList = new ArrayList(); strList.add('one'); strList.add('two'); strList.add('three'); strList.add('four'); strList.add('five'); //print the ArrayList System.out.println('The ArrayList: ' + strList); //declare a set class with ArrayList as argument to the constructor Set strSet= new HashSet(strList); //print the set System.out.println('The Set obtained from ArrayList: ' + strSet); } }Resultado:
The ArrayList: (um, dois, três, quatro, cinco)
O conjunto obtido de ArrayList: (quatro, um, dois, três, cinco)
Classificar um conjunto em Java
A coleção Set em Java não possui um método direto de classificação. Portanto, precisamos seguir algumas abordagens indiretas para classificar ou ordenar o conteúdo do objeto definido. No entanto, existe uma exceção caso o objeto definido seja um TreeSet.
O objeto TreeSet por padrão fornece o conjunto ordenado. Portanto, se estamos interessados no conjunto ordenado de elementos, devemos escolher o TreeSet. Pra HashSet ou objetos LinkedHashSet, podemos converter o conjunto em List. Classifique a lista usando o método Collections.sort () e, a seguir, converta a lista de volta em conjunto.
Essa abordagem é mostrada no programa Java abaixo.
import java.util.Arrays; import java.util.Collections; import java.util.*; public class Main{ public static void main(String() args) { //Declare a set and initialize it with unsorted list HashSet evenNumSet = new LinkedHashSet( Arrays.asList(4,8,6,2,12,10,62,40,36) ); //print the unsorted set System.out.println('Unsorted Set: ' + evenNumSet); //convert set to list List numList = new ArrayList(evenNumSet); //Sort the list using Collections.sort () method Collections.sort(numList); //convert set to list evenNumSet = new LinkedHashSet(numList); //convert list to set //Print the sorted set System.out.println('Sorted Set:' + evenNumSet); } }Resultado:
Conjunto não classificado: (4, 8, 6, 2, 12, 10, 62, 40, 36)
Conjunto ordenado: (2, 4, 6, 8, 10, 12, 36, 40, 62)
Lista Vs definida em Java
Vamos discutir algumas das diferenças entre uma lista e um conjunto.
| Lista | Definir |
|---|---|
| Valores nulos são permitidos. | Apenas um valor nulo permitido. |
| Interface da lista de implementos. | Interface do conjunto de implementos. |
| Contém uma classe Legacy, Vector. | Sem classes legadas. |
| ArrayList, LinkedList é implementações de Interface de Lista. | HashSet, TreeSet, LinkedHashSet são implementações de Set. |
| Uma sequência ordenada de elementos. | Uma coleção não ordenada de elementos distintos. |
| Permite duplicatas. | Nenhuma duplicata é permitida. |
| Capaz de acessar elementos de acordo com a posição do elemento. | Sem acesso posicional. |
| Novos métodos definidos em uma interface de lista. | Nenhum método novo definido na interface Set. Os métodos da interface de coleção devem ser usados com as subclasses Set. |
| Pode ser percorrido na direção para frente e para trás usando ListIterator. | Ele pode ser percorrido apenas na direção para frente com o Iterator. |
perguntas frequentes
P # 1) O que é um conjunto em Java?
Responda: Um conjunto é uma coleção não ordenada de elementos únicos e normalmente modela o conceito de Conjunto na matemática.
Set é uma interface que estende a interface Collection. Ele contém os métodos que herda da interface Collection. A interface definida apenas adiciona uma restrição, ou seja, nenhuma duplicata deve ser permitida.
Q # 2)O conjunto é ordenado em Java?
Responda: Não. O conjunto Java não foi encomendado. Ele também não fornece acesso posicional.
Q # 3)Um conjunto pode conter duplicatas?
Responda: Um conjunto é uma coleção de elementos únicos e não pode ter duplicatas.
Q # 4)O conjunto Java é iterável?
Responda: sim. A interface set implementa uma interface Iterable e, portanto, set pode ser percorrida ou iterada usando um loop forEach.
Q # 5)NULL é permitido no conjunto?
Responda: Um conjunto permite valor nulo, mas no máximo um valor nulo é permitido em implementações de conjunto como HashSet e LinkedHashSet. No caso de TreeSet, ele lança uma exceção de tempo de execução se o nulo for especificado.
Conclusão
Neste tutorial, discutimos os conceitos gerais e a implementação relacionados à interface Set em Java.
A interface de conjunto não possui nenhum método novo definido, mas usa os métodos da interface do Coletor e apenas adiciona implementação para proibir valores duplicados. O conjunto permite no máximo um valor nulo.
Em nossos tutoriais subsequentes, discutiremos implementações específicas da interface Set, como HashSet e TreeSet.
=> Visite aqui para aprender Java do zero.
Leitura recomendada
- Tutorial de reflexão Java com exemplos
- Tutorial JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java
- Java String contains () Tutorial de método com exemplos
- Jagged Array In Java - Tutorial com exemplos
- Tutorial da classe Java Scanner com exemplos
- Tutorial de comprimento de array Java com exemplos de código
- Tutorial de Java String | Métodos Java String com exemplos
- O que é Java Vector | Tutorial da classe Java Vector com exemplos