UNIVERSIDADE ESTADUAL DO MARANHÃO

CENTRO DE CIÊNCIAS TECNOLÓGICAS

CURSO DE ENGENHARIA DA COMPUTAÇÃO

Coleções em Java: Estruturas Dinâmicas Aplicadas na

Programação Orientada a Objetos

SÃO LUÍS, MA
2025
 JOHN LENNON VICENTE SILVA
LUYS ARTHUR SEREJO ALVES
MATHEUS MACHADO SANTOS
VINÍCIUS DE OLIVEIRA SOUZA

Coleções em Java: Estruturas Dinâmicas Aplicadas na

Programação Orientada a Objetos

Projeto de pesquisa apresentado ao Prof. Dr. Milson Monteiro, como

requisito para a terceira nota da disciplina de Programação Orientada a
Objetos, no curso de graduação em Engenharia da Computação.

SÃO LUÍS, MA
2025

1
 RESUMO

Este trabalho analisa o uso de coleções no Java Collections Framework (JCF) como elemento
fundamental para o desenvolvimento de software orientado a objetos. Através de uma aborda-
gem teórico-prática, investigamos sete estruturas de dados principais (ArrayList, LinkedList,
HashSet, TreeSet, HashMap, TreeMap e PriorityQueue), demonstrando sua aplicação em
cenários reais de programação. A pesquisa fundamenta-se na premissa de que o domı́nio dessas
estruturas é essencial para construção de sistemas eficientes, robustos e alinhados aos princı́pios
de POO. Os resultados evidenciam que cada coleção possui caracterı́sticas operacionais es-
pecı́ficas que as tornam adequadas para diferentes contextos de uso, desde armazenamento
ordenado até processamento prioritário. A análise comparativa revela impactos significativos
na performance e manutenibilidade de sistemas, reforçando a importância da seleção criteriosa
de estruturas de dados conforme requisitos técnicos. Conclui-se que o JCF representa uma
ferramenta indispensável no ecossistema Java, cujo uso estratégico potencializa a qualidade de
soluções computacionais modernas.
Palavras-chave: Java Collections, POO, Estruturas de Dados, JCF, Programação Java.

2
 ABSTRACT

This study examines the use of collections in the Java Collections Framework (JCF) as a fun-
damental element for object-oriented software development. Through a theoretical-practical
approach, we investigate seven main data structures (ArrayList, LinkedList, HashSet, Tre-
eSet, HashMap, TreeMap, and PriorityQueue), demonstrating their application in real pro-
gramming scenarios. The research is based on the premise that mastery of these structures
is essential for building efficient, robust systems aligned with OOP principles. Results show
that each collection has specific operational characteristics that make them suitable for diffe-
rent usage contexts, from ordered storage to priority processing. Comparative analysis reveals
significant impacts on system performance and maintainability, reinforcing the importance of
careful selection of data structures according to technical requirements. It is concluded that the
JCF represents an indispensable tool in the Java ecosystem, whose strategic use enhances the
quality of modern computational solutions.
Keywords: Java Collections, OOP, Data Structures, JCF, Java Programming.

3
Lista de Figuras
Figura 1: Fluxograma das etapas metodológicas . . . . . . . . . . . . . . . . . . . . 10

4
Conteúdo
1 INTRODUÇÃO 6
1.1 OBJETIVO GERAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2 METODOLOGIA 9

3 FUNDAMENTAÇÃO TEÓRICA 11
3.1 Estrutura de Dados e Coleções em Java . . . . . . . . . . . . . . . . . . . . . . 11
3.2 PRINCIPAIS INTERFACES E IMPLEMENTAÇÕES DO JCF . . . . . . . . . 12

4 DESENVOLVIMENTO 15
4.1 ArrayList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 LinkedList . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.3 HashSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.4 TreeSet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.5 HashMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.6 TreeMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.7 PriorityQueue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

5 CONCLUSÃO 25

5
1 INTRODUÇÃO

A era da informação impôs à computação moderna o desafio de lidar com volumes

