¡Hola!

👋 Te damos la bienvenida a Collections

Imagina que estás trabajando en un proyecto que tiene que procesar, almacenar
y manipular grandes cantidades de datos. Podrías, por supuesto, intentar
manejar estos datos usando arrays y estructuras de datos básicas, pero pronto
te encontrarás con varias limitaciones. Los arrays tienen un tamaño fijo, por lo
que no puedes agregar o eliminar elementos de manera eficiente. Además,
trabajar con datos en arrays puede volverse complicado, especialmente si
necesitas realizar operaciones como ordenar los datos, buscar un elemento o
eliminar duplicados. También, tendrías que implementar estas estructuras de
datos y algoritmos desde cero, lo cual puede ser muy tedioso y propenso a
errores.

Además, si estás trabajando en un equipo, otros miembros del equipo podrían no

estar familiarizados con las estructuras de datos personalizadas que has creado.
Esto podría dar lugar a problemas de compatibilidad y comprensión del código.

Afortunadamente, existe una solución, y es el Java Collections Framework.

¡Que comience el viaje! 🚀

Java Collections Framework

El framework de colecciones de Java es una abstracción de alto nivel que
establece un marco de trabajo común y proporciona una serie de clases,
interfaces y enums predefinidos para representar y manipular colecciones.

Una colección es simplemente un objeto que agrupa múltiples elementos en una

única unidad para luego poder recuperarlos y manipularlos.

Este Framework de Colecciones proporciona implementaciones de alta calidad y

alto rendimiento de estructuras de datos y algoritmos útiles, vamos a conocerlos.
Herencia e interfaces del Framework de Colecciones

Vamos a iniciar nuestra exploración del Framework de Colecciones de Java por

su jerarquía de interfaces. Estas interfaces definen diferentes tipos de colecciones
que representan distintas estructuras de datos y forman el fundamento del
Framework de Colecciones de Java. Podemos observar la estructura de esa
jerarquía en el siguiente gráfico.

Existen dos árboles de interfaces, uno que comienza con la interfaz Collection e
incluye Set, SortedSet, List, Queue y Deque, y el otro que comienza con Map e
incluye SortedMap.

Las colecciones en Java trabajan con genéricos, lo que significa que debemos
especificar el tipo de dato que contendrá la colección al declararla. Además, es
importante que los objetos personalizados que utilicemos en las colecciones
implementen los métodos hashCode() y equals(). Al implementar estos métodos
en nuestros objetos personalizados, aseguramos que las colecciones puedan
realizar búsquedas, comparaciones y eliminaciones correctamente.

📍 No necesitas leer detenidamente toda la guía, te recomiendo que la primera

vez que la leas, prestes atención a las notas e introducciones de cada interfaz y
clase y no te centres tanto en los métodos. Al final de la misma tendrás un breve
resumen de los aspectos más importantes que necesitas saber. Luego de la
primera lectura puedes interiorizarte más en lo que hacen los métodos.
Collection

Es la interfaz raíz en la jerarquía de colecciones. El JDK no proporciona

implementaciones directas de esta interfaz: proporciona implementaciones de
subinterfaces más específicas como Set y List. Esta interfaz se utiliza cuando se
desea la máxima generalidad.

- Métodos:

Los métodos marcados con "operación opcional” implican que son opcionales y
que las clases que implementan esta interfaz pueden implementar sus métodos
lanzando una excepción UnsupportedOperationException. Las implementaciones
que vamos a ver implementan correctamente todos los métodos,

📍Esto puede suceder en implementaciones personalizadas, las creadas por

Java no lanzan esas excepciones, por lo que no deben preocuparse por este
detalle.

○ boolean add(E e): Asegura que esta colección contenga el

elemento especificado (operación opcional).

💡 El boolean devuelve true si la colección se modificó para

agregar el nuevo objeto.

○ boolean addAll(Collection<? extends E> c): Agrega todos los

elementos de la colección especificada a esta colección (operación
opcional).

○ void clear(): Elimina todos los elementos de esta colección

