Documentos de Académico
Documentos de Profesional
Documentos de Cultura
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//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);
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//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.
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//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);
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
//Crea, llena e imprime una lista con números
//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());
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.
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:
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.
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:
En la línea 23 se define una colección y se especifica que solo almacenará datos de tipo
entero, usando Generics. En la línea 23 se intenta agregar un dato de otro tipo, con lo
cual se genera un error en tiempo de compilación:
package generics;
import java.util.ArrayList;
import java.util.LinkedList;
/**
*
* @author Usuario
*/
public class Generics {
/**
* @param args the command line arguments
*/
public static void main(String[] args) {
//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());