Course Colecciones de Java - Lecture: Interfaces de colección

"¡Hola, amigo!"

"¡Hola, Ellie!"

"Hoy vamos a envolver nuestras cabezas alrededor de la estructura de las colecciones de una vez por todas".

"He esperado mucho tiempo por esto".

"Ya sabes qué son las colecciones y sabes cómo trabajar con ellas. Es hora de organizar tu conocimiento en un sistema estricto. Luego, muchas preguntas de 'por qué' y 'cómo' desaparecerán, y la mayoría de las cosas se volverán obvias".

" Interfaces de colección . La estructura de herencia de las interfaces de colección se parece a esto:"

Fíjate en dos cosas.

Primero, todo lo que ves aquí es una interfaz.

En segundo lugar, las flechas significan «hereda».

"En otras palabras, List, Set y Queue heredan Collection, pero Map no".

"Sí. Las clases abstractas heredan estas interfaces y, a su vez, las implementaciones que conoces heredan esas clases abstractas: ArrayList, Hashtable, TreeSet,... "

"Estás en lo correcto."

"Ahora veamos para qué sirven los métodos de estas interfaces:"

Métodos de la interfaz Iterable<E> ::

Métodos	Descripción
`Iterator<T> iterator();`	Devuelve un objeto iterador.

"Eso no parece suficiente".

"Bueno, esa es la cantidad que hay. Eso es todo para los iteradores. No los cubriremos ahora, pero los cubriremos en detalle pronto".

Métodos de la interfaz Collection<E> ::

Métodos	Descripción
`boolean add(E e);`	Añade un elemento a la colección.
`boolean addAll(Collection<? extends E> c);`	Añade elementos a la colección.
`void clear();`	Elimina todos los elementos de la colección.
`boolean contains(Object o);`	Comprueba si la colección contiene el elemento.
`boolean containsAll(Collection<?> c);`	Comprueba si la colección contiene los elementos.
`boolean equals(Object o);`	Comprueba si las colecciones son equivalentes
`int hashCode();`	Devuelve el código hash
`boolean isEmpty();`	Comprueba si la colección está vacía.
`Iterator<E> iterator();`	Devuelve un objeto iterador.
`boolean remove(Object o);`	Elimina un elemento de la colección.
`boolean removeAll(Collection<?> c);`	Elimina elementos de la colección.
`boolean retainAll(Collection<?> c);`	Elimina todos los elementos que no están en c
`int size();`	Devuelve el tamaño de la colección.
`Object[] toArray();`	Convierte la colección en una matriz.
`<T> T[] toArray(T[] a);`	Convierte la colección en una matriz.

"Ya soy sólido en todo aquí. He usado la mitad de estos métodos y he encontrado la otra mitad".

"Genial, entonces continuemos".

Métodos de la interfaz List<E> ::

Métodos	Descripción
`void add(int index, E element);`	Añade elementos a la mitad de la colección.
`boolean addAll(int index, Collection<? extends E> c);`	Añade elementos a la colección.
`E get(int index);`	Devuelve un elemento por índice
`int indexOf(Object o);`	Devuelve el índice (número) de un elemento
`int lastIndexOf(Object o);`	Devuelve el índice del último elemento.
`ListIterator<E> listIterator();`	Devuelve un iterador para la lista.
`ListIterator<E> listIterator(int index);`	Devuelve un iterador para la lista.
`E remove(int index);`	Elimina un elemento por su índice
`E set(int index, E element);`	Establece un nuevo valor por índice
`List<E> subList(int fromIndex, int toIndex);`	Devuelve una subcolección

"Nada radicalmente nuevo aquí tampoco. Ya sé casi todo sobre colecciones, por lo que no puedo evitar sentirme feliz".

"Bueno, creo que puedo encontrar algo que te sorprenderá. Pero sigamos examinando las interfaces:"

Métodos de la interfaz Set<E> ::

Métodos	Descripción
Sin métodos

"La interfaz Set no tiene ningún método nuevo, solo los que hereda".

"Sí, vi que la interfaz Interable tampoco tenía nada.

"¡Por otro lado, menos métodos significa menos para recordar!"

"Tu optimismo que afirma la vida me hace feliz".

"La interfaz Set es heredada por dos interfaces con métodos: SortedSet y NavigableSet. Pero no las repasaré o nunca terminaremos".

"En su lugar, déjame darte una imagen general de las clases e interfaces que describen las colecciones en Java".

"Dale."

"Entonces agárrate fuerte:"

"¡Vaya, eso es enorme!"

"Bueno, no es tan grande. Además, recuerda que las clases abstractas son completamente opcionales. Pero es bueno recordar qué clase implementa qué interfaces. Eso puede ser útil con bastante frecuencia".

"Oh, también me gustaría señalar que algunas colecciones se consideran obsoletas".

"¿Cuáles son esos?"

"Estoy hablando de las clases Vector, Stack, Dictionary y Hashtable. Estas son versiones sincronizadas (seguras para subprocesos) de colecciones ordinarias".

"Pero Java ha agregado una biblioteca de concurrencia especial con muchas colecciones a las que no solo se puede acceder desde otros subprocesos, sino que también tienen una implementación mucho más eficiente. ConcurrentHashMap es mucho más eficiente que Hashtable ".

"Puede usar las colecciones Vector, Stack, Dictionary y Hashtable, pero no se recomienda".

"Entendido, lo tendré en cuenta".

"¡Gracias, Ellie!"