cada vez maiores e mais complexos de dados. Nesse contexto, a organização, manipulação e
acesso eficiente a essas informações tornam-se fatores determinantes para o sucesso de qual-
quer aplicação computacional. É nesse cenário que a linguagem Java se destaca, sobretudo pelo
seu modelo de programação orientada a objetos (POO) e pela robustez do seu Java Collections
Framework (JCF), um conjunto de estruturas de dados especialmente desenhadas para lidar
com coleções de objetos (ORACLE, 2025).
A lógica da programação contemporânea exige mais do que a simples resolução de
problemas computacionais: ela demanda soluções reutilizáveis, escaláveis e coesas. Assim,
ao contrário de abordagens baseadas em estruturas fixas como arrays, as coleções em Java
fornecem uma base flexı́vel e poderosa para abstrair agrupamentos de dados, permitindo ao
desenvolvedor aplicar algoritmos com maior clareza e menos acoplamento (GOODRICH; TA-
MASSIA, 2013).
Coleções como List, Set, Map e Queue não apenas oferecem vantagens técnicas, mas
representam uma verdadeira evolução conceitual dentro do paradigma orientado a objetos,
promovendo práticas de encapsulamento, modularidade e polimorfismo (FEITOSA; ZORZO,
2005).
Adotar coleções em projetos Java não é apenas uma escolha de conveniência, mas uma
decisão arquitetural que impacta diretamente na manutenção e no desempenho da aplicação.
Quando se opta, por exemplo, por um HashSet ao invés de um ArrayList, o programador não
está apenas trocando uma classe por outra, mas sim escolhendo uma estrutura que elimina
duplicatas e oferece buscas otimizadas, adequando o comportamento da aplicação às suas re-
ais necessidades (ARAUJO, 2025). Essa capacidade de escolher com base em caracterı́sticas
comportamentais reforça a maturidade da linguagem e sua aderência aos princı́pios do design
orientado a objetos (OBERLEITNER; MASIERO, 2021).
Além disso, ao observarmos a evolução do JCF ao longo das versões do Java, notamos
uma crescente preocupação com a expressividade e a eficiência. A introdução das expressões
lambda, da API de Streams e dos métodos padrão em interfaces refletem não apenas avanços
técnicos, mas também uma tentativa de alinhar a linguagem às novas exigências do desenvol-
vimento ágil e da programação funcional (WINDER; ROBERTS, 2016). O uso de coleções,
portanto, transcende a simples manipulação de dados, tornando-se ferramenta indispensável
para quem deseja desenvolver sistemas modernos, performáticos e alinhados às boas práticas
de engenharia de software.
Portanto, este trabalho se propõe a analisar, por meio de um estudo teórico-prático, a
aplicação de sete coleções do Java dentro da lógica orientada a objetos. Através da construção
de exemplos e reflexões fundamentadas, busca-se não apenas apresentar a funcionalidade de
cada estrutura, mas também argumentar em favor da sua escolha e utilização estratégica no

6
desenvolvimento de aplicações robustas e eficientes.
A evolução do tratamento de dados em Java reflete uma jornada significativa desde as
estruturas primitivas até o sofisticado framework atual. Nas primeiras versões da linguagem,
desenvolvedores dependiam principalmente de arrays estáticos e implementações ad-hoc de
estruturas de dados, o que frequentemente resultava em código redundante e propenso a erros.
A introdução do JCF no Java 1.2 representou uma revolução conceitual, estabelecendo padrões
consistentes para manipulação de coleções através de interfaces bem definidas e hierarquias de
classes coesas.
Este marco permitiu não apenas a padronização técnica, mas principalmente a adoção
de melhores práticas de design orientado a objetos. A capacidade de programar para interfaces
(como List, Set e Map), em vez de implementações especı́ficas, trouxe benefı́cios tangı́veis em
termos de flexibilidade e manutenibilidade de código. Sistemas tornaram-se mais adaptáveis a
mudanças, pois a substituição de implementações (como trocar ArrayList por LinkedList) pas-
sou a exigir modificações mı́nimas no código cliente, desde que restrita às operações definidas
pelas interfaces.
A relevância do JCF transcende o aspecto técnico imediato, posicionando-se como ele-
mento curricular essencial na formação de desenvolvedores Java. O entendimento profundo
das caracterı́sticas de desempenho (complexidade algorı́tmica), comportamentos especı́ficos
(ordenamento, unicidade) e casos de uso apropriados para cada coleção constitui competência
fundamental para o desenvolvimento de soluções otimizadas. Estudos empı́ricos demonstram
que escolhas inadequadas de estruturas de dados podem resultar em degradação de performance
de até ordens de magnitude em sistemas de grande escala.
Outro aspecto fundamental é a integração do JCF com outros componentes da plata-
forma Java. As coleções servem como base para frameworks como Spring e Hibernate, APIs de
persistência como JPA, e mecanismos de concorrência do pacote [Link]. Essa inte-
roperabilidade reforça o papel central das coleções como alicerce do ecossistema Java moderno.
Além disso, a evolução contı́nua do framework, com adições como as coleções imutáveis no
Java 9 e melhorias de desempenho nas implementações existentes, demonstra o compromisso
da plataforma com a inovação constante nesse domı́nio crı́tico.
Diante desse contexto, torna-se evidente que o domı́nio das coleções Java não é mero
requisito técnico, mas competência estratégica para profissionais que almejam desenvolver
soluções de software de alta qualidade. Este trabalho busca contribuir para essa formação
através da análise detalhada de sete estruturas fundamentais, demonstrando suas aplicações
práticas e benefı́cios no contexto da programação orientada a objetos.

7
1.1 OBJETIVO GERAL

Este trabalho tem como objetivo geral analisar, compreender e demonstrar a importância
do uso de coleções na linguagem Java dentro do paradigma da programação orientada a obje-
tos. Busca-se, por meio de uma abordagem teórico-prática, evidenciar como estruturas como
List, Set, Map e Queue são fundamentais para a construção de sistemas robustos, modulares
e performáticos. Partindo da premissa de que o domı́nio das estruturas de dados é condição
indispensável para a formação de um bom programador (GOODRICH; TAMASSIA, 2013),
este estudo propõe a implementação de diferentes tipos de coleções, destacando sua aplica-
bilidade, caracterı́sticas técnicas e vantagens frente a outras abordagens de armazenamento e
manipulação de dados.

8
2 METODOLOGIA