dejándola vacía (operación opcional).

○ boolean contains(Object o): Devuelve true si esta colección

contiene el elemento especificado.

○ boolean containsAll(Collection<?> c): Devuelve true si esta

colección contiene todos los elementos de la colección
especificada.

○ boolean equals(Object o): Compara el objeto especificado con esta

colección para determinar si son iguales.
 ○ int hashCode(): Devuelve el valor del código hash para esta
colección.

○ boolean isEmpty(): Devuelve true si esta colección no contiene

elementos.

○ Iterator<E> iterator(): Devuelve un iterador sobre los elementos de

esta colección.

💡 Al final de los métodos de Collection explicaremos que es un

Iterator y para que sirve.

○ boolean remove(Object o): Elimina una única instancia del

elemento especificado de esta colección, si está presente
(operación opcional).

○ boolean removeAll(Collection<?> c): Elimina todos los elementos de

esta colección que también están contenidos en la colección
especificada (operación opcional).

○ boolean retainAll(Collection<?> c): Retiene sólo los elementos de

esta colección que están contenidos en la colección especificada
(operación opcional).

○ int size(): Devuelve el número de elementos en esta colección.

○ Object[] toArray(): Devuelve un arreglo que contiene todos los

elementos de esta colección.

○ <T> T[] toArray(T[] a): Devuelve un arreglo que contiene todos los
elementos de esta colección; el tipo de tiempo de ejecución del
arreglo devuelto es el del arreglo especificado.

💡 Hacer toArray(new Object[x]) es idéntico a toArray().

Iterator

Un Iterator es una interfaz en Java que proporciona una forma de iterar y recorrer
los elementos de una colección de forma secuencial.

- Métodos:
 ○ boolean hasNext(): Devuelve true si la iteración tiene más
elementos para recorrer.

○ E next(): Devuelve el siguiente elemento en la iteración.

○ default void remove(): Elimina de la colección subyacente el último

elemento devuelto por este iterador (operación opcional).

Un Iterator se utiliza en contraposición a los bucles fori o foreach cuando se

necesita eliminar o agregar elementos durante la iteración.

Collection<String> coleccion = new ArrayList<>();

coleccion.add("elemento1");
coleccion.add("elemento2");
coleccion.add("elemento3");

Iterator<String> iterator = coleccion.iterator();

while (iterator.hasNext()) {
String elemento = iterator.next();
if (elemento.equals("elemento2")) {
iterator.remove(); // Elimina el elemento correctamente
}
}

La razón es porque se puede producir una excepción

ConcurrentModificationException. Esta excepción se lanza cuando la colección se
modifica estructuralmente (por ejemplo, al agregar o eliminar elementos)
mientras se está iterando sobre ella.

Collection<String> coleccion = new ArrayList<>();

coleccion.add("elemento1");
coleccion.add("elemento2");
coleccion.add("elemento3");

for (String elemento : coleccion) {

if (elemento.equals("elemento2")) {
coleccion.remove(elemento); // Esto lanzaría
ConcurrentModificationException
}
}
List

La interfaz List en Java representa una colección ordenada secuencialmente que

permite duplicados y proporciona un acceso basado en índices a sus elementos.

💡 Al igual que los arrays su índice comienza en 0.

📍Hereda todos los métodos vistos en Collection.
- Métodos propios:

○ void add(int index, E element): Inserta el elemento especificado en

la posición indicada en esta lista.

○ boolean addAll(int index, Collection<? extends E> c): Inserta todos

los elementos de la colección especificada en esta lista en la
posición especificada (operación opcional).

○ E get(int index): Devuelve el elemento en la posición especificada de

esta lista.

○ int indexOf(Object o): Devuelve el índice de la primera ocurrencia

del elemento especificado en esta lista, o -1 si esta lista no contiene
el elemento.

○ int lastIndexOf(Object o): Devuelve el índice de la última ocurrencia

del elemento especificado en esta lista, o -1 si esta lista no contiene
el elemento.

○ ListIterator<E> listIterator(): Devuelve un iterador de lista sobre los

