> 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/listas.md). # Listas ## Interface List\ A interface List\ é unha das pezas fundamentais das Collections en Java. Representa unha lista, e vai a forzar a todas as clases que implementen esta interface a desenvolver os métodos, entre os que destacamos: | **Método** | **Especificación** | | --------------------------- | ----------------------------------------------------------------------- | | `add(E e)` | Engade o elemento especificado ao final da lista. | | `add(int index, E element)` | Insire o elemento nunha posición específica, desprazando os demais. | | `get(int index)` | Devolve o elemento que se atopa na posición indicada. | | `set(int index, E element)` | Substitúe o elemento na posición indicada por un novo. | | `remove(int index)` | Elimina o elemento na posición indicada e devólveo. | | `remove(Object o)` | Elimina a primeira aparición do obxecto especificado, se existe. | | `size()` | Devolve o número total de elementos presentes na lista. | | `indexOf(Object o)` | Devolve o índice da primeira aparición do elemento (ou -1 se non está). | | `contains(Object o)` | Devolve `true` se a lista contén o elemento buscado. | | `clear()` | Elimina todos os elementos da lista, deixándoa baleira. | | `isEmpty()` | Verifica se a lista non ten elementos. | {% hint style="warning" %} **Documentación oficial:** {% endhint %} ## ArrayList\ ArrayList é unha clase en Java que proporciona unha **lista dinámica de tamaño variable,** que emprega un array interno que se redimensiona automaticamente á medida que engades ou eliminas elementos, polo que é unha das estruturas de datos máis usadas para almacenar listas de elementos en Java. {% hint style="warning" %} **Documentación oficial:** {% endhint %} As características principais de `ArrayList`:copy:son: * **Tamaño Dinámico**: A `ArrayList`:copy: pode aumentar ou reducir o seu tamaño automaticamente segundo se engadan ou eliminen elementos. * **Acceso Rápido**: Permite o acceso aos elementos mediante un índice. * **Permite Duplicados e Nulos**: A `ArrayList`:copy: permite elementos duplicados e admite `null` como valor. Esencialmente implementa os métodos descritos na interface List: * **Engadir elementos**: `void add(E elemento)`:copy: Engade un elemento ao final da lista. Tamén podes especificar un índice para engadir o elemento nunha posición específica `void add(int posición, E elemento)`:copy: ```java nomes.add("Ana"); // Engade ao final nomes.add(0, "Carlos"); // Engade no índice 0 ``` * **Obter elementos**: `E get(int indice)`:copy: Obtén o elemento nun índice específico. ```java String nome = nomes.get(0); // Retorna "Carlos" ``` * **Actualizar elementos**: `set(int indice, E elemento)`:copy: Modifica o valor dun elemento nun índice específico. ```java nomes.set(1, "Lucía"); // Cambia "Ana" por "Lucía" no índice 1 ``` * **Eliminar elementos**: `E remove(int indice)`:copy: Elimina o elemento nun índice especificado ou o primeiro elemento que coincida cun valor `E remove(E elemento)`:copy:. ```java nomes.remove(0); // Elimina "Carlos" nomes.remove("Lucía"); // Elimina "Lucía" se existe ``` * **Verificar se contén un elemento**: `boolean contains(Object obj)`:copy: Comproba se a lista contén un elemento específico. ```java boolean existe = nomes.contains("Ana"); // Retorna true se "Ana" está na lista ``` * **Obter o tamaño da lista**: `int size()`:copy: Retorna o número de elementos na lista. ```java int tamaño = nomes.size(); // Retorna o tamaño da lista ``` * **Comprobar se a lista está baleira**: `boolean isEmpty()`:copy: Comproba se a lista está baleira. ```java boolean estaBaleira = nomes.isEmpty(); // Retorna true se non hai elementos ``` * **Limpar a Lista**: `void clear()`:copy: Elimina todos os elementos da lista. ```java nomes.clear(); // A lista queda baleira ``` * **Obter o Índice dun Elemento**: `int indexOf(E element)`:copy: Retorna o índice da primeira aparición dun elemento. ```java int indice = nomes.indexOf("Lucía"); // Retorna o índice de "Lucía" ``` * **Converter a `ArrayList`**:copy: **a array**: `E[] toArray()`:copy: Converte a `ArrayList`:copy: nun *array*. Útil se necesitas un *array* regular para traballar con métodos que requiran *arrays*. ```java String[] array = nomes.toArray(new String[0]); ``` ## LinkedList\ `LinkedList` é unha clase en Java que implementa unha lista dobremente enlazada. A diferenza do `ArrayList`, **non utiliza un array interno, senón unha serie de nodos conectados entre si.** Cada nodo contén o elemento e dous punteiros (un ao anterior e outro ao seguinte), o que a fai especialmente eficiente para engadir ou eliminar elementos en calquera posición da lista. {% hint style="warning" %} **Documentación oficial:** {% endhint %} As características principais de LinkedList son: * **Estrutura de Nodos:** Cada elemento está enlazado cos seus veciños, o que evita ter que mover grandes bloques de datos ao facer cambios. * **Dobre Interface:** Implementa tanto `List` como `Deque`, polo que pode funcionar como unha Lista, unha Pila ou unha Cola. * **Eficiencia en Inserción/Eliminación:** Engadir ou quitar elementos nos extremos é extremadamente rápido (O(1)). * **Permite Duplicados e Nulos:** Admite elementos repetidos e valores `null`. {% hint style="warning" %} A estructura de datos mais empregada de forma profesional é **ArrayList.** As razóns son as seguintes: a) O acceso por índice é mais rápido b) As insercións ao final son mais rápidas c) O consumo de memoria é menor, non almacena punteiros Unha estructura de datos tipo **LinkedList** ten sentido para implementar estructuras de datos nas que se vai a ter moitas insercións ao principio (Pilas e Colas) {% endhint %} --- # 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/listas.md?ask= ``` 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.