3.7_ Estructuras Dinámicas de Datos en Java.pdf

Taller de Estructura de dAtos

1. INACAP
Universidad Tecnológica de Chile
Sede Santiago Centro
Tema 08:
Estructuras Dinámicas de Datos
en Java
Ing. Manuel López Ramos
Taller de Programación I
Curso Java J2SE

2. Parte I
¿Qué son las estructuras
de datos?

3. Estructuras de datos dinámicas
● Si en un programa de computador se hace necesario trabajar con una gran cantidad de
datos, o bien, no se conoce inicialmente la cantidad máxima de datos a almacenar/procesar
en la aplicación, entonces se necesitará contar con una estructura de datos que pueda crecer
indefinidamente en el tiempo.
● Por esta razón, en Computación se reconocen 2 tipos de estructuras de datos:
●estructuras de datos estáticas
●estructuras de datos dinámicas

4. Estructuras de datos dinámicas
● Por esta razón, en Computación se reconocen 2 tipos de estructuras de datos:
* Variables
* Arreglos
* Matrices
Su tamaño NO puede cambiar
luego de haberse definido
en el programa

5. Estructuras de datos dinámicas
● Por esta razón, en Computación se reconocen 2 tipos de estructuras de datos:
* Variables
* Arreglos
* Matrices
Su tamaño SÍ puede cambiar
luego de haberse definido
en el programa
* Listas
* Pilas
* Colas
* Árboles
* Diccionarios
* Grafos

6. Estructuras de datos dinámicas
● En Java, existen diversas clases para implementar estas estructuras dinámicas. Estas son
las más generales:
Listas: List, ArrayList, LinkedList
Pilas: Stack
Colas: Queue
Árboles: TreeMap
Diccionarios: HashMap
Grafos: HashMap
● De estas estructuras de datos, la más simple (y útil para el curso) es la de lista, que será
implementada en los programas mediante la clase de Java ArrayList.

7. Parte II
Estructuras de datos dinámicas
básicas en Java

8. Estructuras de datos dinámicas
● La clase de Java ArrayList representa las estructuras de datos denominadas como listas
simples enlazadas.
● Estas estructuras pueden crecer indefinidamente debido a que implementan una estructura base
de almacenamiento de datos, llamada NODO DE DATOS.
● El NODO DE DATOS puede almacenar un dato de cualquier tipo y posee una referencia (o enlace
o apuntador) que le permite conectarse hacia otro nodo más adelante. Se simboliza como se
muestra a continuación:
Lista simple
Nodos de datos
Referencias

9. Estructuras de datos dinámicas
● Se muestra a continuación la forma de creación y uso de un ArrayList en Java:
ArrayList lista = new ArrayList();
(crea una lista vacía, con el nombre dado)
lista.add(-1);
lista.add(45.0);
lista.add("Sí");
lista.add('@');
1) Debe crearse una lista vacía, con un nombre de variable.
2) Los datos se van insertando mediante el método add.

10. Estructuras de datos dinámicas
● Todos los elementos de la lista están ubicados en una posición (como en los arreglos),
donde el primer elemento estará en la posición 0.
● Para recuperar un elemento de la lista, se utiliza el método get(posición).
lista.get(0);
(devuelve el dato -1)
lista.get(1);
(devuelve el dato 45.0)
lista.get(3);
(devuelve el dato '@')
● Si se desea conocer el largo de la lista (es decir, la cantidad de elementos que posee), se
debe utilizar el método size() sobre la lista.
lista.size()

11. Estructuras de datos dinámicas
● En algunos casos, el método get no devuelve el dato con el tipo de datos que el programa
esperaría. En esos casos, se hace obligatorio utilizar casting de datos (conversión de tipo)
para obtener el dato correcto.
(int)lista.get(0);
(devuelve el dato -1 como int)
(double)lista.get(1);
(devuelve el dato 45.0 como double)
(String)lista.get(2);
(devuelve el dato 45.0 como String)
(char)lista.get(3);
(devuelve el dato '@' como char)

