JAVA AVANZADO

Clase 7
Estructuras de Datos
Les damos la bienvenida
Vamos a comenzar a grabar la clase
 Clase 07 Clase 08

CLASE 7 - Estructuras de Datos 2 CLASE 8 - Estructuras & Excepciones

● ArrayList vs LinkedList ● Mapas
● Asociación y Composición ● Enums
● Matrices ● Excepciones
 ¿Qué son colecciones en Java?
Las colecciones en Java son grupos de elementos que tienen el mismo tipo. Por ejemplo, podemos
tener un grupo de elementos de tipo integer (número entero). También, podemos tener un grupo de
elementos de tipos String (letras o palabras). Otro grupo sería una colección de objetos “Auto”. En fin,
podemos tener colecciones de cualquier tipo.
En java, para representar estas colecciones podemos hacer uso de las clases que implementan la
interfaz “Collection” o también podemos usar el tipo “array”.

Vamos a enfocarnos en “ArrayList” y “LinkedList”.

ArrayList es una colección donde cada objeto puede ser ubicado por su índice. Como ya sabemos, en
Java, el índice en una colección empieza de cero. ArrayList son muy comunes porque, al contrario del tipo
array, no tienen un tamaño definido. Su tamaño es flexible.
import java.util.ArrayList;
import java.util.List;
Ejemplo ArrayList
public class ArrayListEjemploMain {

public static void main(String[] args) {

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

nombres.add("Lucho");
nombres.add("Pepito");
nombres.add("Jaimito");
System.out.println("veamos todos los nombres que agregamos:");
mostrarNombres(nombres);
String nombreBorrado = nombres.remove(0); // '0' es el indice del nombre que queremos borrar
System.out.println("*Nombre borrado: " + nombreBorrado);
System.out.println("\nVeamos los nombres que quedan despues de remover el primero:");
mostrarNombres(nombres);
nombres.clear();
System.out.println("Veamos que nombres quedan despues de usar el metodo clear():");
mostrarNombres(nombres);
}
public static void mostrarNombres(List<String> nombresParaMostrar){
for (String nombre : nombresParaMostrar) {
System.out.println(".- " + nombre);
}}}
En el ejemplo de arriba, creamos la variable nombres de tipo “List<String>”. List es una interfaz. Es muy recomendable
siempre usar Interfaces como tipos, porque así podemos cambiar las clases que las implementan sin hacer ninguna
modificación. Por ejemplo, en este caso estamos usando la implementación ArrayList. Pero también podemos cambiarla
a LinkedList y nuestro código no necesitaría ninguna modificación.

Después de crear la variable nombres de tipo List<String> e iniciarla con ArrayList<String>, le agregamos los elementos
“Lucho”, “Pepito” y “Jaimito”. Lucho tiene el índice cero porque es el primero. Pepito tiene el índice uno porque es
segundo. Jaimito tiene el índice dos porque es tercero. Recuerden que en Java el índice siempre empieza por cero.
Como se habrán dado cuenta para agregar elementos usamos el método “add”. Recuerden siempre añadir elementos
con el mismo tipo que definieron su lista (colección).

Luego, simplemente llamamos al método “mostrarNombres” que recibe una lista para mostrar en la consola. El método
no tiene nada en especial. Solo tiene un enhanced for loop que muestra cada nombre.

Después, usamos el método “remove” que acepta un número de índice que representa el elemento a remover. Este
método no solo remueve el elemento sino que también lo retorna. De esa manera puedes guardar el elemento removido
en una variable y usarla a tu antojo. Seguidamente, volvemos a mostrar el contenido de la lista nombres.

Por último, usamos el método “clear” que borra todos los elementos de la lista. Este método no retorna nada. Así que
cuidado con usarlo y pensar que va retornar los elementos borrados. Esos fueron algunos métodos de ArrayList.
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class ArrayListEjemploMain { Ejemplo

List<String> nombres = new LinkedList<String>(); // pueden cambiar ArrayList por LinkedList
nombres.add("Lucho"); LinkedList
nombres.add("Pepito");
nombres.add("Jaimito");
System.out.println("veamos todos los nombres que agregamos:");
mostrarNombres(nombres);
String nombreBorrado = nombres.remove(0); // '0' es el indice del nombre que queremos borrar
System.out.println("*Nombre borrado: " + nombreBorrado);
System.out.println("\nVeamos los nombres que quedan despues de remover el primero:");
mostrarNombres(nombres);
nombres.clear();
System.out.println("Veamos que nombres quedan despues de usar el metodo clear():");
mostrarNombres(nombres);
}
public static void mostrarNombres(List<String> nombresParaMostrar){
for (String nombre : nombresParaMostrar) {
System.out.println(".- " + nombre);
}
}}
ArrayList y LinkedList son diferentes implementaciones de List. Tienen cosas en común así como cosas similares. Las
cosas que los distinguen son las siguientes.

ArrayList LinkedList

Es basada en índices Es basada en nudos

Buscar un elemento es más rápido en ArrayList Buscar un elemento es más lento en LinkedList

Insertar un elemento es más lento en ArrayList Insertar un elemento es más rápido en LinkedList

Usa menos memoria Usa más memoria

Como ya sabemos ArrayList está basado en índices. Pero cómo es eso de que LinkedList está basado en nudos.
LinkedList está basado en nudos o nodos que no necesitan índices pero que si necesitan saber quién es su vecino.
¿Cómo es eso de vecino? Al decir vecino, nos referimos que un LinkedList nudo necesita saber que nudo está adelante y
que nudo está detrás de él. Así es como los elementos de LinkedList saben quién es primero y quién es último. Al usar
esta manera de ubicación, es más fácil insertar elementos. Es más fácil porque al insertar elementos no necesitas cambiar
el índice a nadie. Solo necesitas agregar el elemento al último o al comienzo o en un lugar específico. En cambio en
ArrayList si insertas un elemento, tienes que modificar el índice a todos los demás elementos.
 Pros y contras y cuándo utilizar unos antes que otros
