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

# Conxuntos

## Interface Set\<E>

A interface `Set<E>` é unha das interfaces fundamentais das Collections en Java. Representa un **conxunto matemático**, e vai forzar a todas as clases que a implementen a desenvolver os seus métodos. As súas características principais son:

* **Non permite duplicados**: Se intentas engadir un elemento que xa existe, a operación simplemente non ten efecto.
* **Permite un único `null`** (dependendo da implementación)
* **Non garante orde** (dependendo da implementación)

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

| Método                                      | Descrición                                                                                       |
| ------------------------------------------- | ------------------------------------------------------------------------------------------------ |
| `boolean add(E e)`                          | Engade un elemento se non existe xa                                                              |
| `boolean remove(Object o)`                  | Elimina o elemento indicado                                                                      |
| `boolean contains(Object o)`                | Comproba se o elemento existe                                                                    |
| `int size()`                                | Retorna o número de elementos                                                                    |
| `boolean isEmpty()`                         | Comproba se está baleiro                                                                         |
| `void clear()`                              | Elimina todos os elementos                                                                       |
| `Iterator<E> iterator()`                    | Retorna un iterador                                                                              |
| `boolean addAll(Collection<? extends E> c)` | **Unión**: engade todos os elementos da colección. Modifica o conxunto receptor                  |
| `boolean retainAll(Collection<?> c)`        | **Intersección**: elimina os elementos que non estean na colección. Modifica o conxunto receptor |
| `boolean removeAll(Collection<?> c)`        | **Diferenza**: elimina os elementos que estean na colección. Modifica o conxunto receptor        |

## HashSet\<E>

`HashSet` é a implementación máis usada de `Set`. Internamente utiliza unha **táboa hash** (concretamente un `HashMap`) para almacenar os elementos, o que lle proporciona un rendemento moi alto nas operacións principais.

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

As características principais son:

* **Sen orde garantida**: Os elementos non se almacenan en ningún orde concreto nin de inserción.
* **Rendemento O(1)**: `add`, `remove` e `contains` son operacións de tempo constante na maioría dos casos.
* **Permite un `null`**: Admite exactamente un elemento nulo.
* **Non é thread-safe**: Non está sincronizado para uso concorrente.

java

```java
Set<String> conxunto = new HashSet<>();

// Engadir elementos
conxunto.add("Ana");
conxunto.add("Carlos");
conxunto.add("Ana"); // Ignorado, xa existe

// Comprobar se contén un elemento
boolean existe = conxunto.contains("Ana"); // true

// Eliminar un elemento
conxunto.remove("Carlos");

// Tamaño
int tam = conxunto.size(); // 1

// Iterar
for (String s : conxunto) {
    System.out.println(s);
}

// Operacións de conxunto
Set<String> a = new HashSet<>(Arrays.asList("Ana", "Carlos", "Marta"));
Set<String> b = new HashSet<>(Arrays.asList("Carlos", "Marta", "Luís"));

// Unión: todos os elementos de a e b
Set<String> union = new HashSet<>(a);
union.addAll(b); // {Ana, Carlos, Marta, Luís}

// Intersección: só os elementos comúns
Set<String> interseccion = new HashSet<>(a);
interseccion.retainAll(b); // {Carlos, Marta}

// Diferenza: elementos de a que non están en b
Set<String> diferenza = new HashSet<>(a);
diferenza.removeAll(b); // {Ana}
```

## TreeSet\<E>

`TreeSet` é unha implementación de `Set` que almacena os elementos **ordenados de forma natural** mediante unha estructura en forma de árbore.

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

Documentación oficial: <https://docs.oracle.com/javase/8/docs/api/java/util/TreeSet.html>

As características principais son:

* **Orde natural**: Os elementos almacénanse ordenados (alfabética, numérica...).
* **Rendemento O(log n)**: As operacións son algo máis lentas que `HashSet`.
* **Non permite `null`**: Lanza `NullPointerException` se intentas inserir `null`.

```java
Set<String> conxunto = new TreeSet<>();

conxunto.add("Carlos");
conxunto.add("Ana");
conxunto.add("Marta");

// Imprime: Ana, Carlos, Marta (orde alfabética)
for (String s : conxunto) {
    System.out.println(s);
}

// Operacións de conxunto (tamén respectan a orde)
TreeSet<String> a = new TreeSet<>(Arrays.asList("Ana", "Carlos", "Marta"));
TreeSet<String> b = new TreeSet<>(Arrays.asList("Carlos", "Marta", "Luís"));

// Unión: todos os elementos en orde alfabética
TreeSet<String> union = new TreeSet<>(a);
union.addAll(b); // {Ana, Carlos, Luís, Marta}

// Intersección: só os elementos comúns, en orde
TreeSet<String> interseccion = new TreeSet<>(a);
interseccion.retainAll(b); // {Carlos, Marta}

// Diferenza: elementos de a que non están en b, en orde
TreeSet<String> diferenza = new TreeSet<>(a);
diferenza.removeAll(b); // {Ana}
```


---

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