12. Estructuras de datos dinámicas
● Finalmente, el método remove(posición) elimina un nodo de la lista, según la posición
dada.
lista.remove(3);
(se elimina el dato '@')
lista.remove(1);
(se elimina el dato 45.0')
lista.remove(0);
(se elimina el dato -1)
lista.remove(0);
(se elimina el dato "Sí")
(la lista queda vacía)
● Nótese que al eliminar elementos intermedios, los elementos de la derecha se mueven hacia
atrás para rellenar el espacio vacío. Así también, los elementos de la derecha cambiarán sus
posiciones al moverse hacia atrás.

13. Parte III
Implementación de cardinalidades
para relaciones de asociación
entre clases

14. Estructuras de datos dinámicas
● Cuando la cardinalidad de una relación es baja (del orden de 1, 2 ó 3), en general bastará
con crear objetos, dentro de variables simples, en la cantidad indicada. Pero si la
cardinalidad es grande, conviene agrupar los objetos en estructuras de datos que se puedan
acceder y recorrer con facilidad; esto es, en arreglos o listas.
● Vea los siguientes ejemplos:
a) Una mesa tiene 4 pataspublic class Mesa
{
private Pata pata1, pata2, pata3, pata4;
public Mesa()
{
this.pata1 = new Pata();
this.pata2 = new Pata();
this.pata3 = new Pata();
this.pata4 = new Pata();
}
}
public class Pata
{
}

15. Estructuras de datos dinámicas
b) Un bus tiene entre 0 y 40 pasajeros
public class Bus
{
private Pasajero[] arrPasajeros;
public Bus()
{
// Sólo basta con crear el arreglo
// vacío, ya que la cardinalidad 0
// está aceptada en la relación.
this.arrPasajeros = new Pasajero[40];
}
}
public class Pasajero
{
}

16. Estructuras de datos dinámicas
c) Un partido de fútbol se juega con 22 jugadores
public class PartidoFutbol
{
private Jugador[] arrJugadores;
public PartidoFutbol()
{
// Aparte de crear el arreglo, debe
// crear cada uno de los 22 jugadores
// que indica la cardinalidad.
this.arrJugadores = new Jugador[22];
for(int pos=0; pos<22; pos++)
{
this.arrJugadores[pos] = new Jugador();
}
}
}
public class Jugador
{
}

17. Estructuras de datos dinámicas
d) Un paciente puede registrar 0 ó más enfermedades
import java.util.ArrayList;
public class Paciente
{
private ArrayList<Enfermedad> listaEnf;
public Paciente()
{
// Al crear la lista, esta tendrá 0 objetos
this.listaEnf = new ArrayList<Enfermedad>();
}
}
public class Enfermedad
{
}

18. Estructuras de datos dinámicas
● Según lo visto en las diapositivas anteriores, es muy importante cumplir con las relaciones y
con la cardinalidad, debido a que el diseño de clases determina la cantidad de objetos
participantes de las relaciones y a que, si no se crea la cantidad indicada, el programa no
contará con los objetos que necesita por especificación del problema.
● Ahora bien, conviene también entender cómo lograr acceder a los objetos que se almacenan
en cada estructura de datos. Para esto, véase el siguiente diagrama de UML, donde se
relacionan tres clases entre sí con cardinalidades grandes:
e) Una clínica puede tener 0 ó más
pacientes, mientras que cada paciente
puede tener entre 0 y 20
enfermedades registradas.

19. Estructuras de datos dinámicas
● De acuerdo a lo indicado en las diapositivas anteriores:
* La relación Clinica-Paciente se implementará con un ArrayList (por la cardinalidad
sin valor máximo).
* La relación Paciente-Enfermedad se implementará mediante un arreglo de objetos
(por su cardinalidad con valor máximo 20).