elementos de esta lista.

💡 Al final de los métodos de List explicaremos que es un ListIterator

y para qué sirve.

○ ListIterator<E> listIterator(int index): Devuelve un iterador de lista

sobre los elementos de esta lista, comenzando en la posición
especificada en la lista.

○ E remove(int index): Elimina el elemento en la posición especificada

de esta lista (operación opcional).
 ○ E set(int index, E element): Reemplaza el elemento en la posición
especificada de esta lista con el elemento especificado (operación
opcional).

○ default void sort(Comparator<? super E> c): Ordena esta lista de

acuerdo con el orden inducido por el comparador especificado.

○ List<E> subList(int fromIndex, int toIndex): Devuelve una vista de la

porción de esta lista entre el índice fromIndex (inclusive) y el índice
toIndex (exclusivo).

Colecciones de vista

Las colecciones de vista son una forma de ver o acceder a los

elementos de una colección existente sin tener que copiarlos y
almacenarlos por separado. Estas colecciones no almacenan
elementos por sí mismas, sino que dependen de una colección de
respaldo (también conocida como "backing collection") para
almacenar los elementos reales. Por ejemplo el método subList()
genera una vista de una lista original que representa una sublista de
sus elementos. Esta vista permite acceder y realizar modificaciones
en la sublista, y los cambios se reflejarán en la lista original y
viceversa.

ListIterator

Un ListIterator en Java es una interfaz que extiende la interfaz Iterator y

proporciona funcionalidades adicionales específicas para las listas. Un ListIterator
permite iterar sobre los elementos de una lista en ambas direcciones (hacia
adelante y hacia atrás), y además de eliminar elementos permite agregar y
reemplazar.

📍 Hereda todos los métodos vistos en Iterator.

- Métodos propios:

○ void add(E e): Inserta el elemento especificado en la lista.

 ○ boolean hasPrevious(): Devuelve true si este iterador de lista tiene
más elementos al recorrer la lista en la dirección hacia atrás.

○ int nextIndex(): Devuelve el índice del elemento que sería devuelto

por una llamada posterior a next().

○ E previous(): Devuelve el elemento anterior en la lista y mueve la

posición del cursor hacia atrás.

○ int previousIndex(): Devuelve el índice del elemento que sería

devuelto por una llamada posterior a previous().

○ void set(E e): Reemplaza el último elemento devuelto por next() o

previous() con el elemento especificado (operación opcional).

ArrayList implementación de List

La clase ArrayList es una implementación de la interfaz List en Java que ofrece un

almacenamiento dinámico de elementos en un array y ofrece métodos para
aumentar manualmente la capacidad cuando sea necesario.

📍Hereda todos los métodos de Collection y List.

- Métodos propios:

○ void ensureCapacity(int minCapacity): Aumenta la capacidad de

esta instancia de ArrayList, si es necesario, para asegurarse de que
pueda contener al menos el número de elementos especificado por
el argumento de capacidad mínima.

○ void trimToSize(): Ajusta la capacidad de esta instancia de ArrayList

para que sea igual al tamaño actual de la lista.

Ejemplo de creación de un ArrayList:

List<String> lista = new ArrayList<>();

lista.add("elemento1");
Set

Un Set es una colección que no permite elementos duplicados. Esto se define por
la semántica del método add en un Set, que devuelve false si el elemento ya está
presente en el conjunto y no se agrega..

Aunque los conjuntos no permiten elementos duplicados, cada elemento en sí

puede ser único según su propio criterio de igualdad, que se define mediante los
métodos equals y hashCode del objeto. Dos objetos distintos pueden
considerarse iguales si su implementación de equals lo define así, incluso si
contienen valores diferentes en sus atributos.

📍Hereda todos los métodos de Collection, no tiene métodos propios.

HashSet Implementación de Set

HashSet utiliza una estructura de datos llamada "hash table" para almacenar y
administrar elementos únicos. Una hash table es una estructura de datos que
utiliza una función de hash para asignar claves a ubicaciones en una tabla, lo
que permite un acceso rápido y eficiente a los elementos. Pero produce que no
se pueda garantizar un orden específico de los elementos.

