Pausa para café #185. Um guia abrangente para o Java Collection Framework

Fonte: Medium Este tutorial irá ajudá-lo a entender melhor o funcionamento das diversas classes e interfaces incluídas no Java Collection Framework. Java Collection é uma estrutura que fornece uma arquitetura unificada para armazenar e gerenciar um grupo de objetos. Basicamente, é um conjunto de classes e interfaces que fornecem uma maneira padrão de representar e manipular coleções de objetos na linguagem Java. A estrutura também ajuda na implementação de estruturas de dados comumente usadas, como Lista, Conjunto e Mapa. O Java Collection Framework inclui diversas interfaces e classes. Aqui está uma lista de alguns deles:

Interfaces

As interfaces no Java Collection Framework definem o comportamento geral e as operações que podem ser executadas nas coleções. Isso inclui adicionar ou remover itens, repetir itens em uma coleção e muito mais.

• Coleção : A interface raiz em uma hierarquia de coleção, representando um grupo de objetos conhecidos como elementos.
• Lista : Uma coleção ordenada de elementos que permite duplicação.
• Conjunto : uma coleção de elementos que não permitem duplicação.
• Mapa : uma coleção de pares chave-valor, onde cada chave é única.
• Fila : uma fila é uma estrutura de dados usada para armazenar elementos em First-In-First-Out (FIFO).

Esta lista não inclui tudo, mas apenas as interfaces mais utilizadas no Java Collection Framework. Agora vamos dar uma olhada em cada um deles.

Coleção

Uma coleção é um grupo de objetos conhecidos como seus elementos. Este é um objeto que pode conter referências a outros objetos. A interface Collection é a raiz da hierarquia da coleção. Esta é a interface base para todas as coleções do Java Collection Framework. Ele define os métodos básicos que devem ser implementados em todas as coleções, como add() , remove() e contains() . Aqui está um exemplo de uso de coleções no Java Collection Framework. Aqui a interface Collection é usada para adicionar e remover elementos de uma coleção:

import java.util.Collection;
import java.util.ArrayList;

public class CollectionExample {
    public static void main(String[] args) {
        // Создаем новую коллекцию
        Collection<String> stringCollection = new ArrayList<>();

        // Добавляем несколько элементов в коллекцию
        stringCollection.add("hello");
        stringCollection.add("world");
        stringCollection.add("foo");
        stringCollection.add("bar");

        // Печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());

        // Удаляем элемент из коллекции
        stringCollection.remove("foo");

        // Опять печатаем число элементов в коллекции
        System.out.println("Number of elements: " + stringCollection.size());
    }
}

A saída é: Como você pode ver, a interface Collection é uma maneira simples e conveniente de realizar operações comuns com uma coleção de objetos. Muitas vezes é usado como ponto de partida ao trabalhar com coleções em Java. O Java Collection Framework inclui diversas interfaces que definem o comportamento comum para diferentes tipos de coleções. Alguns deles fazem parte do grupo de interface java.util.Collection :

• java.util.List
• java.util.set
• java.util.Queue

java.util.List

Lista é uma coleção ordenada de objetos, cada elemento ocupa uma posição específica na lista. A interface List estende a interface Collection e adiciona vários métodos para trabalhar com listas, como métodos para acessar elementos por sua posição na lista e métodos para pesquisar e classificar listas. Uma lista pode conter elementos duplicados , esses elementos podem ser acessados ​​por sua posição na lista. Aqui está um exemplo de uso da interface List para adicionar, remover e acessar itens em uma lista:

import java.util.List;
import java.util.ArrayList;

public class ListExample {
    public static void main(String[] args) {
        // Создаем новый список
        List<String> stringList = new ArrayList<>();

        // Добавляем несколько элементов в список
        stringList.add("India");
        stringList.add("UAE");
        stringList.add("London");
        stringList.add("US");

        // Печатаем первый элемент в списке
        System.out.println("First element: " + stringList.get(0));

        // Удаляем второй элемент из списка
        stringList.remove(1);

        // Печатаем второй элемент в списке
        System.out.println("Second element: " + stringList.get(1));
    }
}

