Coleções em Java

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.

1. Já implementado (economia de tempo).
2. Eficiência de desempenho (velocidade e qualidade).
3. 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.

1. Interfaces
2. Aulas (implementação)
3. Algoritmos

Hierarquia da Estrutura de Coleção

Para seu entendimento:

1. Coleção, Conjunto, Fila e Lista são interfaces. Set, Queue e List são estendidos pela interface Collection.
2. PriorityQueue, HashSet, LinkedList e Stack são classes ou a implementação dessas interfaces.
3. 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:

1. Classe ArrayList
2. Classe LinkedList
3. Interface de lista
4. Definir interface
5. Interface de fila
6. Interface do mapa
7. Classe PriorityQueue
8. Classe HashMap
9. Interface comparável
10. Classe LinkedHashMap
11. Classe TreeMap
12. 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.

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

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

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

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

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

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:

1. Ordenação
2. Procurando
3. Embaralhando
4. Manipulação de dados de rotina
5. Composição
6. Encontrando Valores Extremos

Para melhor compreensão, discutiremos o algoritmo de classificação.

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.

1. Ordenação Natural
2. 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

Conclusão

Esperamos que agora você já tenha entendido o que é o framework de coleções java, quais são suas interfaces e classes e como implementar suas diferentes classes. Você sempre pode usar esta estrutura para reduzir seus esforços em Java. Sinta-se à vontade para praticar e volte aqui sempre que precisar de mais ajuda. Feliz aprendizado!