💡Es muy importante implementar los métodos hashCode() y equals() de los

objetos personalizados que uses para crear un HashSet, para que se cumpla
correctamente la característica de no permitir elementos duplicados.

📍Hereda todos los métodos de Collection y Set

● Métodos propios estáticos:

○ HashSet<T> newHashSet(int numeroElementos) Crea un nuevo

HashSet vacío adecuado para el número previsto de elementos.

💡El método newHashSet() es útil para crear un HashSet con una

capacidad inicial optimizada en función del número esperado de
elementos, mejorando el rendimiento en la gestión del conjunto.

Ejemplo de creación de un HashSet:

 Set<String> conjunto = new HashSet<>();
conjunto.add("elemento3");

💡String y las clases Wrappers ya tienen implementados los métodos

hashCode() e equals().

Map

La interfaz Map en Java representa una colección de pares clave-valor, donde

cada elemento está asociado a una clave única. Permite almacenar y manipular
datos en forma de entradas que consisten en una clave y su correspondiente
valor.

📍No hereda de la Interfaz Collection

● Métodos propios:

○ void clear(): Elimina todos los mapeos de este mapa (operación

opcional).

○ boolean containsKey(Object key): Devuelve true si este mapa

contiene un mapeo para la clave especificada.

○ boolean containsValue(Object value): Devuelve true si este mapa

mapea una o más claves al valor especificado.

○ Set<Map.Entry<K, V>> entrySet(): Devuelve una vista Set de los

mapeos contenidos en este mapa.

○ boolean equals(Object o): Compara el objeto especificado con este

mapa para verificar la igualdad.

○ V get(Object key): Devuelve el valor al que está mapeada la clave

especificada, o null si este mapa no contiene un mapeo para la
clave.

○ default V getOrDefault(Object key, V defaultValue): Devuelve el valor

al que está mapeada la clave especificada, o defaultValue si este
mapa no contiene un mapeo para la clave.

○ int hashCode(): Devuelve el valor del código hash para este mapa.
○ boolean isEmpty(): Devuelve true si este mapa no contiene mapeos
clave-valor.

○ Set<K> keySet(): Devuelve una vista Set de las claves contenidas en

este mapa.

○ V put(K key, V value): Asocia el valor especificado con la clave

especificada en este mapa (operación opcional).

○ void putAll(Map<? extends K, ? extends V> m): Copia todos los

mapeos desde el mapa especificado a este mapa (operación
opcional).

○ default V putIfAbsent(K key, V value): Si la clave especificada no

está asociada actualmente con un valor (o está mapeada a null), la
asocia con el valor dado y devuelve null, de lo contrario devuelve el
valor actual.

○ V remove(Object key): Elimina el mapeo para una clave de este

mapa si está presente (operación opcional).

○ default boolean remove(Object key, Object value): Elimina la

entrada para la clave especificada solo si está mapeada
actualmente al valor especificado.

○ default V replace(K key, V value): Reemplaza la entrada para la

clave especificada solo si está actualmente mapeada a algún valor.

○ default boolean replace(K key, V oldValue, V newValue): Reemplaza

la entrada para la clave especificada solo si está actualmente
mapeada al valor especificado.

○ default void replaceAll(BiFunction<? super K, ? super V, ? extends V>

function): Reemplaza el valor de cada entrada con el resultado de
invocar la función dada en esa entrada hasta que se hayan
procesado todas las entradas o la función arroje una excepción.

○ int size(): Devuelve el número de mapeos clave-valor en este mapa.

○ Collection<V> values(): Devuelve una vista Collection de los valores

contenidos en este mapa.
HashMap implementación de Map

HashMap utiliza una estructura de datos de tabla hash para almacenar los
elementos. Cada elemento se almacena en una ubicación de la tabla hash
calculada mediante la función de hash de la clave.

📍Hereda todos los métodos de Map