Conclusão: Conforme mostrado acima, a interface List fornece uma maneira conveniente de trabalhar com coleções ordenadas de elementos. Normalmente é usado quando você precisa manter a ordem dos elementos em uma coleção ou quando precisa acessar os elementos por seu índice em uma lista.

java.util.Set

Um conjunto no Java Collection Framework é um conjunto não ordenado de elementos exclusivos que não permite elementos duplicados . A interface Set estende a interface Collection e adiciona vários métodos, como métodos para verificar se um elemento está em um conjunto e métodos para adicionar e remover elementos de um conjunto. Aqui está um exemplo de uso da interface Set para adicionar e remover elementos de um conjunto no Java Collection Framework:

import java.util.Set;
import java.util.HashSet;

public class SetExample {
    public static void main(String[] args) {
        // Создаем новый set
        Set<String> stringSet = new HashSet<>();

        // Добавляем несколько элементов в set
        stringSet.add("Jan");
        stringSet.add("Feb");
        stringSet.add("March");
        stringSet.add("April");

        // Проверяем наличие в set element "March"
        if (stringSet.contains("March")) {
            System.out.println("The set contains the element 'March'");
        }

        // Удаляем элемент "April" из set
        stringSet.remove("April");

        // Опять проверяем наличие element "April" в set
        if (!stringSet.contains("April")) {
            System.out.println("The set no longer contains the element 'April'");
        }
    }
}

Conclusão:

java.util.Queue

Uma fila é uma estrutura de dados usada para armazenar elementos na ordem primeiro a entrar, primeiro a sair (FIFO). Isso significa que o primeiro elemento adicionado à fila será o primeiro elemento removido. Aqui está um exemplo de como usar uma fila no Java Collection Framework:

// Creation очереди
Queue<String> queue = new LinkedList<>();

// Добавление элементов в очередь
queue.add("apple");
queue.add("banana");
queue.add("orange");
// Печатаем очередь
System.out.println("Queue: " + queue);
// Удаляем элемент из очереди
String element = queue.remove();
System.out.println("Removed element: " + element);
// Печатаем обновленную очередь
System.out.println("Queue: " + queue);

Neste exemplo, criamos uma fila de strings e adicionamos três elementos a ela: “maçã”, “banana” e “laranja”. Em seguida, imprimimos a fila para ver seu estado atual. A seguir, removemos o elemento da fila e o imprimimos no console. Finalmente, imprimimos a fila atualizada para garantir que o elemento removido não esteja mais na fila.

Mapa

A interface java.util.Map no Java Collection Framework é usada para mapear chaves para valores. Ele permite armazenar elementos como pares de valores-chave e fornece métodos para acessar, modificar e iterar elementos em um mapa. Abaixo está um exemplo de uso da interface do mapa :

// Создаем Map
 Map<String, Integer> map = new  HashMap <>();
// Добавляем элементы в Map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печать Map
 System.out.println("Map: " + map);
// Получаем meaning для определенного ключа
int  value  = map.get( "banana" );
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из Map
map.remove("orange");
// Печать обновленной карты
 System.out.println( "Map: " + map);

Neste exemplo, criamos um mapa de strings e inteiros adicionando três elementos a ele: mapas “maçã” para 1, mapas “banana” para 2 e mapas “laranja” para 3. Em seguida, imprimimos o mapa para ver seu valor atual. significado. Depois disso, obtemos o valor da chave “banana” e imprimimos no console. Por fim, removemos o par de valores-chave “laranja” do mapa e imprimimos o mapa atualizado para ver se o elemento removido não está mais lá.

Aulas

Uma classe é uma implementação concreta de uma interface de coleção. Ele fornece implementações específicas de comportamentos e operações comuns definidas por interfaces na estrutura.

• ArrayList : uma implementação da interface List com um array redimensionável.
• LinkedList : uma lista duplamente vinculada, uma implementação das interfaces List e Deque .
• HashSet : uma implementação de Set que usa uma tabela hash para armazenamento.
• TreeSet : uma implementação de Set que usa uma árvore para armazenamento.
• HashMap : uma implementação do Map que usa uma tabela hash para armazenamento.