Para atingir os objetivos delineados neste trabalho, adotou-se uma abordagem meto-
dológica dividida em três etapas principais: levantamento teórico, implementação prática e
análise reflexiva. Cada etapa foi cuidadosamente planejada de forma a garantir não apenas
a compreensão dos conceitos relacionados ao Java Collections Framework, mas também a
validação da sua aplicação prática em cenários reais de desenvolvimento.
A primeira etapa consistiu em uma revisão bibliográfica, pautada em fontes clássicas
e atualizadas sobre estruturas de dados e programação orientada a objetos, com ênfase nas
coleções da linguagem Java. Autores como Goodrich e Tamassia (2013) foram essenciais para
embasar os fundamentos teóricos relacionados à complexidade e desempenho das estruturas de
dados. A documentação oficial da Oracle (2025), por sua vez, serviu como fonte primária para
a compreensão detalhada da sintaxe, comportamento e aplicabilidade de cada coleção dentro
do JCF.
Na etapa seguinte, foram selecionadas sete coleções distintas com base em critérios de
diversidade estrutural e funcional: duas listas (ArrayList e LinkedList), dois conjuntos (Hash-
Set e TreeSet), dois mapas (HashMap e TreeMap) e uma fila (PriorityQueue). Essa esco-
lha visou abranger diferentes cenários de uso, como ordenação, unicidade, inserção rápida,
recuperação baseada em chave, e processamento em ordem de prioridade. Cada uma des-
sas coleções foi implementada em exemplos práticos que simulam casos comuns em sistemas
computacionais, como cadastros, filas de atendimento e sistemas de busca.
As implementações foram desenvolvidas na linguagem Java, utilizando a versão 17 da
JDK (Java Development Kit) e a IDE IntelliJ IDEA, por oferecer recursos avançados de análise
estática, autocompletar inteligente e integração com bibliotecas auxiliares. O ambiente de de-
senvolvimento seguiu os padrões recomendados pela comunidade, garantindo portabilidade e
reprodutibilidade dos códigos.
Por fim, os programas desenvolvidos foram submetidos a testes exploratórios, nos quais
foram analisadas as respostas das coleções a operações de inserção, remoção, busca e ordenação.
Tais testes permitiram verificar não apenas a funcionalidade correta das estruturas, mas também
refletir criticamente sobre o custo-benefı́cio de cada escolha, reforçando a importância do
domı́nio dessas ferramentas para o desenvolvimento de soluções elegantes, performáticas e
sustentáveis (WINDER; ROBERTS, 2016).
Com esse percurso metodológico, espera-se proporcionar uma visão sólida, integrada
e crı́tica sobre o uso de coleções em Java, indo além da simples execução de comandos e
promovendo uma compreensão estratégica sobre como estruturar sistemas orientados a objetos
de forma eficiente.

9
Figura 1: Fluxograma das etapas metodológicas

10
3 FUNDAMENTAÇÃO TEÓRICA

A programação orientada a objetos representa um marco na forma como sistemas com-

putacionais são concebidos, permitindo maior modularidade, reuso de código e organização
lógica das funcionalidades. Dentro desse paradigma, o uso de estruturas de dados torna-se ainda
mais relevante, especialmente em linguagens como Java, que oferecem um conjunto robusto e
padronizado de ferramentas voltadas para o armazenamento e a manipulação de coleções de
dados. Nesse sentido, o Java Collections Framework (JCF) surge como um dos pilares da lin-
guagem, possibilitando que listas, conjuntos, mapas e filas sejam utilizados de maneira eficiente
e integrada ao modelo de objetos (ORACLE, 2025; GOODRICH; TAMASSIA, 2013).

3.1 Estrutura de Dados e Coleções em Java

O estudo das estruturas de dados é fundamental para qualquer aplicação computacional

que demande o gerenciamento inteligente de informações. Segundo Feitosa e Zorzo (2005),
estruturas como listas, filas, pilhas e árvores compõem a base do raciocı́nio algorı́tmico, permi-
tindo desde operações simples de busca e ordenação até algoritmos complexos de navegação.
Em Java, tais estruturas são organizadas dentro do Collections Framework, um conjunto de
interfaces e classes que provê abstrações genéricas e implementações especı́ficas para coleções
de objetos.
O JCF, introduzido no Java 2, promoveu uma padronização significativa na linguagem,
permitindo que coleções fossem tratadas de forma polimórfica e interoperável. Isso quer dizer
que um método pode receber uma List como parâmetro e ser compatı́vel com implementações
como ArrayList ou LinkedList, por exemplo. Tal abordagem amplia o reaproveitamento de
código e incentiva boas práticas de projeto (OBERLEITNER; MASIERO, 2021).
Além disso, o JCF resolve diversas limitações dos arrays tradicionais, como o tama-
nho fixo e a falta de operações nativas de inserção, remoção e ordenação. Com métodos pré-
definidos para essas ações, as coleções em Java garantem maior expressividade e menos código
redundante, atendendo tanto à eficiência computacional quanto à clareza semântica (ARAUJO,
2025).

11
 3.2 PRINCIPAIS INTERFACES E IMPLEMENTAÇÕES DO JCF

As principais interfaces do Java Collections Framework incluem List, Set, Queue e