● Métodos propios estáticos:

○ HashMap<K, V> newHashMap(int numMappings): Crea un nuevo

HashMap vacío adecuado para el número esperado de mapeos.

Ejemplo de creación de un HashMap:

Map<String, String> mapa = new HashMap<>();

mapa.put("clave1","valor1");

Clases de utilidad

Las clases de utilidad Collections y Arrays en Java proporcionan funcionalidades

adicionales y métodos estáticos para trabajar con colecciones y matrices de
manera más conveniente y eficiente. Estas clases ofrecen una serie de métodos
para realizar diversas operaciones comunes, como ordenar, buscar, manipular y
transformar elementos en colecciones y matrices.

Collections

La clase Collections se enfoca en proporcionar métodos para trabajar con

colecciones, como List, Set y Map. Ofrece métodos para ordenar, buscar, mezclar,
invertir, copiar, llenar y otras operaciones en colecciones. También proporciona
métodos para crear colecciones inmutables, sincronizadas y envueltas en otras
estructuras de datos.

● Métodos propios estáticos:

○ boolean addAll(Collection<? super T> c, T... elements): Agrega todos

los elementos especificados a la colección especificada.
○ int binarySearch(List<? extends Comparable<? super T>> list, T key):
Busca el objeto especificado en la lista especificada utilizando el
algoritmo de búsqueda binaria.

○ int binarySearch(List<? extends T> list, T key, Comparator<? super T>

c): Busca el objeto especificado en la lista especificada utilizando el
algoritmo de búsqueda binaria.

○ void copy(List<? super T> dest, List<? extends T> src): Copia todos
los elementos de una lista en otra lista.

○ boolean disjoint(Collection<?> c1, Collection<?> c2): Devuelve true si

las dos colecciones especificadas no tienen elementos en común.

○ Enumeration<T> enumeration(Collection<T> c): Devuelve una

enumeración sobre la colección especificada.

○ void fill(List<? super T> list, T obj): Reemplaza todos los elementos de
la lista especificada con el elemento especificado.

○ int frequency(Collection<?> c, Object o): Devuelve el número de

elementos en la colección especificada que son iguales al objeto
especificado.

○ int indexOfSubList(List<?> source, List<?> target): Devuelve la

posición de inicio de la primera ocurrencia de la lista objetivo
especificada dentro de la lista de origen especificada, o -1 si no hay
tal ocurrencia.

○ int lastIndexOfSubList(List<?> source, List<?> target): Devuelve la

posición de inicio de la última ocurrencia de la lista objetivo
especificada dentro de la lista de origen especificada, o -1 si no hay
tal ocurrencia.

○ ArrayList<T> list(Enumeration<T> e): Devuelve una lista de matrices

que contiene los elementos devueltos por la enumeración
especificada en el orden en que son devueltos por la enumeración.

○ T max(Collection<? extends T> coll): Devuelve el elemento máximo

de la colección dada, según el orden natural de sus elementos.
○ T max(Collection<? extends T> coll, Comparator<? super T> comp):
Devuelve el elemento máximo de la colección dada, según el orden
especificado por el comparador.

○ T min(Collection<? extends T> coll): Devuelve el elemento mínimo

de la colección dada, según el orden natural de sus elementos.

○ T min(Collection<? extends T> coll, Comparator<? super T> comp):

Devuelve el elemento mínimo de la colección dada, según el orden
especificado por el comparador.

○ List<T> nCopies(int n, T o): Devuelve una lista inmutable que

consiste en n copias del objeto especificado.

○ Set<E> newSetFromMap(Map<E,Boolean> map): Devuelve un

conjunto respaldado por el mapa especificado.

○ boolean replaceAll(List<T> list, T oldVal, T newVal): Reemplaza todas

las ocurrencias de un valor especificado en una lista con otro valor.

○ void reverse(List<?> list): Invierte el orden de los elementos en la

lista especificada.

○ Comparator<T> reverseOrder(): Devuelve un comparador que

impone el orden inverso del orden natural en una colección de
objetos que implementan la interfaz Comparable.

