Implementaciones ArrayList

Esta es la interfaz List<E>. Aquí tienes una breve explicación de cada método definido en
esta interfaz:

1. void add(E e);

o Descripción: Añade un elemento e a la lista.
2. void add(E e, int index);
o Descripción: Añade un elemento e en una posición específica index en la
lista.
3. E remove(int index);
o Descripción: Elimina el elemento en la posición index de la lista y devuelve
el elemento eliminado.
4. E get(int index);
o Descripción: Devuelve el elemento en la posición index de la lista.
5. int size();
o Descripción: Devuelve el número de elementos en la lista.
6. void clear();
o Descripción: Elimina todos los elementos de la lista.
7. boolean isEmpty();
 o Descripción: Verifica si la lista está vacía y devuelve true si no contiene
elementos, false en caso contrario.

Este conjunto de métodos proporciona la funcionalidad básica para cualquier lista: añadir,
eliminar, obtener elementos, verificar el tamaño y el estado de la lista (vacía o no) y limpiar
todos los elementos. Estas son las firmas de los métodos que cualquier implementación de
una lista, como tu ArrayList, debe proporcionar.

El código anterior define una clase llamada ArrayList, que es una implementación
personalizada de una lista en Java, inspirada en cómo funcionan las listas dinámicas en
muchas bibliotecas estándar. Esta clase es genérica, lo que significa que puede almacenar
elementos de cualquier tipo, especificados por E.

La clase declara tres variables privadas: items, size y capacity. items es un arreglo de
objetos (Object[]) que almacenará los elementos de la lista. La variable size mantiene el
número de elementos actualmente en la lista, mientras que capacity representa la cantidad
máxima de elementos que el arreglo puede almacenar antes de necesitar ser redimensionado.

El constructor de la clase, public ArrayList(), inicializa estas variables. Establece size

en 0, lo que indica que la lista está vacía al principio. La capacidad se establece en 10, lo que
significa que el arreglo items puede contener hasta 10 elementos sin necesidad de
redimensionarse. El arreglo items se inicializa como un nuevo arreglo de objetos con la
capacidad especificada.

Este código proporciona la base para una lista dinámica que puede crecer a medida que se
añaden elementos. Inicializa la lista con una capacidad fija, pero esta puede ser ajustada
(aunque no se muestra en el fragmento de código proporcionado). Esto permite gestionar los
elementos de manera eficiente en términos de memoria y rendimiento.

Vamos a desglosar estas dos funciones paso a paso:

1. Método Expand()
o Descripción: Este método aumenta la capacidad del arreglo items cuando se
llena.
o Explicación:
▪ Object[] aux = new Object[capacity + 10];: Crea un nuevo
arreglo aux con una capacidad aumentada en 10.
▪ System.arraycopy(items, 0, aux, 0, size);: Copia todos los
elementos del arreglo actual items al nuevo arreglo aux.
▪ capacity += 10;: Incrementa la variable capacity en 10,
actualizando la capacidad del arreglo.
▪ items = aux;: Asigna el nuevo arreglo aux a items, reemplazando
el viejo arreglo con el nuevo de mayor capacidad.
2. Método isFull()
 o Descripción: Este método verifica si el arreglo items está lleno.
o Explicación:
▪ return capacity == size;: Devuelve true si la capacidad actual
del arreglo es igual al número de elementos en la lista (size),
indicando que el arreglo está lleno; de lo contrario, devuelve false.

En resumen, Expand() se encarga de aumentar la capacidad del arreglo cuando ya no hay

espacio para más elementos, y isFull() determina si se necesita llamar a Expand()
verificando si el arreglo está lleno.

Esta parte del código añade un elemento a la lista ArrayList y se asegura de que haya
suficiente espacio en el arreglo para el nuevo elemento. Vamos a desglosarlo:

1. @Override
o Descripción: Esta anotación indica que el método add está sobrescribiendo
un método de la interfaz List<E> que la clase ArrayList implementa.
2. public void add(E e) {
o Descripción: Define un método público add que acepta un parámetro de tipo
E (el tipo de elemento que la lista almacenará).
3. if (isFull()) { Expand(); }
o Descripción: Verifica si la lista está llena utilizando el método isFull().
o Detalles: Si isFull() devuelve true, llama al método Expand() para
aumentar la capacidad del arreglo items.
4. items[size++] = e;
o Descripción: Añade el nuevo elemento e al arreglo items en la posición
indicada por size.
 o Detalles: Después de añadir el elemento, incrementa size en 1 (size++).
Esto asegura que la próxima vez que se añada un elemento, se almacene en la
siguiente posición libre del arreglo.

El método add gestiona la adición de nuevos elementos al ArrayList. Primero verifica si

hay suficiente espacio y, si no lo hay, expande la capacidad del arreglo antes de añadir el
nuevo elemento. Esto garantiza que siempre haya espacio disponible para nuevos elementos
sin perder los ya existentes.

Este método add sobrecargado añade un elemento e en una posición específica index en la
lista ArrayList. Vamos a desglosarlo paso a paso:

1. @Override
o Descripción: La anotación indica que este método sobrescribe un método
definido en la interfaz List<E>.
2. public void add(E e, int index) {
o Descripción: Declara un método add que acepta un elemento e de tipo E y un
índice index donde se añadirá el elemento.
3. if (index < size) {
 o Descripción: Verifica si el índice especificado está dentro del rango actual de
la lista (es menor que el tamaño actual).
4. if (isFull()) { Expand(); }
o Descripción: Si la lista está llena (isFull() devuelve true), llama al método
Expand() para aumentar la capacidad del arreglo.
5. for (int i = size; i > index; i--) {
o Descripción: Comienza un bucle for que se ejecuta desde el final de la lista
(size) hasta el índice especificado (index).
6. items[i + 1] = items[i];
o Descripción: Desplaza los elementos en el arreglo items una posición hacia
adelante, comenzando desde el final hasta el índice especificado.
7. items[i] = items[i-1];
o Descripción: Desplaza el elemento en la posición actual a la siguiente
posición.
8. items[index] = e;
o Descripción: Coloca el nuevo elemento e en la posición especificada por
index.
9. size++;
o Descripción: Incrementa el tamaño de la lista (size) en 1, para reflejar la
adición del nuevo elemento.

Este método añade un elemento en una posición específica de la lista, expandiendo la

capacidad de la lista si es necesario y desplazando los elementos existentes para hacer espacio
para el nuevo.
Este método remove se encarga de eliminar un elemento en una posición específica de la lista
ArrayList. Aquí tienes una explicación en párrafos:

El método remove sobrescribe un método de la interfaz List<E>, y acepta un índice index

como parámetro, que especifica la posición del elemento que se desea eliminar. Primero, el
método verifica si el índice proporcionado es menor que el tamaño de la lista (size). Esto
garantiza que el índice esté dentro de los límites de la lista y evita errores de acceso a índices
fuera de rango.

Si el índice es válido, el método almacena temporalmente el elemento en esa posición en una

variable auxiliar aux para poder devolverlo posteriormente. Luego, utiliza un bucle for para
desplazar todos los elementos que están después del índice hacia una posición anterior en el
arreglo items. Este desplazamiento sobrescribe el elemento en la posición index con el
siguiente elemento en la lista, efectivamente eliminando el elemento original en index.

Después de desplazar todos los elementos, decrementa el tamaño de la lista (size--) para
reflejar que ahora contiene un elemento menos. Finalmente, el método devuelve el elemento
eliminado almacenado en aux. Si el índice proporcionado no es válido, el método devuelve
null, indicando que no se pudo eliminar ningún elemento.
En esencia, este método gestiona la eliminación de un elemento específico de la lista, asegura
que la estructura de la lista se mantenga correctamente y devuelve el elemento eliminado
para referencia.

Estos métodos son bastante sencillos pero esenciales para cualquier implementación de una
lista dinámica. Vamos a desglosarlos:

1. Método get(int index)

o Descripción: Este método devuelve el elemento en la posición especificada
por index en la lista.
o Detalles:
▪ @Override: Indica que está sobrescribiendo el método get definido
en la interfaz List<E>.
▪ public E get(int index) {: Define el método get que acepta un
índice index y devuelve un elemento de tipo E.
▪ return (E) items[index];: Devuelve el elemento en la posición
index del arreglo items. La conversión (E) asegura que el objeto se
devuelva como el tipo correcto.
2. Método size()
o Descripción: Este método devuelve el número de elementos en la lista.
o Detalles:
▪ @Override: Indica que está sobrescribiendo el método size definido
en la interfaz List<E>.
 ▪ public int size() {:
Define el método size que no acepta
parámetros y devuelve un valor de tipo int.
▪ return size;: Devuelve el valor de la variable size, que representa
el número actual de elementos en la lista.

El método get permite acceder a elementos específicos de la lista por su índice, mientras que
el método size proporciona el número de elementos actuales en la lista. Estos métodos son
fundamentales para manejar y acceder a los datos en una implementación de lista dinámica.

Claro, vamos a desglosar estos dos métodos:

1. Método clear()
o Descripción: Este método vacía la lista y la reinicia a su capacidad inicial.
o Detalles:
▪ @Override: Indica que está sobrescribiendo el método clear definido
en la interfaz List<E>.
▪ public void clear() {: Define el método clear que no acepta
parámetros y no devuelve ningún valor.
▪ capacity = 10;: Restablece la capacidad del arreglo items a 10.
▪ items = new Object[capacity];: Crea un nuevo arreglo items con
la capacidad restablecida a 10, eliminando todos los elementos
anteriores.
2. Método isEmpty()
 o Descripción: Este método verifica si la lista está vacía.
o Detalles:
▪ @Override: Indica que está sobrescribiendo el método isEmpty
definido en la interfaz List<E>.
▪ public boolean isEmpty() {: Define el método isEmpty que no
acepta parámetros y devuelve un valor booleano.
▪ return size == 0;: Devuelve true si el tamaño de la lista es 0, lo
que significa que la lista está vacía; de lo contrario, devuelve false.

El método clear reinicia la lista, eliminando todos los elementos y restableciendo la

capacidad a su valor inicial de 10, mientras que el método isEmpty verifica si la lista no
contiene elementos. Ambos métodos son fundamentales para gestionar y manipular la
estructura de la lista dinámica.