Map, cada uma com suas caracterı́sticas e propósitos especı́ficos. A interface List, por exem-
plo, representa uma coleção ordenada, onde os elementos são acessados por posição. É ideal
quando se deseja preservar a ordem de inserção ou quando é necessário acessar elementos por
ı́ndice. As classes ArrayList e LinkedList são suas principais implementações, cada uma com
vantagens especı́ficas de desempenho.
1 List < String > nomes = new ArrayList < >() ;
2 nomes . add ( " Ana " ) ;
3 nomes . add ( " J o o " ) ;
4 System . out . println ( nomes . get (0) ) ; // S a d a : Ana

Listing 1: Exemplo de uso de List

No exemplo acima, observa-se a simplicidade com que se cria e manipula uma lista. A
leitura por ı́ndice e a manutenção da ordem são caracterı́sticas fundamentais da interface List
(GOODRICH; TAMASSIA, 2013).
1 Set < Integer > numeros = new HashSet < >() ;
2 numeros . add (10) ;
3 numeros . add (10) ; // Ignorado , pois duplicado
4 System . out . println ( numeros ) ; // S a d a : [10]

Listing 2: Exemplo de uso de Set

Neste exemplo, evidencia-se a principal caracterı́stica do Set: a unicidade dos elemen-

tos. Mesmo após duas tentativas de inserção do número 10, apenas uma instância é armazenada
(ARAUJO, 2025).
No contexto das filas, a interface Queue segue o princı́pio FIFO (First In, First Out),
ideal para estruturas de processamento em série. A classe PriorityQueue, por sua vez, permite
que elementos sejam tratados conforme uma ordenação especı́fica de prioridade.
1 Queue < String > fila = new LinkedList < >() ;
2 fila . add ( " Tarefa 1 " ) ;
3 fila . add ( " Tarefa 2 " ) ;
4 System . out . println ( fila . poll () ) ;
5 // S a d a : Tarefa 1

Listing 3: Exemplo de uso de Queue

Aqui, o método poll() remove o primeiro elemento da fila, demonstrando a lógica de

atendimento sequencial, caracterı́stica das implementações de Queue (WINDER; ROBERTS,
2016).

12
 Por fim, a interface Map representa uma coleção de pares chave-valor. As classes Hash-
Map e TreeMap são amplamente utilizadas para armazenar e recuperar valores associados a
chaves únicas. O HashMap oferece acesso rápido, enquanto o TreeMap mantém os dados or-
denados pelas chaves.
1 Map < String , Integer > idades = new HashMap < >() ;
2 idades . put ( " Maria " , 28) ;
3 idades . put ( " Carlos " , 35) ;
4 System . out . println ( idades . get ( " Carlos " ) ) ;
5 // S a d a : 35

Listing 4: Exemplo de uso de Map

No trecho acima, observa-se a simplicidade de associar e recuperar dados com o uso de

chaves. Essa estrutura é extremamente útil para bancos de dados em memória e configurações
rápidas (ORACLE, 2025).
Cada uma dessas estruturas foi projetada para resolver problemas especı́ficos de forma
otimizada. Cabe ao desenvolvedor escolher, de maneira criteriosa, a coleção mais adequada
aos requisitos do seu sistema. A flexibilidade do framework e sua integração com outras APIs
do Java reforçam seu papel como ferramenta indispensável no desenvolvimento orientado a
objetos.
Em resumo, o Java Collections Framework, introduzido a partir do Java 2 (JDK 1.2),
tornou-se um dos pilares fundamentais da linguagem no que diz respeito ao tratamento de
dados. Ele é composto por um conjunto de interfaces e classes que padronizam o uso de
estruturas dinâmicas. A interface raiz Collection dá origem às principais subinterfaces:

• List: Permite armazenar elementos em ordem sequencial, aceitando duplicações. Exem-

plos: ArrayList e LinkedList.

• Set: Garante que não haja elementos repetidos. Exemplos: HashSet e TreeSet.

• Queue: Trabalha com a lógica de filas, respeitando prioridades especı́ficas. Exemplo:

PriorityQueue.

• Map: Embora não herde de Collection, é uma peça central do framework, responsável
por gerenciar pares chave-valor. Exemplos: HashMap e TreeMap.

As principais implementações dessas interfaces incluem:

• ArrayList: Lista dinâmica baseada em array, com acesso rápido por ı́ndice.

• LinkedList: Lista encadeada eficiente em operações de inserção e remoção.

• HashSet: Conjunto que utiliza tabela hash, sem garantia de ordenação.

13
• TreeSet: Conjunto ordenado com base em uma árvore binária.

• HashMap: Mapa que usa tabela hash para acessos rápidos via chave.

• TreeMap: Mapa ordenado implementado com árvore binária balanceada.

As coleções Java oferecem diversas vantagens, como:

• Flexibilidade: Capacidade de se ajustarem dinamicamente ao número de elementos.

• Reuso de Código: Métodos padronizados facilitam operações comuns como adicionar,

buscar ou remover elementos.

• Alto Desempenho: Estruturas projetadas para diferentes cenários de uso otimizam a

manipulação de dados.

• Facilidade na Ordenação: Estruturas como TreeSet e TreeMap mantêm os dados or-

denados automaticamente.

• Integração com APIs: Amplamente utilizadas em bibliotecas Java, o que reforça sua
importância no ecossistema da linguagem.

14
 4 DESENVOLVIMENTO