En resumen, cada estructura de datos en Java tiene sus pros y contras. Las listas son muy flexibles y permiten el acceso rápido a
elementos individuales, pero las listas vinculadas pueden ser menos eficientes que los arreglos en el acceso a elementos individuales.
Los mapas permiten la recuperación rápida de valores asociados con una clave, pero no mantienen el orden de los elementos en el que
se agregaron. Los conjuntos son muy eficientes en la eliminación y búsqueda de elementos, pero no mantienen el orden de los
elementos en el que se agregaron y no son eficientes en el acceso a elementos individuales.

En cuanto a cuándo utilizar unos antes que otros, todo depende del caso de uso específico y de los requisitos de la aplicación. A
continuación se presentan algunas recomendaciones generales:

● Utilice una lista cuando necesite almacenar una colección de elementos ordenados y necesite acceso rápido a elementos
individuales.
● Utilice un mapa cuando necesite recuperar valores asociados con una clave y no le importe el orden en el que se agregaron los
elementos.
● Utilice un conjunto cuando necesite almacenar una colección de elementos únicos y necesite una eliminación o búsqueda
eficiente de elementos.
ASOCIACIÓN, COMPOSICIÓN Y AGREGACIÓN EN JAVA
 ASOCIACIÓN

La asociación es la relación entre dos clases separadas que se establece a través de sus Objetos. La
asociación puede ser de uno a uno, de uno a varios, de varios a uno, de varios a varios.

En la programación orientada a objetos, un objeto se comunica con otro objeto para utilizar la
funcionalidad y los servicios proporcionados por ese objeto. La composición y la agregación son las dos
formas de asociación.

En el ejemplo, dos clases separadas

Banco y Empleado están asociadas a
través de sus Objetos. El banco puede
tener muchos empleados, por lo que es
una relación de uno a muchos.
 AGREGACIÓN
Es una forma especial de Asociación donde:

● Representa la relación Has-A .

● Es una asociación unidireccional, es decir, una relación unidireccional. Por ejemplo, el
departamento puede tener estudiantes, pero viceversa no es posible y, por lo tanto, es de naturaleza
unidireccional.
● En Agregación, ambas entradas pueden sobrevivir individualmente, lo que significa que finalizar
una entidad no afectará a la otra entidad.
 COMPOSICIÓN
La composición es una forma restringida de agregación en la que dos entidades son altamente dependientes
entre sí.

● Representa parte de la relación.

● En composición, ambas entidades dependen unas de otras.
● Cuando hay una composición entre dos entidades, el objeto compuesto no puede existir sin la otra
entidad.
 MATRICES EN JAVA
Un array en Java puede tener más de una dimensión. El caso más general son los arrays
bidimensionales también llamados matrices o tablas.
La dimensión de un array la determina el número de índices necesarios para acceder a
sus elementos.
Los vectores que hemos visto son arrays unidimensionales porque solo utilizan un índice
para acceder a cada elemento.
Una matriz necesita dos índices para acceder a sus elementos. Gráficamente podemos
representar una matriz como una tabla de n filas y m columnas cuyos elementos son
todos del mismo tipo.
La siguiente figura representa un array M de 3 filas y 5 columnas:
A los elementos del array se accede mediante la fila y columna donde están situados.
A efectos prácticos, cuando trabajamos con arrays bidimensionales podemos pensar en una tabla
como la que se muestra en la imagen anterior donde los elementos están distribuidos en filas y
columnas.
Pero en realidad una matriz en Java es un array de arrays.
La disposición real en memoria del array anterior la podemos representar gráficamente de esta
forma:
M es el nombre del array.
M contiene la dirección de memoria (referencia) de un array unidimensional de 3 elementos.
Cada elemento de este array unidimensional contiene la dirección de memoria de otro array
unidimensional.
Cada uno de estos últimos arrays unidimensionales contiene los valores de cada fila de la matriz.
M.length indica el número de filas de la matriz. En este ejemplo el número de filas (M.length) es 3.
M[i].length indica el número de columnas de la fila i. En este ejemplo la longitud de cada fila del array
(M[i].length) es 5.
Para acceder a cada elemento de la matriz se utilizan dos índices. El primero indica la fila y el segundo
la columna.
M[0][2] = 9; //asigna el valor 9 al elemento situado en la primera fila (fila 0) y tercera columna (fila 2).
 CREAR UNA MATRIZ EN JAVA
Se crean de forma similar a los arrays unidimensionales, añadiendo un índice.
Por ejemplo:

matriz de datos de tipo int llamado ventas de 4 filas y 6 columnas:

int [][] ventas = new int[4][6];
matriz de datos double llamado temperaturas de 3 filas y 4 columnas:
double [][] temperaturas = new double[3][4];

En Java se pueden crear arrays irregulares en los que el número de elementos de cada fila es variable.
Solo es obligatorio indicar el número de filas.

Por ejemplo:
int [][] m = new int[3][];
crea una matriz m de 3 filas.

A cada fila se le puede asignar un número distinto de columnas:

m[0] = new int[3];
m[1] = new int[5];
m[2] = new int[2];
Recordá:
● Revisar la Cartelera de Novedades.
● Hacer tus consultas en el Foro.

Todo en el Aula Virtual.

Muchas gracias por tu atención.
Nos vemos pronto