○ Comparator<T> reverseOrder(Comparator<T> cmp): Devuelve un

comparador que impone el orden inverso del comparador
especificado.

○ void rotate(List<?> list, int distance): Rota los elementos en la lista

especificada según la distancia especificada.

○ void shuffle(List<?> list): Permuta aleatoriamente la lista

especificada utilizando una fuente de aleatoriedad predeterminada.

○ void shuffle(List<?> list, Random rnd): Permuta aleatoriamente la

lista especificada utilizando la fuente de aleatoriedad especificada.

○ void sort(List<T> list): Ordena la lista especificada en orden

ascendente, según el orden natural de sus elementos.
 ○ void sort(List<T> list, Comparator<? super T> c): Ordena la lista
especificada según el orden especificado por el comparador.

○ void swap(List<?> list, int i, int j): Intercambia los elementos en las
posiciones especificadas de la lista especificada.

○ métodos que devuelven colecciones inmodificables vacías

○ métodos que devuelven colecciones inmodificables con un solo

elemento

○ métodos que devuelven colecciones sincronizadas

○ métodos que devuelven colecciones inmodificables

Arrays

La clase Arrays se centra en trabajar con matrices. Proporciona métodos para

ordenar, buscar, comparar, rellenar, copiar y manipular elementos en matrices.
También ofrece métodos para convertir matrices en listas y viceversa. Ya la
hemos utilizado al principio del curso, ahora conocerás más métodos útiles.

📍 En los métodos siguientes se utiliza la palabra primitivo para referirse a que

existen sobrecargas del método para cada primitivo: boolean, byte, short, int,
long, char, float, double

● Métodos propios estáticos:

○ <T> List<T> asList(T... a): Devuelve una lista de tamaño fijo

respaldada por el arreglo especificado.

List<String> list = Arrays.asList("Pepe", "Lolo", "Elias");

💡 La lista no puede cambiar de tamaño, si usas su método add()

lanzará un error.

○ int binarySearch(primitivo[] a, primitivo key): Busca el valor

especificado en el arreglo de primitivos especificado utilizando el
algoritmo de búsqueda binaria.
○ int binarySearch(primitivo[] a, int fromIndex, int toIndex, primitivo
key): Busca un rango del arreglo de primitivos especificado para
encontrar el valor especificado utilizando el algoritmo de búsqueda
binaria.

○ int binarySearch(T[] a, int fromIndex, int toIndex, T key,

Comparator<? super T> c): Busca un rango del arreglo especificado
para encontrar el objeto especificado utilizando el algoritmo de
búsqueda binaria.

○ int binarySearch(T[] a, T key, Comparator<? super T> c): Busca el

objeto especificado en el arreglo especificado utilizando el
algoritmo de búsqueda binaria.

○ int compare(primitivo[] a, primitivo[] b): Compara dos arreglos de

primitivos lexicográficamente.

○ int compare(primitivo[] a, int aFromIndex, int aToIndex, primitivo[]

b, int bFromIndex, int bToIndex): Compara dos arreglos de primitivos
lexicográficamente en los rangos especificados.

○ int compare(T[] a, int aFromIndex, int aToIndex, T[] b, int

bFromIndex, int bToIndex): Compara dos arreglos de objetos
lexicográficamente en los rangos especificados.

○ int compare(T[] a, int aFromIndex, int aToIndex, T[] b, int

bFromIndex, int bToIndex, Comparator<? super T> cmp): Compara
dos arreglos de objetos lexicográficamente en los rangos
especificados.

○ int compare(T[] a, T[] b): Compara dos arreglos de objetos

lexicográficamente, dentro de elementos comparables.

○ int compare(T[] a, T[] b, Comparator<? super T> cmp): Compara

dos arreglos de objetos lexicográficamente utilizando un
comparador especificado.

○ int compareUnsigned(int[] a, int[] b): Compara dos arreglos de

