O que é coleção em Java?
Uma coleção em java é representada como um contêiner que agrupa todos os elementos em uma única unidade. Por exemplo , uma pasta de correio (grupo de e-mails), uma lista telefônica (mapeamento de nomes para números de telefone).O que é uma estrutura?
Uma estrutura é uma base ou layout básico no qual você começa a trabalhar usando as diferentes classes e interfaces fornecidas. Por exemplo , Laravel é um dos frameworks PHP mais famosos que fornece um esqueleto básico para sua aplicação.Qual é a estrutura de coleções em Java?
Todos os objetos são agrupados em um único objeto junto com uma arquitetura que representa e fornece diferentes métodos para manipulação de coleções. Portanto, a estrutura de coleções em Java fornece diferentes estruturas de dados já implementadas para armazenar dados e métodos, para manipulá-los com recursos como classificação, pesquisa, exclusão e inserção . Por exemplo , você deseja implementar um sistema para alguma empresa aleatória melhorar o serviço aos seus clientes, com base na ordem de chegada. Isso também é conhecido como implementação FIFO (primeiro a entrar, primeiro a sair). Agora precisamos implementar essa estrutura de dados e então usá-la para atingir nosso objetivo. A estrutura Collections nos fornece uma interface Queue que só precisamos importar em vez de implementar, depois usá-la e pronto. Implementação : você pode importar todas as coleções usando a seguinte linha:import java.util.*;
Se você deseja importar uma coleção específica, use o nome exato do pacote, como:
import java.util.LinkedList;
Benefícios do Framework de Coleções em Java
Tem os seguintes benefícios.- Já implementado (economia de tempo).
- Eficiência de desempenho (velocidade e qualidade).
- Reduz o esforço para aprender e usar novas APIs.
Qual é a hierarquia da estrutura de coleção?
Agora vamos ver a hierarquia de coleções, mas primeiro precisamos conhecer os componentes essenciais deste framework.- Interfaces
- Aulas (implementação)
- Algoritmos
Hierarquia da Estrutura de Coleção
Para seu entendimento:- Coleção, Conjunto, Fila e Lista são interfaces. Set, Queue e List são estendidos pela interface Collection.
- PriorityQueue, HashSet, LinkedList e Stack são classes ou a implementação dessas interfaces.
- Não é obrigatório que uma classe implemente apenas uma interface. LinkedList também implementa a interface Deque, por exemplo.
Tipos de coleções
A estrutura de coleções Java possui vários tipos de coleções para reduzir nossos esforços. Aqui está uma lista de algumas das coleções:- Classe ArrayList
- Classe LinkedList
- Interface de lista
- Definir interface
- Interface de fila
- Interface do mapa
- Classe PriorityQueue
- Classe HashMap
- Interface comparável
- Classe LinkedHashMap
- Classe TreeMap
- Tabela Hash
Interfaces de coleção
Aqui discutiremos algumas interfaces de coleção comuns e, em seguida, alguns métodos implementados pelas classes.Interface de coleção
Esta é uma base básica para a estrutura de Coleções, pois fornece todos os métodos necessários para implementação. O Mapa é a única estrutura de dados que não o implementa, mas todas as demais implementam seus métodos. Esta interface possui métodos para saber o tamanho da coleção, e se existe um objeto na coleção, adicionando ou removendo objetos da coleção.Interface Iterável
É a interface raiz da estrutura Collections, pois é estendida pela interface Collection, que é implementada por todas as classes. Ele retorna um iterador para a coleção específica iterar sobre ela.Interface de fila
A fila é usada para armazenar os elementos, mas eles não podem ser processados. Implementando as operações básicas de coleta, também fornece métodos adicionais de inserção e extração.Definir interface
Set é usado para conter elementos únicos nele. Ele nunca contém elementos duplicados e modela a abstração do conjunto matemático para representar os conjuntos, como processos em execução em uma máquina.Interface de lista
Lista é uma coleção ordenada, às vezes chamada de sequência, que pode conter elementos duplicados. Ele fornece ao usuário controle para atualizar ou remover um elemento específico, inserindo um elemento em um ponto específico usando seu valor de índice inteiro. LinkedList e ArrayList são classes de implementação da interface List.Interface Deque
Deque significa fila dupla, o que significa que podemos realizar operações em ambas as extremidades. Podemos inserir e remover elementos de ambas as extremidades. A interface Deque estende a interface da fila. ArrayDeque e LinkedList implementam a interface Deque. Ele fornece métodos para inserção, exclusão e exame da instância em ambas as extremidades.Interface do mapa
A interface do mapa também faz parte da estrutura de coleções, mas não estende a interface de coleção. É usado para armazenar pares de valores-chave. Suas principais implementações são HashMap, TreeMap e LinkesHashMap que são semelhantes em certos aspectos a HashSet, TreeSet e LinkedHashSet. Sempre contém chaves exclusivas, mas os valores podem ser duplicados. É útil quando você precisa adicionar, excluir ou pesquisar um item com base em uma chave. Ele nos fornece métodos básicos como put , get , remove , size , empty e assim por diante.Métodos comuns dessas interfaces
Agora veremos alguns métodos comuns fornecidos para a implementação de diferentes classes nesta estrutura, exceto a interface Map.Métodos | Descrição |
---|---|
adição booleana pública (E e) | Usado para inserir um elemento na coleção |
remoção booleana pública (elemento objeto) | Usado para remover um elemento da coleção |
tamanho interno público() | Retorna o número de elementos em uma coleção |
booleano público contém (elemento objeto) | Usado para procurar um elemento |
booleano público isEmpty() | Verifica se a coleção está vazia |
booleano público é igual (elemento objeto) | Verificações de igualdade |
Aulas de coleção
Como sabemos, o framework possui diferentes interfaces que são implementadas por diversas classes dentro dele. Agora vamos dar uma olhada em algumas classes comumente usadas.Lista vinculada
É a estrutura de dados mais comumente usada que implementa uma lista duplamente vinculada para armazenar os elementos dentro dela. Ele pode armazenar elementos duplicados. Ele implementa a interface Dequeue estendida pela interface Queue e pela interface List. Não está sincronizado. Agora vamos ver como resolver nosso problema discutido acima (o conceito FIFO) usando LinkedList. O problema é atender os clientes da maneira que eles chegam, ou seja, primeiro a entrar, primeiro a sair .Exemplo
import java.util.*;
public class LinkedListExample {
public static void main(String[] args) {
Queue<String> customerQueue = new LinkedList<String>();
//Adding customers to the Queue as they arrived
customerQueue.add("John");
customerQueue.add("Angelina");
customerQueue.add("Brooke");
customerQueue.add("Maxwell");
System.out.println("Customers in Queue:"+customerQueue);
//element() => returns head of the queue
//we will see our first customer and serve him
System.out.println("Head of the queue i.e first customer: "+customerQueue.element());
//remove () method =>removes first element(customer) from the queue i.e the customer is served so remove him to see next
System.out.println("Element removed from the queue: "+customerQueue.remove());
//poll () => removes and returns the head
System.out.println("Poll():Returned Head of the queue: "+customerQueue.poll());
//print the remaining customers in the Queue
System.out.println("Final Queue:"+customerQueue);
}
}
Saída
Clientes na fila:[John, Angelina, Brooke, Maxwell] Chefe da fila, ou seja, primeiro cliente: John Elemento removido da fila: John Poll():Retornado Chefe da fila: Angelina Fila final:[Brooke, Maxwell]
ListaArray
Ele simplesmente implementa a interface List. Ele mantém o pedido de inserção e usa um array dinâmico para armazenar elementos de diferentes tipos de dados. Os elementos podem ser duplicados. Também não é sincronizado e pode armazenar valores nulos. Agora vamos ver seus diferentes métodos... São úteis quando não sabemos quantos registros ou elementos precisamos inserir. Tomemos o exemplo de uma biblioteca onde não sabemos quantos livros temos que guardar. Portanto, sempre que tivermos um livro, precisamos inseri-lo no ArrayList.Exemplo
public class ArrayListExample {
public static void main(String args[]) {
// Creating the ArrayList
ArrayList<String> books = new ArrayList<String>();
// Adding a book to the list
books.add("Absalom, Absalom!");
// Adding a book in array list
books.add("A Time to Kill");
// Adding a book to the list
books.add("The House of Mirth");
// Adding a book to the list
books.add("East of Eden");
// Traversing the list through Iterator
Iterator<String> itr = books.iterator();
while (itr.hasNext()) {
System.out.println(itr.next());
}
}
}
Saída
Absalão, Absalão! É hora de matar a Casa da Alegria a Leste do Éden
HashSet
Implementa a interface Set e nunca contém valores duplicados. Ele implementa a tabela hash para armazenar os valores. Também permite valores nulos. Ele nunca mantém o pedido de inserção, mas fornece desempenho de tempo constante para métodos add , remove , size e contains . É melhor para operações de pesquisa e não está sincronizado.Exemplo
import java.util.*;
class HashSetExample{
public static void main(String args[]){
//creating HashSet and adding elements to it
HashSet<Integer> hashSet=new HashSet();
hashSet.add(1);
hashSet.add(5);
hashSet.add(4);
hashSet.add(3);
hashSet.add(2);
//getting an iterator for the collection
Iterator<Integer> i=hashSet.iterator();
//iterating over the value
while(i.hasNext()) {
System.out.println(i.next());
}
}
}
Saída
1 2 3 4 5
Como você pode ver, não mantém o pedido de inserção.
ArrayDeque
Ele implementa a interface Deque para permitir operações de ambas as extremidades. Não permite valores nulos. É mais rápido que Stack e LinkedList quando implementado como Stack e LinkedList. ArrayDeque não tem restrições de tamanho à medida que aumenta e diminui de acordo com os requisitos. Não é sincronizado, o que significa que não é seguro para threads. Para mantê-lo seguro para threads, temos que implementar alguma lógica externa.Exemplo
import java.util.*;
public class ArrayDequeExample {
public static void main(String[] args) {
//creating Deque and adding elements
Deque<String> deque = new ArrayDeque<String>();
//adding an element
deque.add("One");
//adding an element at the start
deque.addFirst("Two");
//adding an element at the end
deque.addLast("Three");
//traversing elements of the collection
for (String str : deque) {
System.out.println(str);
}
}
}
Saída
Dois Um Três
HashMap
É a implementação da interface Map apoiada pela tabela hash. Ele armazena os pares de valores-chave. Não permite valores nulos. Não está sincronizado. Nunca garante o pedido de inserção. Ele fornece desempenho de tempo constante para métodos como get e put . Seu desempenho depende de dois fatores — capacidade inicial e fator de carga . Capacidade é o número de buckets na tabela hash, portanto a capacidade inicial é o número de buckets alocados no momento da criação. O fator de carga é a medida de quanto uma tabela hash pode ser preenchida antes que sua capacidade seja aumentada. O método rehash é usado para aumentar a capacidade e principalmente duplica o número de baldes.Exemplo
import java.util.*;
public class HashMapExample{
public static void main(String args[]){
//creating a HashMap
HashMap<Integer,String> map=new HashMap<Integer,String>();
//putting elements into the map
map.put(1,"England");
map.put(2,"USA");
map.put(3,"China");
//get element at index 2
System.out.println("Value at index 2 is: "+map.get(2));
System.out.println("iterating map");
//iterating the map
for(Map.Entry m : map.entrySet()){
System.out.println(m.getKey()+" "+m.getValue());
}
}
}
Saída
O valor no índice 2 é: Mapa iterativo da China 1 Inglaterra 2 EUA 3 China
Algoritmos
A estrutura Collections nos fornece diferentes algoritmos para diferentes operações a serem aplicadas às coleções. Aqui veremos quais operações principais são cobertas por esses algoritmos. Ele contém algoritmos relacionados a:- Ordenação
- Procurando
- Embaralhando
- Manipulação de dados de rotina
- Composição
- Encontrando Valores Extremos
Ordenação
O algoritmo de classificação reordena uma lista de acordo com um relacionamento de ordenação. Duas formas de relacionamento são fornecidas.- Ordenação Natural
- Ordenação de comparação
Ordenação Natural
Na ordenação natural, uma lista é ordenada de acordo com seus elementos.Ordenação de comparação
Nesta forma de ordenação um parâmetro adicional, que é um comparador, é passado junto com a lista. Um algoritmo de classificação por mesclagem ligeiramente otimizado é usado para classificação, que é rápido e estável, pois garante o tempo de execução n log (n) e não reordena elementos iguais. Estaremos usando o mesmo exemplo de ArrayList para demonstrar a classificação.Exemplo
import java.util.*;
public class SortingExample{
public static void main(String args[]){
//Creating arraylist
ArrayList<String> books=new ArrayList<String>();
//Adding a book to the arraylist
books.add("A Time to Kill");
//Adding a book to the arraylist
books.add("Absalom, Absalom!");
//Adding a book to the arraylist
books.add("The House of Mirth");
//Adding a book to the arraylist
books.add("East of Eden");
//Traversing list through Iterator before sorting
Iterator itrBeforeSort=books.iterator();
while(itrBeforeSort.hasNext()){
System.out.println(itrBeforeSort.next());
}
//sorting the books
Collections.sort(books);
System.out.println("After sorting the books");
//Traversing list through Iterator after sorting
Iterator itr=books.iterator();
while(itr.hasNext()){
System.out.println(itr.next());
}
}
}
Saída
É hora de matar Absalão, Absalão! A Casa da Alegria a Leste do Éden Depois de classificar os livros Hora de Matar Absalão, Absalão! Leste do Éden A Casa da Alegria
GO TO FULL VERSION