A lista acima é uma das classes mais comumente usadas no Java Collection Framework. Agora vamos dar uma olhada na explicação detalhada dessas classes.

ListaArray

A classe java.util.ArrayList em coleções Java é usada para armazenar uma matriz redimensionável de elementos em uma lista. É uma implementação amplamente utilizada da interface java.util.List que usa um array para armazenar elementos e fornece métodos eficientes para acessar, modificar e iterar através de elementos em uma lista. A classe java.util.ArrayList fornece acesso aleatório rápido aos seus elementos, mas inserção e remoção lentas em posições aleatórias. Abaixo está um exemplo de uso da classe ArrayList no Java Collection Framework:

// Создаем array list
List<String> list = new ArrayList<>();
// Добавляем элементы в array list
list.add("qa");
list.add("devops");
list.add("dev");
// Печатаем array list
System.out.println("Array list: " + list);
// Доступ к элементу по определенному индексу
String element = list.get(1);
System.out.println("Element at index 1: " + element);
// Удаление element из the array list
list.remove(1);
// Print the updated array list
System.out.println("Array list: " + list);

Como você pode ver, criamos um array de strings e adicionamos três elementos a ele: “qa”, “devops” e “dev”. Em seguida, imprimimos a lista de arrays para ver seu estado atual. Depois disso, acessamos o elemento no índice 1 e o imprimimos no console. Finalmente, removemos o elemento no índice 1 da lista de arrays e imprimimos uma lista de arrays atualizada para garantir que o elemento removido não esteja mais na lista.

Lista vinculada

A classe java.util.LinkedList no Java Collection Framework herda da classe AbstractList e implementa as interfaces List e Deque . Ele fornece métodos eficientes para adicionar, remover e acessar elementos no início e no final de uma lista. Esta classe também é uma implementação da interface List , que usa uma lista duplamente vinculada para armazenar elementos. Ele fornece inserção e exclusão rápida em posições arbitrárias, mas acesso aleatório lento aos seus elementos. Aqui está um exemplo de como usar a classe LinkedList no Java Collection Framework:

// Создаем linked list
List<String> list = new LinkedList<>();
// Добавляем элементы в linked list
list.add("selenium");
list.add("cypress");
list.add("playwright");
// Печатаем linked list
System.out.println("Linked list: " + list);
// Добавляем элемент в начало списка
list.add(0, "webdriver.io");
// Печатаем обновленный linked list
System.out.println("Linked list: " + list);
// Удаляем первый элемент в списке
list.remove(0);
// Еще раз печатаем обновленный linked list
System.out.println("Linked list: " + list);

Neste exemplo, criamos uma lista vinculada de strings e adicionamos três elementos a ela: “selenium”, “cypress” e “dramaturgo”. Em seguida, imprimimos a lista vinculada para ver seu estado atual. A seguir, adicionamos o elemento “webdriver.io” ao início da lista e imprimimos a lista vinculada atualizada. Por fim, removemos o primeiro elemento da lista e imprimimos novamente a lista vinculada atualizada para ver se o elemento excluído não está mais na lista.

HashSet

A classe java.util.HashSet no Java Collection Framework é usada para armazenar uma coleção de elementos exclusivos em um conjunto. Ele fornece uma implementação baseada em tabela hash da interface java.util.Set . Também fornece inserção, exclusão e pesquisa rápidas, mas não preserva a ordem de seus elementos. Abaixo está um exemplo de uso da classe HashSet no Java Collection Framework:

// Создаем hash set
Set<String> set = new HashSet<>();

// Добавляем элементы в hash set
set.add("rose");
set.add("lily");
set.add("lotus");
// Попытка добавить повторяющийся элемент
set.add("rose");
// Печатаем hash set
System.out.println("Hash set: " + set);
// Удаляем элемент из hash set
set.remove("lily");
// Печать обновленного hash set
System.out.println("Hash set: " + set);