20. Estructuras de datos dinámicas
● El código que implementará éstas relaciones es el mostrado a continuación (parte 1):
public class Paciente
{
private String nombre;
private byte edad;
private Enfermedad[] arrEnf;
public Paciente()
{
// Al crear el arreglo, tendrá 0 objetos.
this.arrEnf = new Enfermedad[20];
}
}
public class Enfermedad
{
private String sintomas;
public String getSintomas() {
return this.sintomas;
}
public void setSintomas(String v) {
this.sintomas = v;
}
}

21. Estructuras de datos dinámicas
● El código que implementará éstas relaciones es el mostrado a continuación (parte 2):
public class Clinica
{
private String nombre;
private ArrayList<Paciente> listaPac;
public Clinica()
{
// Esta lista se crea sin elementos
// inicialmente.
this.listaPac = new ArrayList<Paciente>();
}
}
public class Paciente
{
private String nombre;
private byte edad;
private Enfermedad[] arrEnf;
public Paciente()
{
// Al crear el arreglo, tendrá 0 objetos.
this.arrEnf = new Enfermedad[20];
}
}

22. Estructuras de datos dinámicas
● Nótese también que, al crear nuevos atributos, también se debe crear nuevos métodos
selectores y mutadores para estos atributos. Por esta razón, en la clase Clinica corresponde
crear los siguientes métodos:
import java.util.ArrayList;
public class Clinica
{
private String nombre;
private ArrayList<Paciente> listaPac;
public Clinica()
{
// Esta lista se crea sin elementos
// inicialmente.
this.listaPac = new ArrayList<Paciente>();
}
public ArrayList<Paciente> getListaPac()
{
return this.listaPac;
}
public void setListaPac(ArrayList<Paciente> v)
{
this.listaPac = v;
}
}

23. Estructuras de datos dinámicas
public class Paciente
{
private String nombre;
private byte edad;
private Enfermedad[] arrEnf;
public Paciente()
{
// Al crear el arreglo, tendrá 0 objetos.
this.arrEnf = new Enfermedad[20];
}
public Enfermedad[] getArrEnf()
{
return this.arrEnf;
}
public void setArrEnf(Enfermedad[] v)
{
this.arrEnf = v;
}
}
● ... y en la clase Paciente corresponde crear estos otros métodos (selector y mutador):
Con estos selectores y mutadores especiales (que trabajan con la lista de pacientes y el arreglo de enfermedades,
respectivamente), el programa en Java puede acceder a los pacientes y enfermedades de cada objeto. Recuerde que
es necesario crearlos, ya que al estar declarados con acceso private, no pueden accederse directamente en el
programa, sólo a través de estos métodos antes indicados.

24. Estructuras de datos dinámicas
● Luego, si se desea realizar alguno de los siguientes accesos, haga la llamada
correspondiente desde el programa:
a) acceder a un objeto de la clase Clinica:
Clinica cli = new Clinica();
// Utilice el objeto 'cli'
b) acceder al listado de pacientes de la clínica 'cli':
cli.getListaPac()
c) acceder a un paciente de la clínica 'cli' (al paciente de la
posición 4, si es que existe):
cli.getListaPac().get(4)
d) acceder a la lista de enfermedades del paciente 4 de la
clínica 'cli' (siempre que el paciente de la posición 4 exista):
cli.getListaPac().get(4).getArrEnf()
e) acceder a la enfermedad 2 del paciente anterior:
cli.getListaPac().get(4).getArrEnf()[2]
f) obtener el nombre de la enfermedad anterior:
cli.getListaPac().get(4).getArrEnf()[2].getNombre()

25. Estructuras de datos dinámicas
● ¡Más códigos de acceso, utilizando ahora métodos mutadores!
g) cambiar el nombre de la clínica 'cli':
cli.setNombre("nuevonombre");
h) cambiar el nombre del paciente 15 de la clínica 'cli' (si es que el objeto
Paciente existe):
cli.getListaPac().get(15).setNombre("nompaciente");
i) cambiar los síntomas de la enfermedad 4 del paciente 45 de la clínica 'cli':
cli.getListaPac().get(45).getArrEnf()[45].setSintomas("nuevossintomas");