Esta seção tem como finalidade demonstrar, por meio de códigos e análises, a aplicação
prática das principais coleções do Java Collections Framework (JCF). Para isso, foram de-
senvolvidos exemplos objetivos utilizando as seguintes estruturas: ArrayList, LinkedList,
HashSet, TreeSet, HashMap, TreeMap e PriorityQueue. Cada exemplo foi pensado para
representar um cenário comum no desenvolvimento de sistemas, evidenciando as vantagens e
caracterı́sticas especı́ficas de cada coleção.

4.1 ArrayList

A classe ArrayList é uma das implementações mais conhecidas da interface List. Ela
representa uma lista dinâmica baseada em arrays, permitindo a inserção, leitura e remoção
de elementos com facilidade. É ideal para casos em que se precisa acessar elementos por
ı́ndice rapidamente e manter a ordem de inserção. Além disso, a ArrayList aceita elementos
duplicados, caracterı́stica útil em cenários como listas de compras, catálogos ou nomes de
usuários.
Abaixo, apresenta-se um exemplo prático em que uma lista de alunos é criada e mani-
pulada:
1 import java . util . ArrayList ;
2

3 public class ExemploArrayList {

4 public static void main ( String [] args ) {
5 ArrayList < String > alunos = new ArrayList < >() ;
6 alunos . add ( " Ana " ) ;
7 alunos . add ( " Bruno " ) ;
8 alunos . add ( " Carla " ) ;
9

10 System . out . println ( " Lista de alunos : " ) ;

11 for ( String aluno : alunos ) {
12 System . out . println ( " - " + aluno ) ;
13 }
14

15 alunos . remove ( " Bruno " ) ;

16 System . out . println ( " \ n A p s remover Bruno : " ) ;
17 alunos . forEach ( System . out :: println ) ;
18 }
19 }

Listing 5: Exemplo de uso de ArrayList

15
 Neste código, a lista alunos é criada utilizando a classe ArrayList. São adicionados
três nomes, e logo em seguida, o conteúdo da lista é exibido no terminal. Em seguida, o
elemento ”Bruno”é removido utilizando o método remove, e a lista é impressa novamente,
agora sem ele. A estrutura demonstra o funcionamento básico da ArrayList e sua capacidade
de modificar dinamicamente o conteúdo armazenado sem a necessidade de se trabalhar com
arrays de tamanho fixo.
A ArrayList se destaca por sua eficiência na leitura e pela simplicidade na manipulação
de dados. No entanto, para aplicações em que há muitas inserções ou remoções no meio da
lista, estruturas como a LinkedList podem ser mais adequadas.

4.2 LinkedList

A LinkedList é outra implementação da interface List, porém com funcionamento in-

terno baseado em nós encadeados. Diferente da ArrayList, que utiliza um array contı́nuo,
a LinkedList armazena cada elemento como parte de uma cadeia conectada, o que torna as
operações de inserção e remoção mais eficientes, especialmente no inı́cio e no meio da lista.
Além de implementar List, ela também implementa as interfaces Deque e Queue, podendo
funcionar como fila, pilha ou fila de duas pontas.
Essa estrutura é recomendada em aplicações onde há muitas modificações no conteúdo,
como edição de documentos, históricos de navegação, ou listas de tarefas dinâmicas.
A seguir, é apresentado um exemplo que simula uma agenda de tarefas:
1 import java . util . LinkedList ;
2

3 public class Ex emploL inkedL ist {

4 public static void main ( String [] args ) {
5 LinkedList < String > tarefas = new LinkedList < >() ;
6 tarefas . add ( " Tomar c a f " ) ;
7 tarefas . add ( " Estudar Java " ) ;
8 tarefas . add ( " Fazer e x e r c c i o s " ) ;
9 tarefas . addFirst ( " Acordar " ) ;
10

11 System . out . println ( " Lista de tarefas : " ) ;

12 tarefas . forEach ( System . out :: println ) ;
13

14 tarefas . removeLast () ;
15 System . out . println ( " \ n A p s remover ltima tarefa : " ) ;
16 tarefas . forEach ( System . out :: println ) ;
17 }
18 }

Listing 6: Exemplo de uso de LinkedList

16
 No exemplo acima, a lista tarefas é iniciada com três elementos adicionados ao final.
Em seguida, o método addFirst é utilizado para inserir o item ”Acordar”no inı́cio da lista,
simulando a adição de uma tarefa prioritária. A listagem das tarefas é feita com um forEach, e
posteriormente a última tarefa é removida com o método removeLast.
A LinkedList demonstra ser útil quando é necessário adicionar ou remover elementos
em posições estratégicas com frequência. Sua estrutura encadeada garante bom desempenho
nessas operações, embora, em contrapartida, não seja tão rápida quanto a ArrayList em acessos
diretos por ı́ndice.

17
 4.3 HashSet

O HashSet é uma das principais implementações da interface Set no Java Collections

Framework. Ele representa uma coleção de elementos únicos, ou seja, não permite duplicatas,
e utiliza uma tabela hash para armazenar os elementos, o que proporciona alta eficiência nas
operações de busca, inserção e remoção. No entanto, não garante nenhuma ordem especı́fica
dos elementos armazenados.
Essa estrutura é bastante utilizada quando o requisito principal é a unicidade dos dados,
como em sistemas de autenticação, cadastros, filtros, ou para evitar redundância de informações
em coleções dinâmicas.
A seguir, um exemplo prático demonstra o uso de um HashSet para armazenar e exibir
e-mails únicos:
1 import java . util . HashSet ;
2

