> For the complete documentation index, see [llms.txt](https://educacion.gitbook.io/programacion/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://educacion.gitbook.io/programacion/ud6-estructuras-de-datos-avanzadas/estructuras-de-datos-en-java.md).

# Estructuras de datos en Java

Java implementa un conxunto de interfaces e clases que permiten traballar con TADs implementados mediante estruturas de datos concretas:

{% @mermaid/diagram content="classDiagram
%% Interface Ra
class Collection {
<<interface>>
+add(E e)
+size()
}

```
%% TAD Listas (Lineal, orde específica, calquera posición)
class List {
    <<interface>>
    +get(index)
    +add(index, element)
}
Collection <|-- List
List <|.. ArrayList
List <|.. LinkedList

%% TAD Conxunto (Elementos únicos, sen orde)
class Set {
    <<interface>>
}
Collection <|-- Set
Set <|.. HashSet
Set <|.. TreeSet

%% TAD Colas (FIFO) e Pilas (LIFO)
class Queue {
    <<interface>>
    +poll() FIFO
}
class Deque {
    <<interface>>
    +push() LIFO
    +pop() LIFO
}
Collection <|-- Queue
Queue <|-- Deque
Deque <|.. ArrayDeque
LinkedList ..|> Deque

%% TAD Mapas / Táboas Hash (Clave-Valor)
%% Nota: Map é independente de Collection en Java
class Map {
    <<interface>>
    +put(key, value)
    +get(key)
}
Map <|.. HashMap
Map <|.. TreeMap
```

" %}

## Collection\<E>

**Java** proporciónamos unha serie de **estruturas dinámicas** que comparten un conxunto de métodos declarados na **interface** **`Collection<E>.`**

{% hint style="warning" %}
**Documentación oficial:** <https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Collection.html>
{% endhint %}

Os métodos mais destacados para traballar con Collection serían:

| **Método**                   | **Especificación**                                                                                                              |
| ---------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `boolean add(E e)`           | Engade o elemento indicado á colección. Devolve `true` se a colección cambiou (por exemplo, os `Set` non engaden se xa existe). |
| `boolean remove(Object o)`   | Elimina unha única instancia do elemento especificado, se está presente. Devolve `true` se se atopou e eliminou con éxito.      |
| `int size()`                 | Devolve o número total de elementos presentes na colección nese momento.                                                        |
| `boolean contains(Object o)` | Devolve `true` se a colección contén o elemento indicado. Moi útil para verificacións rápidas de existencia.                    |
| `void clear()`               | Baleira por completo a colección, eliminando todos os elementos dunha soa vez.                                                  |
| `boolean isEmpty()`          | Devolve `true` se a colección non ten elementos. É máis lexible que facer `size() == 0`.                                        |

`Collection`<i class="fa-copy">:copy:</i> é unha interface raíz na xerarquía de coleccións e **ten diversas interfaces fillas que especifican diferentes tipos de coleccións** (listas, conxuntos, colas, etc.). Estas interfaces son **implantadas por varias clases concretas** que proporcionan as implantacións reais das coleccións:

* **`List`**: Unha lista é unha colección lineal e ordenada que pode conter elementos duplicados. Implantacións típicas: **`ArrayList`**<i class="fa-copy">:copy:</i>, `LinkedList`<i class="fa-copy">:copy:</i>, `Vector`<i class="fa-copy">:copy:</i>, etc.
* **`Set`**: Un conxunto é unha colección que non permite elementos duplicados e non ten orde garantida. Implantacións típicas: `HashSet`<i class="fa-copy">:copy:</i>, `LinkedHashSet`<i class="fa-copy">:copy:</i>, `TreeSet`<i class="fa-copy">:copy:</i>, etc.
* **`Queue`**: Unha cola é unha colección que segue a orde de tipo “FIFO” (primeiro en entrar, primeiro en saír). Implantacións típicas: `LinkedList`<i class="fa-copy">:copy:</i>, `PriorityQueue`<i class="fa-copy">:copy:</i>, `ArrayDeque`<i class="fa-copy">:copy:</i>, etc.
* **`Deque`**: Unha cola que permite inserir e eliminar elementos desde ambos os dous extremos. Implantacións típicas: `ArrayDeque`<i class="fa-copy">:copy:</i>, `LinkedList`<i class="fa-copy">:copy:</i>.

## Map\<K,V>

A interface Map atopase fora da xerarquía de Collection, é unha interface que define unha colección de pares clave-valor, mentres que as interfaces derivadas de `Collection`<i class="fa-copy">:copy:</i> xiran arredor de coleccións de elementos.

{% hint style="warning" %}
**Documentación oficial:** [**https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Map.html**](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/Map.html)
{% endhint %}

Map define un conxunto de métodos para traballar con pares de clave-valor.

| **Método**                        | **Especificación**                                                                                        |
| --------------------------------- | --------------------------------------------------------------------------------------------------------- |
| `V put(K key, V value)`           | Asocia o valor indicado coa clave indicada. Se a clave xa existía, substitúe o valor anterior e devólveo. |
| `V get(Object key)`               | Recupera o valor asociado á clave. Devolve `null` se a clave non existe no mapa.                          |
| `boolean containsKey(Object key)` | Permite saber se existe unha entrada para esa clave. É moi rápido e eficiente.                            |
| `Set<K> keySet()`                 | Devolve un Conxunto (`Set`) con todas as claves. Úsase moito para iterar sobre o mapa.                    |
| `Collection<V> values()`          | Devolve unha Colección con todos os valores (aquí si pode haber duplicados).                              |
| `V remove(Object key)`            | Elimina a entrada completa (clave e valor) asociada á clave indicada.                                     |

Existen diferentes interfaces fillas de Map coma SortedMap, NavigableMap,... Pero non imos a afondar neste punto


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://educacion.gitbook.io/programacion/ud6-estructuras-de-datos-avanzadas/estructuras-de-datos-en-java.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