enteros lexicográficamente, tratando numéricamente a los
elementos como sin signo.
○ int compareUnsigned(int[] a, int aFromIndex, int aToIndex, int[] b,
int bFromIndex, int bToIndex): Compara dos arreglos de enteros
lexicográficamente en los rangos especificados, tratando
numéricamente a los elementos como sin signo.

○ primitivo[] copyOf(primitivo[] original, int newLength): Copia el

arreglo especificado, truncando o rellenando con ceros (si es
necesario) para que la copia tenga la longitud especificada.

○ T[] copyOf(T[] original, int newLength): Copia el arreglo

especificado, truncando o rellenando con nulos (si es necesario)
para que la copia tenga la longitud especificada.

○ T[] copyOf(U[] original, int newLength, Class<? extends T[]>

newType): Copia el arreglo especificado, truncando o rellenando
con nulos (si es necesario) para que la copia tenga la longitud
especificada.

○ primitivo[] copyOfRange(primitivo[] original, int from, int to): Copia

el rango especificado del arreglo especificado en un nuevo arreglo.

○ T[] copyOfRange(T[] original, int from, int to): Copia el rango

especificado del arreglo especificado en un nuevo arreglo.

○ T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]>
newType): Copia el rango especificado del arreglo especificado en
un nuevo arreglo.

○ boolean deepEquals(Object[] a1, Object[] a2): Devuelve true si los

dos arreglos especificados son profundamente iguales entre sí.

○ int deepHashCode(Object[] a): Devuelve un código hash basado en

el "contenido profundo" del arreglo especificado.

○ String deepToString(Object[] a): Devuelve una representación en

forma de cadena del "contenido profundo" del arreglo especificado.

○ boolean equals(primitivo[] a, primitivo[] a2): Devuelve true si los

dos arreglos de primitivos especificados son iguales entre sí.
○ boolean equals(primitivo[] a, int aFromIndex, int aToIndex,
primitivo[] b, int bFromIndex, int bToIndex): Devuelve true si los dos
arreglos de primitivos especificados, en los rangos especificados,
son iguales entre sí.

○ boolean equals(Object[] a, int aFromIndex, int aToIndex, Object[] b,

int bFromIndex, int bToIndex): Devuelve true si los dos arreglos de
objetos especificados, en los rangos especificados, son iguales entre
sí.

○ boolean equals(Object[] a, Object[] a2): Devuelve true si los dos

arreglos de objetos especificados son iguales entre sí.

○ boolean equals(T[] a, int aFromIndex, int aToIndex, T[] b, int

bFromIndex, int bToIndex, Comparator<? super T> cmp): Devuelve
true si los dos arreglos de objetos especificados, en los rangos
especificados, son iguales entre sí.

○ boolean equals(T[] a, T[] a2, Comparator<? super T> cmp):

Devuelve true si los dos arreglos de objetos especificados son
iguales entre sí.

○ void fill(primitivo[] a, primitivo val): Asigna el valor de primitivo

especificado a cada elemento del arreglo de primitivos
especificado.

○ void fill(primitivo[] a, int fromIndex, int toIndex, primitivo val): Asigna

el valor de primitivo especificado a cada elemento del rango
especificado del arreglo de primitivos especificado.

○ void fill(Object[] a, int fromIndex, int toIndex, Object val): Asigna la

referencia de objeto especificada a cada elemento del rango
especificado del arreglo de objetos especificado.

○ void fill(Object[] a, Object val): Asigna la referencia de objeto

especificada a cada elemento del arreglo de objetos especificado.

○ int hashCode(primitivo[] a): Devuelve un código hash basado en el

contenido del arreglo especificado.
○ int hashCode(Object[] a): Devuelve un código hash basado en el
contenido del arreglo especificado.

○ int mismatch(primitivo[] a, primitivo[] b): Encuentra y devuelve el

índice de la primera diferencia entre dos arreglos de primitivos, de lo
contrario devuelve -1 si no se encuentra ninguna diferencia.