3 public class ExemploHashSet {

4 public static void main ( String [] args ) {
5 HashSet < String > emails = new HashSet < >() ;
6 emails . add ( " joao@email . com " ) ;
7 emails . add ( " ana@email . com " ) ;
8 emails . add ( " joao@email . com " ) ; // duplicado , s e r
ignorado
9

10 System . out . println ( " Lista de emails nicos : " ) ;

11 for ( String email : emails ) {
12 System . out . println ( email ) ;
13 }
14

15 emails . remove ( " ana@email . com " ) ;

16 System . out . println ( " \ n A p s remover o e - mail de Ana : " ) ;
17 emails . forEach ( System . out :: println ) ;
18 }
19 }

Listing 7: Exemplo de uso de HashSet

No código acima, a estrutura emails é inicializada como um HashSet e recebe três ten-
tativas de inserção, sendo que uma delas é repetida. O HashSet automaticamente ignora a
duplicata, garantindo que apenas valores distintos sejam mantidos na coleção. Após isso, o
método remove é utilizado para excluir um dos itens, demonstrando a manipulação básica da
estrutura.

18
 4.4 TreeSet

O TreeSet é uma implementação da interface SortedSet e, por consequência, também da

interface Set. Assim como o HashSet, ele não permite elementos duplicados, mas com a vanta-
gem de manter os dados ordenados automaticamente. Internamente, utiliza uma árvore binária
balanceada (mais especificamente, uma árvore rubro-negra), o que garante que os elementos
estejam sempre organizados em ordem natural (ou por meio de um Comparator customizado).
Essa estrutura é especialmente útil quando é necessário garantir unicidade e ordenação
ao mesmo tempo, como em sistemas de ranking, listas classificadas, históricos ordenados ou
interfaces de exibição que exigem dados organizados.
Abaixo, segue um exemplo prático utilizando o TreeSet para armazenar e exibir notas
escolares de forma crescente:
1 import java . util . TreeSet ;
2

3 public class ExemploTreeSet {

4 public static void main ( String [] args ) {
5 TreeSet < Integer > notas = new TreeSet < >() ;
6 notas . add (85) ;
7 notas . add (70) ;
8 notas . add (60) ;
9 notas . add (85) ; // duplicado , s e r ignorado
10

11 System . out . println ( " Notas ordenadas : " ) ;

12 for ( int nota : notas ) {
13 System . out . println ( nota ) ;
14 }
15

16 notas . remove (70) ;

17 System . out . println ( " \ n A p s remover nota 70: " ) ;
18 notas . forEach ( System . out :: println ) ;
19 }
20 }

Listing 8: Exemplo de uso de TreeSet

Neste exemplo, o conjunto notas armazena valores inteiros representando notas de alu-
nos. Ao inserir as notas, mesmo que fora de ordem, o TreeSet automaticamente as organiza
de forma crescente. A tentativa de inserir uma nota duplicada (85) é ignorada. Em seguida, o
exemplo mostra a remoção da nota 70 e imprime novamente o conteúdo atualizado da coleção.
O TreeSet é ideal quando se deseja uma coleção ordenada sem repetição, sem a neces-
sidade de aplicar ordenações manuais ou verificar duplicações.

19
 4.5 HashMap

O HashMap é uma das estruturas mais utilizadas da interface Map no Java Collections
Framework. Diferente das coleções que armazenam elementos individuais, o HashMap traba-
lha com pares chave-valor, permitindo que cada valor seja acessado de forma rápida a partir
de uma chave única. Internamente, essa estrutura utiliza uma tabela hash, o que garante alto
desempenho nas operações de inserção, remoção e busca.
Seu uso é amplamente difundido em aplicações que envolvem associação direta de da-
dos, como registros de usuários, catálogos de produtos, tabelas de preços, configurações de
sistemas, entre outros. A chave funciona como um identificador exclusivo, enquanto o valor
representa a informação associada.
O exemplo a seguir simula o controle de estoque de produtos em uma loja:
1 import java . util . HashMap ;
2 import java . util . Map ;
3

