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

# Pilas

Na implementación mais moderna de Java **non existe unha interface denominada Pila que unicamente soporte este comportamiento LIFO.** O motivo e que se considerou unha pila como un caso particular de Cola dobremente enlazada, onde so tes que empregar un dos extremos ( o do inicio). De este xeito, reempregouse a **interface Deque** defindo unha serie de métodos que actuan exactamente coma unha pila:

* push(E) é un alias de addFirst(E)
* pop() é un alias de removeFirst()
* peek() é un alias de peekFirst()

## Stack\<E>

A clase Stack é unha clase en Java que representa unha estrutura de datos de tipo LIFO (*Last-In, First-Out* — o último en entrar é o primeiro en saír). Estende a clase `Vector`, o que significa que herda as súas capacidades de array dinámico, pero está deseñada especificamente para modelar unha pila de elementos.

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

As súas características son:&#x20;

* **Estructura LIFO dinámica:** O último elemento en entrar é o primeiro en sair. Engade elementos de forma dinámica, de tal forma que non é necesario definir o seu tamaño inicial.
* **Herdanza da clase Vector:** Herda os métodos de vector, que permite a inserción ou acceso a elementos en calquera posición. Esta implementación foi moi discutida, debido a súa pouca adecuación. Unha solución mais correcta houbera sido implementar Stack coma unha interface.
* **É unha clase sincronizada (synchronized):** Significa que pode ser empregada por procesos xestionados por diferentes hilos de forma segura, pero tamen implica que é mais lenta que outras alternativas que non o son. En moitos casos, a solución pasa por traballar con estructuras non sincronizadas e xestionar de maneira externa o control da concorrencia.

| **Método**         | **Especificación**                                                          |
| ------------------ | --------------------------------------------------------------------------- |
| push(E item)       | Engade un elemento na parte superior da pila e devólveo.                    |
| pop()              | Elimina o elemento superior da pila e devólveo (LIFO).                      |
| peek()             | Devolve o elemento superior sen eliminalo da pila.                          |
| empty()            | Verifica se a pila está baleira (devolve `true` ou `false`).                |
| search(Object o)   | Devolve a posición (base 1) desde o cumio da pila onde está o obxecto.      |
| size()             | Devolve o número total de elementos presentes na pila.                      |
| contains(Object o) | Verifica se o elemento especificado existe na estrutura.                    |
| clear()            | Elimina todos os elementos, deixando a pila totalmente baleira.             |
| add(E element)     | Engade un elemento ao final (herdado de Vector, pero menos usado en pilas). |
| remove(int index)  | Elimina o elemento nunha posición específica (herdado de Vector).           |
| isEmpty()          | Alias de `empty()`, tamén verifica se non hai elementos.                    |

```java
Stack<String> pilaLibros = new Stack<>();
pilaLibros.push("O Quixote");
pilaLibros.push("Harry Potter");
System.out.println("Pila inicial: " + pilaLibros);
System.out.println("Cima: " + pilaLibros.peek());
pilaLibros.pop();
System.out.println("Pila tras pop: " + pilaLibros);
```

{% hint style="warning" %}
A documentación recomenda o emprego de **Deque** como alternativa mais moderna e consistente
{% endhint %}

## Deque\<E>

A interface Deque\<E> (*Double Ended Queue*) estende a Queue e permite a inserción e eliminación de elementos en ambos os dous extremos. **Pode actuar tanto como unha cola (FIFO) como unha pila (LIFO -&#x20;*****Last-In-First-Out*****).**

Se estamos a traballar con Deque coma Pila, a interface define as operacións clásicas da interface

* `push(E e)`: Engade un elemento ao principio (cima).
* `pop()`: Elimina e devolve o primeiro elemento.
* `peek()`: Devolve o elemento da cima sen eliminalo.

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

## ArrayDeque\<E>

ArrayDeque é unha clase en Java que proporciona unha "cola de dobre extremo" (*Double Ended Queue*) baseada nun array dinámico Esta estrutura permite engadir ou eliminar elementos de forma extremadamente eficiente tanto pola fronte como polo final. No noso caso&#x20;

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

```java
Deque<String> pila = new ArrayDeque<>();
pila.push("Primeiro");
pila.push("Segundo");
String cima = pila.pop(); // Devolve "Segundo"
```

## Traballando con pilas en Java

Se traballamos con estructuras de datos tipo Pila empregando Deque - ArrayDeque, o que vai a ocorrer que non podemos garantir e que un usuario trate a estructura como unha pila, xa que permite insertar e eliminar ao principio e ao final, e pode dar lugar a erros. Para solucionar este aspecto, e posible limitar a súa funcionalidade mediante o encapsulamento:

<pre class="language-java"><code class="lang-java">import java.util.ArrayDeque;
import java.util.Deque;

public class Pila &#x3C;E>{
    private Deque&#x3C;E> pila;

    public Pila(){
        this.pila = new ArrayDeque&#x3C;>();
    }

    public void push(E elemento){
        this.pila.push(elemento);
    }

    public E peek(){
        return this.pila.peek();
    }

    public E pop(){
        return this.pila.pop();
    }

    public int size(){
        return this.pila.size();
    }
    
    public boolean isEmpty(){
        return this.pila.isEmpty();
    }
    
    @Override
<strong>    public String toString(){
</strong>        return pila.toString();
    }
}
</code></pre>


---

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