○ int mismatch(primitivo[] a, int aFromIndex, int aToIndex, primitivo[]

b, int bFromIndex, int bToIndex): Encuentra y devuelve el índice
relativo de la primera diferencia entre dos arreglos de primitivos en
los rangos especificados, de lo contrario devuelve -1 si no se
encuentra ninguna diferencia.

○ int mismatch(Object[] a, int aFromIndex, int aToIndex, Object[] b,

int bFromIndex, int bToIndex): Encuentra y devuelve el índice relativo
de la primera diferencia entre dos arreglos de objetos en los rangos
especificados, de lo contrario devuelve -1 si no se encuentra
ninguna diferencia.

○ int mismatch(Object[] a, Object[] b): Encuentra y devuelve el índice

de la primera diferencia entre dos arreglos de objetos, de lo
contrario devuelve -1 si no se encuentra ninguna diferencia.

○ int mismatch(T[] a, int aFromIndex, int aToIndex, T[] b, int

bFromIndex, int bToIndex, Comparator<? super T> cmp): Encuentra y
devuelve el índice relativo de la primera diferencia entre dos
arreglos de objetos en los rangos especificados, de lo contrario
devuelve -1 si no se encuentra ninguna diferencia.

○ int mismatch(T[] a, T[] b, Comparator<? super T> cmp): Encuentra

y devuelve el índice de la primera diferencia entre dos arreglos de
objetos, de lo contrario devuelve -1 si no se encuentra ninguna
diferencia.

○ void setAll(double[] array, IntToDoubleFunction generator):

Establece todos los elementos del arreglo especificado utilizando la
función generadora proporcionada para calcular cada elemento.
(Explicar qué es un generador y dar un ejemplo)
○ void setAll(int[] array, IntUnaryOperator generator): Establece todos
los elementos del arreglo especificado utilizando la función
generadora proporcionada para calcular cada elemento.

○ void setAll(long[] array, IntToLongFunction generator): Establece

todos los elementos del arreglo especificado utilizando la función
generadora proporcionada para calcular cada elemento.

○ void setAll(T[] array, IntFunction<? extends T> generator): Establece

todos los elementos del arreglo especificado utilizando la función
generadora proporcionada para calcular cada elemento.

○ void sort(primitivo[] a): Ordena el arreglo especificado en orden

numérico ascendente.

○ void sort(primitivo[] a, int fromIndex, int toIndex): Ordena el rango

especificado del arreglo en orden ascendente.

○ void sort(Object[] a): Ordena el arreglo de objetos especificado en

orden ascendente, según el orden natural de sus elementos.

○ void sort(Object[] a, int fromIndex, int toIndex): Ordena el rango

especificado del arreglo de objetos especificado en orden
ascendente, según el orden natural de sus elementos.

○ void sort(T[] a, int fromIndex, int toIndex, Comparator<? super T> c):
Ordena el rango especificado del arreglo de objetos especificado
según el orden especificado por el comparador.

○ void sort(T[] a, Comparator<? super T> c): Ordena el arreglo de

objetos especificado según el orden especificado por el
comparador.

○ String toString(primitivo[] a): Devuelve una representación en

forma de cadena del contenido del arreglo especificado.

○ String toString(Object[] a): Devuelve una representación en forma

de cadena del contenido del arreglo especificado.

Los siguientes métodos tienen las mismas sobrecargas que los

anteriores pero tienen usos más avanzados que no abordaremos.
 ○ parallelPrefix()

○ parallelSetAll()

○ parallelSort()

○ splitIterator()

○ stream()

Resumen de los aspectos más importantes

Este apartado será breve porque el objetivo es dejar claras las ideas principales,
la mayor parte de esta guía son referencias a los métodos que puedes usar con
cada clase, pero la idea principal es que sepas cuando usar cada estructura.

El ArrayList es la estructura por default que siempre usarás cuando quieras usar
una colección de elementos.

El HashSet siempre que necesites evitar datos duplicados en tu colección.

El HashMap cuando necesites representar estructuras que tienen una clave y un

valor.

Existen más implementaciones específicas para distintos casos pero no son las
más utilizadas y no serán abordadas en este módulo.