Download ARREGLOS Y COLECCIONES EN JAVA

ARREGLOS Y COLECCIONES EN JAVA
ESTRUCTURA DE CONTENIDOS
1.
¿PARA QUÉ USAR ARREGLOS?
1.1
1.2
1.3
2.
Enunciado del Problema.
Análisis del Problema.
Solución al problema con el uso de arreglos.
DECLARACIÓN, CREACIÓN Y USO DE ARREGLOS
2.1
2.2
2.3
3.
Sintaxis para declarar y crear un arreglo.
Recorrido de un arreglo.
Arreglos de Objetos.
COLECCIONES Y GENERICS
3.1
3.2
3.3
3.4
3.5
3.6
Tipos de Colecciones y Características.
Uso de la colección ArrayList.
Uso de la colección LinkedList.
Uso de la colección HashSet.
Uso de la colección TreeSet.
Los generics y las colecciones.
1
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
MAPA CONCEPTUAL
2
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
INTRODUCCIÓN
Frecuentemente las aplicaciones informáticas requieren manejar conjuntos de datos
comunes en memoria para su posterior consulta o procesamiento, por ejemplo los
nombres de los empleados de una empresa o los precios de los artículos de un
almacén. Este almacenamiento de datos en memoria se puede llevar a cabo a
través de estructuras de programación como los arreglos o las colecciones.
El uso de arreglos y colecciones es fundamental para la solución de problemas a
través de aplicaciones de software y este es el principal propósito del presente
Objeto de Aprendizaje.
1. ¿PARA QUÉ USAR ARREGLOS?
Los arreglos son estructuras de almacenamiento en memoria que permiten llevar a
cabo la lectura, el procesamiento o consulta de conjuntos de datos dentro de una
aplicación de software. Este recurso es de uso común entre los desarrolladores de
software, pero para entender mejor su utilidad, a continuación se presenta un
enunciado de un problema donde se requiere el uso de arreglos.
1.1 Enunciado del problema.
“Determinar la cantidad de empleados de una empresa que
ganan un salario superior al salario promedio de todos los
empleados de la empresa”.
3
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
1.2 Análisis del problema.
Fácilmente se puede deducir que el problema se debe descomponer en 2 partes:
1
2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Se debe determinar cuántos empleados
ganan un salario superior al salario promedio
anteriormente calculado.
Se requiere calcular el salario promedio de
los empleados de la empresa.
import javax.swing.JOptionPane;
public class Programa1
{
public static void main(String arg[])
{
//1. Calcular el salario promedio de los empleados
double sumSalario=0,salario,salarioPromedio;
int totalEmpleados, cantEmplSalSuperior=0;
totalEmpleados=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese cantidad de empleados"));
for(int i=1;i<=totalEmpleados;i++)
{
salario=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese salario del empleado"));
sumSalario=sumSalario+salario;
}
salarioPromedio=sumSalario/totalEmpleados;
//2. Determinar cuántos empleados ganan un salario superior al promedio
for(int i=1;i<=totalEmpleados;i++)
{
//????????????????
}
}
}
El programa anterior calcula correctamente el salario promedio de todos los
empleados de la empresa (punto 1 del análisis), pero ¿cómo determinar cuántos
de esos empleados ganan un salario superior al salario promedio?(punto 2 del
análisis)
4
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
1
Primer Intento
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
Se debe determinar cuántos
empleados ganan un salario superior al
salario promedio anteriormente
import javax.swing.JOptionPane;
public class Programa1A
{
public static void main(String arg[])
{
//1. Calcular el salario promedio de los empleados
double sumSalario=0,salario=0,salarioPromedio;
int totalEmpleados, cantEmplSalSuperior=0;
totalEmpleados=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese cantidad de empleados"));
for(int i=1;i<=totalEmpleados;i++)
{
salario=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese salario del empleado"));
sumSalario=sumSalario+salario;
}
salarioPromedio=sumSalario/totalEmpleados;
x
//2. Determinar cuántos empleados ganan un salario superior al promedio
for(int i=1;i<=totalEmpleados;i++)
{
if(salario > salarioPromedio)
{
cantEmplSalSuperior++;
}
}
La solución propuesta es equivocada porque el salario de cada empleado es leído
en la misma variable salario en la línea 14 del programa, por lo tanto, en la línea
22 del programa, el valor que se tiene en la variable salario es el salario del último
empleado solamente, los salarios de los empleados anteriores se han perdido.
Una pequeña prueba de escritorio muestra como el valor de la variable salario es
actualizado cada vez que se lee un nuevo salario.
i
Salario
1
2
3
4
5
6
1200000
1500000
950000
800000
1100000
7800000
5
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
2
Segundo Intento
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Se requiere calcular el salario promedio
de los empleados de la empresa.
import javax.swing.JOptionPane;
public class Programa1B
{
public static void main(String arg[])
{
//1. Calcular el salario promedio de los empleados
double sumSalario=0,salario,salarioPromedio;
int totalEmpleados, cantEmplSalSuperior=0;
totalEmpleados=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese cantidad de empleados"));
for(int i=1;i<=totalEmpleados;i++)
{
salario=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese salario del empleado"));
sumSalario=sumSalario+salario;
}
salarioPromedio=sumSalario/totalEmpleados;
//2. Determinar cuántos empleados ganan un salario superior al promedio
for(int i=1;i<=totalEmpleados;i++)
{
salario=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese salario del empleado"));
if(salario > salarioPromedio)
{
cantEmplSalSuperior++;
}
}
x
}
}
La segunda solución propuesta incluye en la línea 22 un nuevo código que permite
leer nuevamente el salario de cada empleado. Esta propuesta es equivocada porque
el salario de cada empleado ya había sido leído en la línea 14 del programa. Esta
solución además del doble trabajo que significa leer en 2 oportunidades el salario de
cada empleado, es insegura, ya que al volver a leer el salario de cada empleado, el
usuario podría ingresar salarios diferentes a los usados para calcular el salario
promedio.
5
6
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
1.3 SOLUCIÓN AL PROBLEMA CON EL USO DE ARREGLOS.
La segunda solución propuesta incluye en la línea 22 un nuevo código que permite
leer nuevamente el salario de cada empleado. Esta propuesta es equivocada
porque el salario de cada empleado ya había sido leído en la línea 14 del programa.
Esta solución además del doble trabajo que significa leer en 2 oportunidades el
salario de cada empleado, es insegura, ya que al volver a leer el salario de cada
empleado, el usuario podría ingresar salarios diferentes a los usados para calcular el
salario promedio.
i
1
2
3
4
5
6
Salario
1200000
1500000
950000
800000
1100000
7800000
SalarioPromedio cantEmplSalSup
1055000
3
Los arreglos permiten realizar el almacenamiento de un conjunto de valores en
posiciones de memoria diferentes para que cada valor pueda ser accedido en
cualquier momento durante la ejecución de un programa.
La solución al problema consiste en definir un arreglo para
almacenar los diferentes salarios de los empleados de la empresa, a
partir de ellos calcular el salario promedio y posteriormente acceder
al arreglo de salarios para determinar cuántos de ellos son
superiores al salario promedio.
7
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
SOLUCIÓN FINAL USANDO UN ARREGLO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import javax.swing.JOptionPane;
public class Programa1Final
{
public static void main(String arg[])
{
//1. Calcular el salario promedio de los empleados
double salario[];//Declaración del arreglo de Salarios
double sumSalario=0,salarioPromedio;
int totalEmpleados, cantEmplSalSuperior=0;
totalEmpleados=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese cantidad de empleados"));
salario= new double[totalEmpleados];//Creación del arreglo de Salarios
for(int i=0;i<totalEmpleados;i++)
{
//Lectura de cada posición (i) del arreglo (en cada posición se almacena un salario diferente
salario[i]=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese salario del empleado"));
sumSalario=sumSalario+salario[i];
}
salarioPromedio=sumSalario/totalEmpleados;
JOptionPane.showMessageDialog(null, "El salario promedio es "+salarioPromedio);
//2. Determinar cuántos empleados ganan un salario superior al promedio
for(int i=0;i<totalEmpleados;i++)
{
//Uso del arreglo de salarios, previamente cargado en la línea 18
if(salario[i] > salarioPromedio)
{
cantEmplSalSuperior++;
}
}
JOptionPane.showMessageDialog(null, "El numero de empleados con salario superior al promedio
es "+cantEmplSalSuperior);
}
}
5
8
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
Ejecución del programa:
Ingrese cantidad de empleados
6
Aceptar
Ingrese Salario de empleados
1200000
Aceptar
Ingrese Salario de empleados
1500000
Aceptar
Ingrese Salario de empleados
950000
Aceptar
Ingrese Salario de empleados
800000
Aceptar
Ingrese Salario de empleados
1100000
Aceptar
El salario promedio es 1055000.0
Aceptar
Ingrese Salario de empleados
780000
Aceptar
El numero de empleados con salarios
superior al promedio es 3
Aceptar
9
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
2. DECLARACIÓN, CREACIÓN Y USO DE ARREGLOS
2.1 Sintaxis para declarar y crear un arreglo.
La declaración de un arreglo es similar a la declaración de una variable, la sintaxis
es la siguiente:
tipoDato nombreArreglo[ ];
Ejemplos:
int edad[ ];
Declaración de un arreglo de enteros llamado edad
float nota[ ];
Declaración de un arreglo de reales llamado nota
String nombre[ ]; Declaración de un arreglo de cadenas llamado nombre
En el ejercicio anteriormente resuelto, se aprecia la declaración de un arreglo de
tipo doublé llamado salario:
10
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import javax.swing.JOptionPane;
public class Programa1Final
{
public static void main(String arg[])
{
//1. Calcular el salario promedio de los empleados
double salario[];//Declaración del arreglo de Salarios
double sumSalario=0,salarioPromedio;
int totalEmpleados, cantEmplSalSuperior=0;
totalEmpleados=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese cantidad de empleados"));
salario= new double[totalEmpleados];//Creación del arreglo de Salarios
for(int i=0;i<totalEmpleados;i++)
{
//Lectura de cada posición (i) del arreglo (en cada posición se almacena un salario diferente
salario[i]=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese salario del empleado"));
sumSalario=sumSalario+salario[i];
}
salarioPromedio=sumSalario/totalEmpleados;
JOptionPane.showMessageDialog(null, "El salario promedio es "+salarioPromedio);
//2. Determinar cuántos empleados ganan un salario superior al promedio
for(int i=0;i<totalEmpleados;i++)
{
//Uso del arreglo de salarios, previamente cargado en la línea 18
if(salario[i] > salarioPromedio)
{
cantEmplSalSuperior++;
}
}
JOptionPane.showMessageDialog(null, "El numero de empleados con salario superior al promedio
es "+cantEmplSalSuperior);
}
}
Después de declarar un arreglo, este debe crearse, para ello se usa la palabra
reservada new y se define la cantidad de posiciones que el arreglo puede
contener para el almacenamiento de valores.
Sintaxis:
Arreglo = new TipoDato[tamaño];
11
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
Ejemplos:
·
·
·
edad = new int [10]; Creación del arreglo edad con 10 posiciones
nota = new float [15]; Creación del arreglo nota con 15 posiciones
nombre = new String [5]; Creación del arreglo nombre con 5 posiciones
En el ejercicio anteriormente resuelto, se aprecia la creación de un arreglo
llamado salario de una cantidad de posiciones definida por la variable
totalEmpleados:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import javax.swing.JOptionPane;
public class Programa1Final
{
public static void main(String arg[])
{
//1. Calcular el salario promedio de los empleados
double salario[];//Declaración del arreglo de Salarios
double sumSalario=0,salarioPromedio;
int totalEmpleados, cantEmplSalSuperior=0;
totalEmpleados=Integer.parseInt(JOptionPane.showInputDialog(null,"Ingrese cantidad de empleados"));
salario= new double[totalEmpleados];//Creación del arreglo de Salarios
for(int i=0;i<totalEmpleados;i++)
{
//Lectura de cada posición (i) del arreglo (en cada posición se almacena un salario diferente
salario[i]=Double.parseDouble(JOptionPane.showInputDialog(null,"Ingrese salario del empleado"));
sumSalario=sumSalario+salario[i];
}
salarioPromedio=sumSalario/totalEmpleados;
JOptionPane.showMessageDialog(null, "El salario promedio es "+salarioPromedio);
//2. Determinar cuántos empleados ganan un salario superior al promedio
for(int i=0;i<totalEmpleados;i++)
{
//Uso del arreglo de salarios, previamente cargado en la línea 18
if(salario[i] > salarioPromedio)
{
cantEmplSalSuperior++;
}
}
JOptionPane.showMessageDialog(null, "El numero de empleados con salario superior al promedio
es "+cantEmplSalSuperior);
}
}
La primera posición de un arreglo en Java es la posición 0 y la última es n-1,
donde n es el tamaño del arreglo.
12
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
En Java también es posible declarar y crear un objeto en la misma línea de
código, ejemplo:
int edad [ ] = new int [10];
Declaración y creación de un arreglo llamado edad de 10 posiciones de tipo
entero.
floatnota [ ] = new float [15];
Declaración y creación de un arreglo llamado nota de 15 posiciones de tipo float.
String nombre [ ] = new String [5];
Declaración y creación de un arreglo llamado nombre de 5 posiciones de tipo
String.
El siguiente ejemplo muestra la declaración, creación, inicialización y consulta de
un arreglo llamado edad de 5 posiciones de tipo entero:
public class Programa2
{
public static void main(String arg[])
{
int edad[]= new int[5];
edad[0]=18;
edad[1]=20;
edad[2]=15;
edad[3]=35;
edad[4]=53;
for(int i=0;i<5;i++)
{
System.out.println("El valor del arreglo edad en la posicion
"+i+" es "+edad[i]);
}
}
}
Al ejecutar el programa, el resultado es el siguiente:
13
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
También es posible inicializar un arreglo en la misma línea donde es declarado y
creado.
El siguiente ejemplo declara, crea e inicializa en la misma línea de código un
arreglo de 5 posiciones de tipo cadena con los nombres de 5 personas diferentes,
posteriormente se imprime el contenido del arreglo:
public class Programa3
{
public static void main(String arg[])
{
String nombre[]={"Juan","Pedro","Luis","Lina","Diana"};
for(int i=0;i<5;i++)
{
System.out.println(nombre[i]);
}
}
}
Al ejecutar el programa, el resultado es el siguiente:
14
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
2.2
Recorrido de un arreglo.
Como se ha visto anteriormente, el recorrido de un arreglo requiere de un ciclo
para pasar por cada una de sus posiciones; en el programa anterior, se aprecia el
uso del ciclo for para acceder a todas las posiciones del arreglo nombres.
public class Programa3
{
public static void main(String arg[])
{
String nombre[]={"Juan","Pedro","Luis","Lina","Diana"};
for(int i=0;i<5;i++)
{
System.out.println(nombre[i]);
}
}
}
Pero ¿qué podría ocurrir al intentar acceder a una posición inexistente de un
arreglo?. Este es un error común en programación, veamos el siguiente ejemplo:
public class Programa3A
{
public static void main(String arg[])
{
String nombre[]={"Juan","Pedro","Luis","Lina","Diana"};
for(int i=0;i<=5;i++)
{
System.out.println(nombre[i]);
}
}
}
15
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
El arreglo anterior es de 5 posiciones, las cuales están comprendidas desde la
posición 0 hasta la posición 4.
Al intentar acceder la posición 5 del arreglo, se lanzará una excepción de tipo
ArrayIndexOutOfBoundsException
Afortunadamente existe una forma más segura de recorrer un arreglo, esta es
utilizando un ciclo especial conocido como el ciclo for each.
Sintaxis:
for (TipoDato variable : Arreglo)
·
Permite recorrer todas las posiciones del arreglo, a través de la variable
Ejemplo:
for (Stringx : nombre)
·
Recorre todas las posiciones del arreglo nombre a través de la variable x
El ejercicio anterior, puede ser modificado para realizar el recorrido del arreglo de
manera segura mediante el uso del ciclo for each:
16
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
public class Programa3A
{
public static void main(String arg[])
{
String nombre[]={"Juan","Pedro","Luis","Lina","Diana"};
for(String x: Nombre)
{
System.out.println(x);
}
}
}
Al ejecutar el programa, el resultado es el siguiente:
2.3 Arreglos de Objetos.
17
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
2.3 Arreglos de Objetos.
De la misma manera como se declaran, crean, inicializan y acceden los arreglos
de tipos de datos primitivos se hace con los arreglos de objetos. De hecho el
arreglo de tipo String es un arreglo de objetos. Pero para entender mejor este
aspecto, vamos a implementar un programa que cree un arreglo de objetos
asociados a una clase personalizada.
El siguiente es el código de la clase Alumno:
public class Alumno
{
private String nombre;
private double nota;
public Alumno(String nombre,double nota)
{
this.nombre=nombre;
this.nota=nota;
}
public String getNombre()
{
return nombre;
}
public double getNota()
{
return nota;
}
}
18
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
El programa 4, muestra la manera de crear un arreglo de objetos de la clase
Alumno y su respectivo procesamiento:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class Programa4
{
public static void main(String arg[])
{
Alumno estudiante[]=new Alumno[3];
estudiante[0]=new Alumno("Andres",3.5);
estudiante[1]=new Alumno("Julian",5);
estudiante[2]=new Alumno("Fabian",4.2);
for(Alumno al:estudiante)
{
System.out.println("El alumno "+al.getNombre()+" obtuvo una nota de "+al.getNota());
}
}
}
Linea 5 : Declaración y creación de un arreglo de 3 posiciones de tipo Alumno
Linea 6,7,8 : Declaración y creación de un arreglo de 3 posiciones de tipo Alumno
Linea 10 : Configuración del ciclo for each para recorrer todas las posiciones del
arreglo de tipo Alumno llamado estudiante a través de una variable
llamada al
Linea 12 : Acceso a los métodos de cada objeto almacenado en el arreglo
Al ejecutar el programa, se obtiene el siguiente resultado:
19
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
3.0 COLECCIONES Y GENERICS
Los arreglos son una excelente herramienta de programación, principalmente
cuando la cantidad de posiciones del mismo se mantiene constante, sin embargo, al
momento de incluir más elementos dentro de un arreglo o al momento de querer
eliminar posiciones del mismo, los arreglos son ineficientes.
En Java existen otras estructuras de almacenamiento conocidas como colecciones.
Una colección permite almacenar información en memoria de manera dinámica, es
decir, permite el aumento o disminución del tamaño de la colección de acuerdo con la
necesidad de la aplicación.
3.1
Tipos de Colecciones y Características.
COLLECTION
List
ArrayList
Set
LinkedList
HashSet
TreeSet
20
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
ELEMENTO
TIPO
DESCRIPCION
Collection
Interfaz
Define un conjunto de métodos comunes a
las demás interfaces o clases que se
derivan de la interfaz Collection.
List
Interfaz
Maneja de manera ordenada los elementos
introducidos de acuerdo con el orden de
inserción. Permite elementos duplicados.
Set
Interfaz
Colección desordenada de objetos. No
permite elementos duplicados
Clase
Clase concreta que implementa la interfaz
List, esta clase se basa en un arreglo
dinámico. Permite un acceso rápido a los
elementos de la colección, pero es lenta
para la inserción o eliminación de objetos.
ArrayList
LinkedList
HashSet
TreeSet
Clase
Clase concreta que implementa la interfaz
List, esta clase se basa en una lista
enlazada. Es muy útil cuando la cantidad
de elementos de la colección es muy
variable. El acceso a un elemento
particular de la colección es más lento.
Clase
Clase concreta que implementa la interfaz
Set. Los elementos de esta clase no
permiten duplicados y no se almacenan en
orden no determinado.
Clase
Clase concreta que implementa la interfaz
Set. Los elementos de esta clase no
permiten duplicados y sus elementos se
ordenan de manera ascendente.
Para usar cualquier elemento de la API de Colecciones, se debe implementar el
paquete java.util
21
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
3.2
Uso de la clase ArrayList.
Para comprender mejor el uso de la clase ArrayList, se presenta el siguiente
ejemplo:
import java.util.ArrayList;
public class TestArrayList
{
public static void main(String arg[])
{
//Crea, llena e imprime una lista con números
ArrayList listaNums= new ArrayList();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
System.out.println("Lista de numeros: "+listaNums);
//-----------------------------------------//Crea, llena e imprime una lista con nombres
ArrayList listaNombres= new ArrayList();
listaNombres.add("Juan");
listaNombres.add("Pedro");
listaNombres.add("Carlos");
listaNombres.add("Daniel");
listaNombres.add("Carlos");
System.out.println("Lista de nombres:"+listaNombres);
//-----------------------------------------//Obtener un elemento particular de la lista
System.out.println("Numero posicion 2:"+listaNums.get(2));
System.out.println("Nombre posicion 0:"+listaNombres.get(0));
//Reemplazar un elemento de la lista
listaNums.set(0,15);
listaNombres.set(0,"Claudia");
//Las listas quedan así:
System.out.println("Lista de numeros: "+listaNums);
System.out.println("Lista de nombres:"+listaNombres);
}
}
La clase ArrayList está basada en un arreglo dinámico y permite gestionar su
contenido a través de posiciones específicas. Por implementar la interfaz List, el
almacenamiento de sus datos se da de acuerdo con el orden de inserción y
permite los elementos repetidos.
22
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
3.3
Uso de la clase LinkedList.
Para comprender mejor el uso de la clase LinkedList, se presenta el siguiente
ejemplo:
import java.util.LinkedList;
public class TestLinkedList
{
public static void main(String arg[])
{
//Crea, llena e imprime una lista con números
LinkedList listaNums= new LinkedList();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
//Insertar un nuevo dato al inicio de la lista
listaNums.addFirst(10);
System.out.println("Lista de numeros: "+listaNums);
//-----------------------------------------//Crea, llena e imprime una lista con nombres
LinkedList listaNombres= new LinkedList();
listaNombres.add("Juan");
listaNombres.add("Pedro");
listaNombres.add("Carlos");
listaNombres.add("Daniel");
listaNombres.add("Carlos");
//Insertar un nuevo dato al inicio de la lista
listaNombres.addFirst("Julian");
System.out.println("Lista de nombres:"+listaNombres);
//-----------------------------------------//Obtiene y remueve el primer elemento de la lista
System.out.println("Elemento removido:"+listaNums.poll());
System.out.println("Elemento removido:"+listaNombres.poll());
//Las listas quedan así:
System.out.println("Lista de numeros: "+listaNums);
System.out.println("Lista de nombres:"+listaNombres);
}
}
La clase LinkedList está basada en una lista doblemente enlazada, en la que se
conoce cuál es el primer elemento y último elemento de la lista, por esta razón, se
facilitan las operaciones que se hacen al principio o al final de la lista como la
inserción o eliminación de elementos. Por implementar la interfaz List, el
almacenamiento de sus datos se da de acuerdo con el orden de inserción y
permite los elementos repetidos.
23
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
3.4
Uso de la claseHashSet.
Para comprender mejor el uso de la clase HashSet, se presenta el siguiente
ejemplo:
import java.util.HashSet;
public class TestHashSet
{
public static void main(String arg[])
{
//Crea, llena e imprime una lista con números
HashSet listaNums= new HashSet();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
System.out.println("Lista de numeros: "+listaNums);
//-----------------------------------------//Crea, llena e imprime una lista con nombres
HashSet listaNombres= new HashSet();
listaNombres.add("Juan");
listaNombres.add("Pedro");
listaNombres.add("Carlos");
listaNombres.add("Daniel");
listaNombres.add("Carlos");
System.out.println("Lista de nombres:"+listaNombres);
//-----------------------------------------//Remueve un elemento de la lista
listaNums.remove(5);
listaNombres.remove("Pedro");
//Las listas quedan así:
System.out.println("Lista de numeros: "+listaNums);
System.out.println("Lista de nombres:"+listaNombres);
}
}
La clase HashSetbasa la organización de sus elementos en un algoritmo especial,
mediante el cual, cada elemento posee una clave o identificador no manipulable
a través del cual se realiza el ordenamiento y búsqueda de los elementos de la
colección. Por esta razón el orden de los elementos almacenados en la colección
es indeterminado. Al implementar la interfaz Set, la clase HashSet tiene la
característica de no permitir elementos duplicados.
24
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
3.5
Uso de la clase TreeSet.
Para comprender mejor el uso de la clase TreeSet, se presenta el siguiente
ejemplo:
import java.util.TreeSet;
public class TestTreeSet
{
public static void main(String arg[])
{
//Crea, llena e imprime un conjunto con números
TreeSet listaNums= new TreeSet();
listaNums.add(8);
listaNums.add(3);
listaNums.add(5);
listaNums.add(2);
listaNums.add(3);
System.out.println("Lista de numeros: "+listaNums);
//-----------------------------------------//Crea, llena e imprime un conjunto con nombres
TreeSet listaNombres= new TreeSet();
listaNombres.add("Juan");
listaNombres.add("Pedro");
listaNombres.add("Carlos");
listaNombres.add("Daniel");
listaNombres.add("Carlos");
System.out.println("Lista de nombres:"+listaNombres);
//-----------------------------------------//Elementos mayores a un elemento dado
System.out.println("Numeros mayores o iguales a 3:"+listaNums.tailSet(3));
System.out.println("Nombres mayores o iguales a Daniel:"+listaNombres.tailSet("Daniel"));
//Se muestran los datos en orden descendente
System.out.println("Numeros en orden descendente: "+listaNums.descendingSet());
System.out.println("Nombres en orden descendente:"+listaNombres.descendingSet());
}
}
La clase TreeSet mantiene siempre los elementos de la colección de manera
ordenada. Al implementar la interfaz Set, la clase TreeSet tiene la característica
de no permitir elementos duplicados. Posee un conjunto de métodos que
permiten aprovechar la ventaja de mantener siempre los datos ordenados.
25
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
3.6
Los generics y las colecciones.
Los datos que se almacenan en una colección siempre son de tipo Object, esto
significa que teóricamente en una colección podemos almacenar cualquier dato.
Esto aunque a primera vista parece una ventaja, en la práctica presenta
dificultades, en primer lugar por la falta de seguridad en los datos almacenados y
en segundo lugar, por la necesidad de hacer casting o conversiones en los datos
almacenados para pasarlos del tipo Object a su tipo real.
Veamos el siguiente ejemplo:
import java.util.ArrayList;
public class Generics1
{
public static void main(String arg[])
{
//Se crea una colección y se le asignan datos
//de diferentes tipos
ArrayList miLista= new ArrayList();
miLista.add(4);
miLista.add("Juan");
miLista.add(new Alumno("Pedro",4.3));
}
}
El programa anterior compila sin problemas, porque una colección recibe datos de
cualquier tipo, debido a que todos los datos al interior de la colección son tratados
como datos de tipo Object. Esta característica no le permite al programador tener
un control en tiempo de compilación sobre la integridad de los datos almacenados.
Si se intenta recuperar la información de la lista en diferentes variables, se
generan errores de compilación, por incompatibilidad de tipo de datos:
26
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
import java.util.ArrayList;
public class Generics1
{
public static void main(String arg[])
{
//Se crea una colección y se le asignan datos
//de diferentes tipos
ArrayList miLista= new ArrayList();
miLista.add(4);
miLista.add("Juan");
miLista.add(new Alumno("Pedro",4.3));
//Para obtener los datos en su original tipo
//se requiere hacer casting.
int a = miLista.get(0);
String b = miLista.get(1);
Alumno c = miLista.get(2);
}
}
Las instrucciones anteriores generan error de compilación.
Para permitir recuperar los datos en su plenitud, es necesario hacer casting de
datos, es decir, realizar una conversión de datos entre el tipo Object (que es por
defecto el tipo de dato de cualquier elemento al interior de una colección) y el tipo
de dato deseado.
27
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
import java.util.ArrayList;
public class Generics1
{
public static void main(String arg[])
{
//Se crea una colección y se le asignan datos
//de diferentes tipos
ArrayList miLista= new ArrayList();
miLista.add(4);
miLista.add("Juan");
miLista.add(new Alumno("Pedro",4.3));
//Para obtener los datos en su original tipo
//se requiere hacer casting.
int a = ( Intiger )miLista.get(0);
String b = ( String ) miLista.get(1);
Alumno c = ( Alumno ) miLista.get(2);
}
}
Para tener mayor control sobre los datos que se almacenan en una colección y
para evitar la necesidad de realizar una gran cantidad de casting a la hora de
trabajar con colecciones, a partir de la versión 5 de Java se incluye el concepto
de Generics. Los generics permiten asignarle a una colección un tipo de dato
predeterminado. La sintaxis para la definición de una colección con Generics es
la siguiente:
28
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
TipoColección<TipoDato> nombreColeccion = new
TipoColección<TipoDato>();
Ejemplo:
LinkedList<String>ciudades = new LinkedList<String> ();
import java.util.ArrayList;
public class Generics2
{
public static void main(String arg[])
{
//Se crea una colección de tipo entero para
//el almacenamiento y procesamiento de numeros
ArrayList<Integer> listaNums = new ArrayList<Integer>();
listaNums.add(2);
listaNums.add(7);
listaNums.add("Juan");
}
}
En la línea 9 se define una colección y se especifica que solo almacenará datos
de tipo entero, usando Generics. En la línea 12 se intenta agregar un dato de otro
tipo, con lo cual se genera un error en tiempo de compilación:
29
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
El siguiente ejemplo muestra el uso de colecciones con Generics:
import java.util.ArrayList;
import java.util.LinkedList;
public class Generics3
{
public static void main(String arg[])
{
//Se crea una colección de tipo entero para
//el almacenamiento y procesamiento de numeros
ArrayList<Integer> listaNums = new ArrayList<Integer>();
listaNums.add(2);
listaNums.add(7);
listaNums.add(5);
//Se crea una colección de tipo string para
//el almacenamiento y procesamiento de cadenas de caracteres
LinkedList<String> listaCiudades = new LinkedList<String>();
listaCiudades.add("Manizales");
listaCiudades.add("Medellin");
listaCiudades.add("Cali");
//Se crea una colección de tipo Alumno para
//el almacenamiento y procesamiento de Alumnos
ArrayList<Alumno> alumnos = new ArrayList<Alumno>();
alumnos.add(new Alumno("Andres",3.2));
alumnos.add(new Alumno("Julian",4.2));
alumnos.add(new Alumno("Carlos",4.9));
//Procesamiento de los datos almacenados en las colecciones
//sin necesidad de casting
int a=listaNums.get(0);
String b=listaCiudades.get(0);
Alumno c=alumnos.get(0);
System.out.println("El primer numero es "+a);
System.out.println("La primera ciudad es "+b);
System.out.println("El alumno "+c.getNombre()+" obtuvo una nota de "+c.getNota());
}
}
El resultado de ejecutar el anterior programa es el siguiente:
30
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje
ARREGLOS Y COLECCIONES EN JAVA
Control de Documento
Construcción Objeto de Aprendizaje
Arreglos y Colecciones en JAVA
Desarrollador de contenido
Experto temático
Andrés Julián Valencia Osorio
Asesor Pedagógico
Rafael Neftalí Lizcano Reyes
Productor Multimedia
Carlos Julian Ramirez Benitez
Programadores
Daniel Eduardo Martínez Díaz
Líder Expertos Temáticos
Ana Yaqueline Chavarro Parra
Líder línea de producción
Santiago Lozada Garcés
31
FAVA - Formación en Ambientes Virtuales de Aprendizaje
SENA - Servicio Nacional de Aprendizaje