Aqui criamos um conjunto hash de strings e adicionamos três elementos a ele: “rosa”, “lírio” e “lótus”. Tentamos então adicionar o elemento “rosa” novamente, mas como o conjunto de hash não permite duplicatas, ele não será adicionado. Depois disso, imprimimos o conjunto de hash para ver seu estado atual. Em seguida, removemos o elemento “lírio” do conjunto e imprimimos o hash atualizado do conjunto para ver se o elemento removido não está mais no conjunto.

Conjunto de árvores

A classe java.util.TreeSet no Java Collection Framework é usada para armazenar uma coleção de elementos exclusivos em um conjunto classificado em ordem crescente. Ele fornece uma implementação baseada em árvore da interface java.util.Set para armazenar elementos sem permitir elementos duplicados. A classe fornece inserção, exclusão e pesquisa rápidas e mantém a ordem de seus elementos de acordo com sua ordem natural ou comparador. Aqui está um exemplo de como usar a classe TreeSet no Java Collection Framework:

// Создаем tree set
Set<String> set = new TreeSet<>();

// Добавляем элементы в tree set
set.add("apple");
set.add("banana");
set.add("orange");
// Попытка добавить повторяющийся элемент
set.add("apple");
// Печатаем tree set
System.out.println("Tree set: " + set);
// Удаляем элемент из tree set
set.remove("banana");
// Печатаем обновленный tree set
System.out.println("Tree set: " + set);

Neste exemplo, criamos um conjunto de strings em árvore e adicionamos três elementos a ele: “maçã”, “banana” e “laranja”. Tentamos então adicionar o elemento “apple” novamente, mas como o conjunto da árvore não permite duplicatas, ele não será adicionado. Depois disso, imprimimos o conjunto da árvore para ver seu estado atual. Como o conjunto da árvore está ordenado em ordem crescente, os elementos serão impressos na ordem: “maçã”, “banana” e “laranja”. Em seguida, removemos o elemento “banana” do conjunto e imprimimos o conjunto de árvore atualizado para ver se o elemento removido não está mais no conjunto.

HashMap

A classe java.util.HashMap no Java Collection Framework é usada para armazenar o mapeamento de chaves para valores em um mapa. Ele fornece uma implementação baseada em tabela hash da interface java.util.Map e permite que os elementos sejam armazenados como pares de valores-chave. A classe fornece inserção, exclusão e pesquisa rápidas, mas não preserva a ordem de seus elementos. Aqui está um exemplo de como usar a classe HashMap no Java Collection Framework:

// Создаем hash map
Map<String, Integer> map = new HashMap<>();

// Добавляем элементы в hash map
map.put("apple", 1);
map.put("banana", 2);
map.put("orange", 3);
// Печатаем hash map
System.out.println("Hash map: " + map);
// Получаем meaning для определенного ключа
int value = map.get("banana");
System.out.println("Value for 'banana': " + value);
// Удаляем элемент из hash map
map.remove("orange");
// Печатаем обновленный hash map
System.out.println("Hash map: " + map);

Neste exemplo, criamos um mapa hash de strings inteiras e adicionamos três elementos a ele: “maçã” corresponde a 1, “banana” corresponde a 2 e “laranja” corresponde a 3. Em seguida, imprimimos o mapa hash para vê-lo Estado atual. Depois disso, obtemos o valor da chave “banana” e imprimimos no console. Por fim, removemos o par de valores-chave “laranja” do mapa hash e imprimimos o mapa hash atualizado para ver se o elemento removido não está mais nele.

Conclusão

O Java Collection Framework é um conjunto de classes e interfaces que fornece uma maneira padrão de representar e manipular coleções de objetos na linguagem de programação Java. Isso permite que desenvolvedores/testadores trabalhem com coleções de objetos de maneira consistente e eficiente. A estrutura fornece métodos para armazenar, acessar e gerenciar itens em uma coleção e permite alternar facilmente entre diferentes implementações de coleção, dependendo dos requisitos do aplicativo.