ESTRUCTURA DE CONTENIDOS 1. PARA QUÉ USAR ARREGLOS? 1.1 Enunciado del Problema. 1.2 Análisis del Problema. 1.3 Solución al problema con el uso de arreglos. 2. DECLARACIÓN, CREACIÓN Y USO DE ARREGLOS 2.1 Sintaxis para declarar y crear un arreglo. 2.2 Recorrido de un arreglo. 2.3 Arreglos de Objetos. 3. COLECCIONES Y GENERICS 3.1 Tipos de Colecciones y Características. 3.2 Uso de la colección ArrayList. 3.3 Uso de la colección LinkedList. 3.4 Uso de la colección HashSet. 3.5 Uso de la colección TreeSet. 3.6 Los generics y las colecciones. 1
MAPA CONCEPTUAL 2
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
1.2 Análisis del problema. Fácilmente se puede deducir que el problema se debe descomponer en 2 partes: 1 2 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. 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 import javax.swing.joptionpane; public class Programa1 //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
Primer Intento Se debe determinar cuántos empleados ganan un salario superior al 1 salario promedio anteriormente 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 import javax.swing.joptionpane; public class Programa1A //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; x salariopromedio=sumsalario/totalempleados; //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 1 2 3 4 5 6 Salario 1200000 1500000 950000 800000 1100000 7800000 5
Segundo Intento Se requiere calcular el salario promedio 2 de los empleados de la empresa. 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 import javax.swing.joptionpane; public class Programa1B //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++) x salario=double.parsedouble(joptionpane.showinputdialog(null,"ingrese salario del empleado")); if(salario > salariopromedio) cantemplsalsuperior++; 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. 56
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 Salario SalarioPromedio cantemplsalsup 1 2 3 4 5 6 1200000 1500000 950000 800000 1100000 7800000 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
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 //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); 58
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 Ingrese Salario de empleados 780000 Aceptar Aceptar El numero de empleados con salarios superior al promedio es 3 Aceptar 9
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
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 //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
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 //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
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 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
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 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
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 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 String nombre[]="juan","pedro","luis","lina","diana"; for(int i=0;i<=5;i++) System.out.println(nombre[i]); 15
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
public class Programa3A 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
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
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 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
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 Set ArrayList LinkedList HashSet TreeSet 20
ELEMENTO TIPO DESCRIPCION Collection List Interfaz Interfaz Define un conjunto de métodos comunes a las demás interfaces o clases que se derivan de la interfaz Collection. 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 ArrayList LinkedList Clase 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. 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. HashSet Clase Clase concreta que implementa la interfaz Set. Los elementos de esta clase no permiten duplicados y no se almacenan en orden no determinado. TreeSet 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
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 //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
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 //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
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 //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
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 //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
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 //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
import java.util.arraylist; public class Generics1 //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
import java.util.arraylist; public class Generics1 //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
TipoColección<TipoDato> nombrecoleccion = new TipoColección<TipoDato>(); Ejemplo: LinkedList<String>ciudades = new LinkedList<String> (); import java.util.arraylist; public class Generics2 //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
El siguiente ejemplo muestra el uso de colecciones con Generics: import java.util.arraylist; import java.util.linkedlist; public class Generics3 //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
Control de Documento Construcción Objeto de Aprendizaje Arreglos y Colecciones en JAVA Desarrollador de contenido Experto temático Asesor Pedagógico Productor Multimedia Programadores Líder Expertos Temáticos Líder línea de producción Andrés Julián Valencia Osorio Rafael Neftalí Lizcano Reyes Carlos Julian Ramirez Benitez Daniel Eduardo Martínez Díaz Ana Yaqueline Chavarro Parra Santiago Lozada Garcés 31