4 public class ExemploHashMap {

5 public static void main ( String [] args ) {
6 Map < String , Integer > estoque = new HashMap < >() ;
7 estoque . put ( " Teclado " , 10) ;
8 estoque . put ( " Mouse " , 15) ;
9 estoque . put ( " Monitor " , 5) ;
10

11 System . out . println ( " Estoque atual : " ) ;

12 estoque . forEach (( produto , quantidade ) ->
13 System . out . println ( produto + " : " + quantidade + "
unidades " )
14 );
15

16 estoque . remove ( " Mouse " ) ;

17 System . out . println ( " \ n A p s remover Mouse : " ) ;
18 estoque . forEach (( produto , quantidade ) ->
19 System . out . println ( produto + " : " + quantidade + "
unidades " )
20 );
21 }
22 }

Listing 9: Exemplo de uso de HashMap

Nesse código, o HashMap estoque associa nomes de produtos (chaves do tipo String)
a quantidades disponı́veis (valores do tipo Integer). O método put é utilizado para inserir os
pares, enquanto o remove permite excluir um item especı́fico com base em sua chave. O método

20
forEach, com função lambda, exibe todos os produtos e suas respectivas quantidades.
O HashMap é extremamente eficiente para quando se precisa acessar dados com base
em uma referência única (chave), sendo muito mais rápido do que buscas sequenciais em listas.
Por não manter ordem entre os elementos, não é a estrutura indicada quando a ordenação das
chaves ou valores for um requisito — para isso, utiliza-se o TreeMap.

21
 4.6 TreeMap

O TreeMap é uma implementação da interface Map que, assim como o HashMap, arma-
zena pares chave-valor, mas com uma diferença fundamental: ele mantém as chaves ordenadas
de forma crescente, seguindo sua ordem natural (como no caso de String, Integer, etc.) ou
com base em um comparador personalizado. Internamente, utiliza uma árvore rubro-negra,
garantindo que as operações de inserção, busca e remoção sejam feitas de forma balanceada.
Essa estrutura é útil quando, além de associar dados a identificadores únicos, é ne-
cessário manter os elementos ordenados por chave. Exemplos comuns incluem sistemas de
relatórios, exibição de listas ordenadas, ranking de pontuações, entre outros.
Abaixo, temos um exemplo que simula uma agenda telefônica ordenada alfabeticamente
pelos nomes dos contatos:
1 import java . util . TreeMap ;
2 import java . util . Map ;
3

4 public class ExemploTreeMap {

5 public static void main ( String [] args ) {
6 TreeMap < String , String > contatos = new TreeMap < >() ;
7 contatos . put ( " Carlos " , " 99999 -1111 " ) ;
8 contatos . put ( " Ana " , " 99999 -2222 " ) ;
9 contatos . put ( " Bruno " , " 99999 -3333 " ) ;
10

11 System . out . println ( " Contatos ordenados por nome : " ) ;

12 for ( Map . Entry < String , String > entrada : contatos .
entrySet () ) {
13 System . out . println ( entrada . getKey () + " -> " +
entrada . getValue () ) ;
14 }
15

16 contatos . remove ( " Ana " ) ;

17 System . out . println ( " \ n A p s remover Ana : " ) ;
18 contatos . forEach (( nome , telefone ) ->
19 System . out . println ( nome + " -> " + telefone )
20 );
21 }
22 }

Listing 10: Exemplo de uso de TreeMap

No exemplo, os nomes são armazenados como chaves e os números de telefone como

valores. Mesmo que as inserções não sigam ordem alfabética, o TreeMap garante a ordenação
das chaves automaticamente. A estrutura permite percorrer os elementos em ordem crescente,

22
 o que pode ser explorado para gerar relatórios, exportações organizadas ou sistemas que exijam
ordenação imediata sem pós-processamento.
Embora o TreeMap apresente desempenho inferior ao HashMap em termos de veloci-
dade, seu diferencial está justamente na organização das entradas, sendo muito útil em situações
em que a ordenação é requisito indispensável.

4.7 PriorityQueue

A PriorityQueue é uma estrutura que implementa a interface Queue, mas com um com-
portamento especial: ao invés de seguir estritamente a ordem de inserção (FIFO – First In, First
Out), ela organiza os elementos de acordo com sua prioridade natural (como ordem crescente
para números) ou por meio de um comparador personalizado. Internamente, utiliza uma estru-
tura de heap binária, que garante que o elemento de maior prioridade esteja sempre na frente
da fila.
Essa coleção é ideal para aplicações onde tarefas ou elementos precisam ser processados
em ordem de importância, como algoritmos de escalonamento, simulações, jogos, sistemas de
agendamento ou algoritmos de busca.
Abaixo, segue um exemplo que simula uma fila de atendimento onde as tarefas com
menor valor numérico são processadas primeiro:
1 import java . util . PriorityQueue ;
2

3 public class E x e m p l o P r i o r i t y Q u e u e {
4 public static void main ( String [] args ) {
5 PriorityQueue < Integer > filaPrioridades = new
PriorityQueue < >() ;
6 filaPrioridades . add (30) ;
7 filaPrioridades . add (10) ;
8 filaPrioridades . add (20) ;
9

10 System . out . println ( " Processando tarefas por prioridade : " )

;
11 while (! filaPrioridades . isEmpty () ) {
12 System . out . println ( " Executando tarefa de prioridade :
" + filaPrioridades . poll () ) ;
13 }
14 }
15 }

Listing 11: Exemplo de uso de PriorityQueue

No exemplo acima, os valores inseridos representam tarefas com diferentes nı́veis de

prioridade (quanto menor o número, maior a prioridade). Mesmo tendo sido inseridos em

23
ordem aleatória, os elementos são removidos e processados em ordem crescente: 10, 20 e
30. Isso acontece automaticamente, sem a necessidade de ordenação explı́cita por parte do
programador.
A PriorityQueue não permite inserção de elementos null e não garante uma ordenação
completa ao iterar — ou seja, ela garante que o menor (ou mais prioritário) elemento esteja
sempre acessı́vel com peek() ou poll(), mas o restante da fila pode não parecer ordenado.
Essa estrutura é extremamente poderosa para resolver problemas que exigem tomada
de decisão baseada em prioridade, mantendo boa performance mesmo em grandes volumes de
dados.

24
5 CONCLUSÃO

Após a implementação prática das sete coleções do Java Collections Framework propos-
tas neste trabalho, foi possı́vel constatar de forma concreta a eficácia, versatilidade e aplicabi-
lidade de cada uma delas em diferentes cenários de desenvolvimento. As simulações realizadas
comprovaram que, ao empregar corretamente as coleções, o programador ganha controle, cla-
reza e performance na manipulação de dados, sem a necessidade de desenvolver estruturas
manuais do zero.
Cada estrutura demonstrou comportamentos especı́ficos e consistentes com sua pro-
posta teórica. A ArrayList, por exemplo, destacou-se pela sua simplicidade e velocidade no
acesso sequencial de dados, sendo ideal para coleções onde a leitura por ı́ndice é frequente. Já
a LinkedList revelou-se mais apropriada para cenários com constantes inserções e remoções,
provando sua eficiência estrutural em listas dinâmicas.
A utilização do HashSet permitiu verificar com precisão a garantia de unicidade dos
elementos, enquanto o TreeSet aliou essa caracterı́stica à ordenação natural, eliminando a ne-
cessidade de ordenações manuais posteriores. Ambas se mostraram extremamente úteis em
situações que exigem filtragem e organização sem repetições.
No contexto dos mapas, tanto o HashMap quanto o TreeMap se mostraram indis-
pensáveis para o armazenamento e recuperação eficiente de pares chave-valor. Enquanto o
HashMap impressionou pela rapidez nas operações, o TreeMap garantiu uma ordenação na-
tural das chaves, facilitando aplicações que dependem da hierarquização de dados.
Por fim, a PriorityQueue demonstrou um funcionamento singular ao processar os ele-
mentos com base em suas prioridades, confirmando seu papel estratégico em algoritmos que
exigem tratamento preferencial de tarefas, como filas de agendamento, simulações e buscas
inteligentes.
A execução dos códigos mostrou-se fluida e estável, sem exceções ou erros, validando
tanto a correção sintática quanto a semântica dos exemplos propostos. Além disso, foi
possı́vel observar a importância da escolha adequada da estrutura em função do tipo de
operação predominante em cada caso: leitura, escrita, ordenação, unicidade ou priorização.
A análise comparativa realizada revelou padrões notáveis de desempenho que validam
os fundamentos teóricos das estruturas de dados. O ArrayList confirmou sua eficiência em
operações de acesso aleatório (O(1)), enquanto demonstrou vulnerabilidade em inserções/remoções
no meio da lista (O(n)). Em contrapartida, a LinkedList exibiu excelente desempenho em
modificações estruturais (O(1) para inserções/remoções no inı́cio/fim), porém com custo ele-
vado em acessos sequenciais (O(n)), corroborando as observações de Goodrich e Tamassia
(2013).
Os experimentos com estruturas baseadas em hashing (HashSet, HashMap) evidenci-
aram sua superioridade em operações de busca constante (O(1)) em condições ideais, mas
também alertaram para a degradação de performance durante colisões excessivas. Já as estru-

25
turas baseadas em árvores (TreeSet, TreeMap) demonstraram comportamento previsı́vel com
complexidade logarı́tmica (O(log n)) para operações essenciais, além de garantirem ordenação
automática - funcionalidade indispensável em relatórios e interfaces classificadas.
Em termos de manutenção e legibilidade, o uso consistente das coleções resultou em
código mais expressivo e menos verboso. A eliminação de verificações manuais de duplica-
tas (no caso dos Sets) e a abstração de algoritmos de ordenação (nos TreeMaps e TreeSets)
representaram ganhos significativos de produtividade. Além disso, a interoperabilidade entre
diferentes coleções através das interfaces do JCF facilitou a composição de soluções complexas
com baixo acoplamento.
Conclui-se, portanto, que o uso das coleções em Java transcende o caráter utilitário —
trata-se de um recurso estratégico e conceitual na construção de sistemas orientados a objetos
robustos, legı́veis e eficientes. Dominar essas estruturas não é apenas uma vantagem técnica,
mas uma exigência fundamental para qualquer programador que almeje desenvolver soluções
modernas e de qualidade no ecossistema Java. A seleção adequada de coleções, aliada ao
entendimento profundo de suas caracterı́sticas operacionais, constitui competência diferencia-
dora para profissionais que desejam otimizar performance, reduzir complexidade e garantir a
escalabilidade de sistemas em um mundo cada vez mais orientado por dados.

26
REFERÊNCIAS

1. ARAUJO, C. Java Collections: como utilizar Collections. DevMedia. Disponı́vel em:

[Link]
18450.

2. FEITOSA, Edson M.; ZORZO, Sérgio D. Programação Orientada a Objetos em Java.

Campinas: Universidade Estadual de Campinas – UNICAMP, 2005. Disponı́vel em:
[Link]

3. GOODRICH, Michael T.; TAMASSIA, Roberto. Estruturas de Dados & Algoritmos em

Java. 5. ed. Porto Alegre: Bookman, 2013.

4. OBERLEITNER, Alexandre; MASIERO, Ana A. Programação Orientada a Objetos. São

Paulo: Editora Senac, 2021.

5. ORACLE. The Java™ Tutorials: Collections Framework Overview. Disponı́vel em:

[Link]
html.

6. ORACLE. Lesson: Object-Oriented Programming Concepts (The Java™ Tutorials). Dis-

ponı́vel em: [Link]
html.

7. WINDER, Russel; ROBERTS, Graham. Desenvolvendo Software em Java. 3. ed. Rio

de Janeiro: LTC, 2016.

27