> 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/mapas.md).

# Mapas

## Interface Map\<K,V>

A interface `Map<K, V>` é unha das estruturas fundamentais de Java. Representa unha estrutura de chave-valor **(Key ⇒ Value)**, onde cada chave é única e apunta a un valor determinado.&#x20;

As súas características principais son:

* **Chaves únicas:** Non permite chaves duplicadas. Se inseres unha chave que xa existe, o valor vello substitúese polo novo
* **Valores duplicados:** Diferentes chaves poden apuntar ao mesmo valor ( Ao traballar con xenéricos, tanto chaves como valores son sempre obxectos, polo que os tipos primitivos deben usarse coas súas clases envoltorio (`Integer`, `Double`, etc.).)&#x20;
* **Acceso directo:** Esta deseñado para realizar accesos moi rápidos a partir da chave. As clases concretas que a implementan adoitan empregar estructuras de datos tipos hash ou arbores.

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

| **Método**                            | **Descrición**                                                                                     |
| ------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `V put(K key, V value)`               | Engade unha parella chave-valor. Se a chave xa existía, substitúe o valor e devolve o antigo.      |
| `V get(Object key)`                   | Retorna o valor asociado á chave indicada ou `null` se a chave non existe no mapa.                 |
| `V remove(Object key)`                | Elimina a entrada (chave e valor) asociada á chave indicada e devolve o valor que tiña.            |
| `boolean containsKey(Object key)`     | Comproba se o mapa contén a chave indicada (operación moi eficiente).                              |
| `boolean containsValue(Object value)` | Comproba se o mapa contén o valor indicado (operación máis lenta, require percorrido).             |
| `int size()`                          | Retorna o número total de parellas chave-valor (entradas) que contén o mapa.                       |
| `Set<K> keySet()`                     | Retorna un conxunto (`Set`) que contén todas as chaves presentes no mapa.                          |
| `Collection<V> values()`              | Retorna unha colección con todos os valores (pode conter duplicados).                              |
| `Set<Map.Entry<K, V>> entrySet()`     | Retorna un conxunto de obxectos `Entry` (parellas) para poder iterar sobre chaves e valores á vez. |

## HashMap\<K, V>

A clase `HashMap` é a implementación máis común de `Map`. Utiliza unha táboa hash para organizar as chaves, o que permite un acceso case instantáneo aos datos.

As súas caracteristicas principais son:

* **Sen orde:** Non garante ningunha orde específica para as chaves.
* **Rendemento O(1):** As operacións `put`, `get` e `containsKey` son de tempo constante.
* **Permite null:** Admite unha chave nula e múltiples valores nulos

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

```java
Map<String, Integer> idades = new HashMap<>();
//Engadir
idades.put("Ana", 25);
idades.put("Carlos", 30);
//Recuperar
System.out.println("O valor de Ana é " + idades.get("Ana"));
idades.put("Ana", 26);
System.out.println("O novo valor de Ana é " + idades.get("Ana"));
```

### Percorrendo estructuras Map

A interface Map non herda de Collections nin de iterable, co que **non é posible percorrer un Mapa empregando directamente un iterador**. Sen embargo, a clase nos ofrece dúas alternativas para poder implementar dito percorrido:

#### O método Set\<K> keySet()

Este método devolve un conxunto coas claves que conforman o Mapa. Un conxunto é unha estructura de datos que herda de Collection, polo que é posible percorrela mediante un iterador ou un for-each

```java
//For-each
for (String clave: idades.keySet()){
            System.out.println("Clave: " + clave +  " - Valor: " + idades.get(clave));
}

//Iterador
Iterator<String> it = idades.keySet().iterator(); 
//Devolve un Set<String> do que sacamos o Iterator<String>
while (it.hasNext()){
            String clave = it.next();
            System.out.println("Clave: " + clave +  " - Valor: " + idades.get(clave));
}
```

#### O método Set<`Map.Entry<K, V>`> entrySet()

Este método devolve un conxunto coas entradas (pares clave - valor) que compoñen o Mapa. Un conxunto é unha estructura de datos que herda de Collection, polo que é posible percorrela mediante un iterador ou un for-each

```java
//For-each
for (Map.Entry<String, Integer> entrada : idades.entrySet()) {
        System.out.println(entrada.getKey() + " ten " + entrada.getValue() + " anos");
}

//Iterador
Iterator<Map.Entry<String, Integer> > itMapEntry = idades.entrySet().iterator();
while (itMapEntry.hasNext()){
        Map.Entry<String,Integer> entrada = itMapEntry.next();
        System.out.println(entrada.getKey() + " ten " + entrada.getValue() + " anos");
}
```

## TreeMap\<K, V>

A clase `TreeMap` almacena as chaves seguindo a súa orde natural (alfabética, numérica...) ou un comparador personalizado mediante unha estructura en forma de árbore.

As súas características son:

* **Orde garantida:** As chaves están sempre ordenadas.
* **Rendemento O(log n):** É un pouco máis lento que `HashMap` debido ao mantemento da árbore.
* **Non permite null nas chaves:** Lanza `NullPointerException` (necesita comparar as chaves entre si).

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

```java
Map<String, String> dicionario = new TreeMap<>();
dicionario.put("Zume", "Bebida de froitas");
dicionario.put("Abella", "Insecto produtor de mel");
dicionario.put("Casa", "Lugar onde vivir");

// Ao iterar, aparecerán en orde alfabética: Abella, Casa, Zume
for (String chave : dicionario.keySet()) {
    System.out.println(chave);
}
```


---

# 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/mapas.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.