laboratorio de colecciones en java

1

Laboratorio de Colecciones en Java

Una colección es una estructura de datos que puede guardar referencia a otros objetos. Las más importantes son

Vector, Stack, Dictionary, HashTable y la interfaz Enumeration para recorrer los elementos de una colección. Existen

tres tipos generales de colecciones: conjuntos, listas y mapas; las interfaces Set, List y Map describen las

características de estos. La interfaz Collection especifica el comportamiento común de las colecciones.

Instrucciones (Trabajo a ser realizado en grupos de dos personas)

a) Ejecute cada uno de los programas considerados en la siguiente práctica.

b) Comente en una hoja aparte el resultado de cada programa.

c) Para cada programa: comente cada métodos o clase (relacionados a la interfaz Collection o Collections) usado

para cada uno de los programas

2

De preferencia use el siguiente formato:

Nombre de programa: nombre y comentario

Clase: nombre y comentario (es importante indicar si se implementa alguna interfaz)

Método1:nombre y comentario

Método2:nombre y comentario

…..

1. La clase Arrays

import java.util.Arrays;

public class UsoArrays

{

private int arregloInt[] = { 1, 2, 3, 4, 5, 6 };

private double arregloDouble[] = { 8.4, 9.3, 0.2, 7.9, 3.4 };

private int arregloIntLleno[], copiaArregloInt[];

// el constructor inicializa los arreglos

public UsoArrays()

{

arregloIntLleno = new int[ 10 ]; // crea arreglo int con 10 elementos

copiaArregloInt = new int[ arregloInt.length ];

Arrays.fill( arregloIntLleno, 7 ); // llena con 7s

Arrays.sort( arregloDouble ); // ordena arregloDouble en forma ascendente

// copia el arreglo arregloInt en el arreglo copiaArregloInt

System.arraycopy( arregloInt, 0, copiaArregloInt,

0, arregloInt.length );

} // fin del constructor de UsoArrays

// imprime los valores en cada arreglo

public void imprimirArreglos()

{

System.out.print( "arregloDouble: " );

for ( double valorDouble : arregloDouble )

System.out.printf( "%.1f ", valorDouble );

System.out.print( "\narregloInt: " );

for ( int valorInt : arregloInt )

System.out.printf( "%d ", valorInt );

System.out.print( "\narregloIntLleno: " );

for ( int valorInt : arregloIntLleno )


System.out.print( "\ncopiaArregloInt: " );

for ( int valorInt : copiaArregloInt )


System.out.println( "\n" );

} // fin del método imprimirArreglos

// busca un valor en el arreglo arregloInt

public int buscarUnInt( int valor )

{

return Arrays.binarySearch( arregloInt, valor );

} // fin del método buscarUnInt

// compara el contenido del arreglo

public void imprimirIgualdad()

{

boolean b = Arrays.equals( arregloInt, copiaArregloInt );

System.out.printf( "arregloInt %s copiaArregloInt\n",

( b ? "==" : "!=" ) );

b = Arrays.equals( arregloInt, arregloIntLleno );

System.out.printf( "arregloInt %s arregloIntLleno\n",

( b ? "==" : "!=" ) );

3

} // fin del método imprimirIgualdad

public static void main( String args[] )

{

UsoArrays usoArreglos = new UsoArrays();

usoArreglos.imprimirArreglos();

usoArreglos.imprimirIgualdad();

int ubicacion = usoArreglos.buscarUnInt( 5 );

if ( ubicacion >= 0 )

System.out.printf(

"Se encontro el 5 en el elemento %d de arregloInt\n", ubicacion );

else

System.out.println( "No se encontro el 5 en arregloInt" );

ubicacion = usoArreglos.buscarUnInt( 8763 );

if ( ubicacion >= 0 )

System.out.printf(

"Se encontro el 8763 en el elemento %d en arregloInt\n", ubicacion );

else

System.out.println( "No se encontro el 8763 en arregloInt" );

} // fin de main

} // fin de la clase UsoArrays

2. La interfaz Collection y la clase Collections La interfaz Collection es la interfaz raíz en la jerarquía de colecciones, a partir de la cual se derivan las interfaces Set,

Queue y List. La clase Collections contiene operaciones masivas en una colección.

3. Listas

3.1. ArrayList e Iterator

// Uso de la interfaz Collection.

import java.util.List;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Iterator;

public class PruebaCollection

{

private static final String[] colores =

{ "MAGENTA", "ROJO", "BLANCO", "AZUL", "CYAN" };

private static final String[] eliminarColores =

{ "ROJO", "BLANCO", "AZUL" };

// crea objeto ArrayList, le agrega los colores y lo manipula

public PruebaCollection()

{

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

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

// agrega los elementos en el arreglo colores a la lista

for ( String color : colores )

lista.add( color );

// agrega los elementos en eliminarColores a eliminarLista

for ( String color : eliminarColores )

eliminarLista.add( color );

System.out.println( "ArrayList: " );

// imprime en pantalla el contenido de la lista

for ( int cuenta = 0; cuenta < lista.size(); cuenta++ )

System.out.printf( "%s ", lista.get( cuenta ) );

// elimina los colores contenidos en eliminarLista

eliminarColores( lista, eliminarLista );

System.out.println( "\n\nArrayList despues de llamar a eliminarColores: " );

// imprime en pantalla el contenido de la lista

for ( String color : lista )

4

System.out.printf( "%s ", color );

} // fin del constructor de PruebaCollection

// elimina de coleccion1 los colores especificados en coleccion2

private void eliminarColores(

Collection< String > coleccion1, Collection< String > coleccion2 )

{

// obtiene el iterador

Iterator< String > iterador = coleccion1.iterator();

// itera mientras la colección tenga elementos

while ( iterador.hasNext() )

if ( coleccion2.contains( iterador.next() ) )

iterador.remove(); // elimina el color actual

} // fin del método eliminarColores


{

new PruebaCollection();

} // fin de main

} // fin de la clase PruebaCollection

3.2. LinkedList // Uso de objetos LinkList.


import java.util.LinkedList;

import java.util.ListIterator;

public class PruebaList

{

private static final String colores[] = { "negro", "amarillo",

"verde", "azul", "violeta", "plateado" };

private static final String colores2[] = { "dorado", "blanco",

"cafe", "azul", "gris", "plateado" };

// establece y manipula objetos LinkedList

public PruebaList()

{

List< String > lista1 = new LinkedList< String >();

List< String > lista2 = new LinkedList< String >();

// agrega elementos a la lista enlace


lista1.add( color );

// agrega elementos a la lista enlace2

for ( String color : colores2 )

lista2.add( color );

lista1.addAll( lista2 ); // concatena las listas

lista2 = null; // libera los recursos

imprimirLista( lista1 ); // imprime los elementos de lista1

convertirCadenasAMayusculas( lista1 ); // convierte cadena a mayúsculas


System.out.print( "\nEliminando elementos 4 a 6..." );

eliminarElementos( lista1, 4, 7 ); // elimina los elementos 4 a 7 de la lista


imprimirListaInversa( lista1 ); // imprime la lista en orden inverso

} // fin del constructor de PruebaList

// imprime el contenido del objeto List

public void imprimirLista( List< String > lista )

{

System.out.println( "\nlista: " );

for ( String color : lista )

System.out.printf( "%s ", color );

System.out.println();

} // fin del método imprimirLista

// localiza los objetos String y los convierte a mayúsculas

private void convertirCadenasAMayusculas( List< String > lista )

{

ListIterator< String > iterador = lista.listIterator();

5

while ( iterador.hasNext() )

{

String color = iterador.next(); // obtiene elemento

iterador.set( color.toUpperCase() ); // convierte a mayúsculas

} // fin de while

} // fin del método convertirCadenasAMayusculas

// obtiene sublista y utiliza el método clear para eliminar los elementos de la misma

private void eliminarElementos( List< String > lista, int inicio, int fin )

{

lista.subList( inicio, fin ).clear(); // elimina los elementos

} // fin del método eliminarElementos

// imprime la lista inversa

private void imprimirListaInversa( List< String > lista )

{

ListIterator< String > iterador = lista.listIterator( lista.size() );

System.out.println( "\nLista inversa:" );

// imprime la lista en orden inverso

while ( iterador.hasPrevious() )

System.out.printf( "%s ", iterador.previous() );

} // fin del método imprimirListaInversa


{

new PruebaList();

} // fin de main

} // fin de la clase PruebaList

3.3. Arreglo como una colección List

// Uso del método toArray.

import java.util.LinkedList;


public class UsoToArray

{

// el constructor crea un objeto LinkedList, le agrega elementos y lo convierte en arreglo

public UsoToArray()

{

String colores[] = { "negro", "azul", "amarillo" };

LinkedList< String > enlaces =

new LinkedList< String >( Arrays.asList( colores ) );

enlaces.addLast( "rojo" ); // lo agrega como último elemento

enlaces.add( "rosa" ); // lo agrega al final

enlaces.add( 3, "verde" ); // lo agrega en el 3er índice

enlaces.addFirst( "cyan" ); // lo agrega como primer elemento

// obtiene los elementos de LinkedList como un arreglo

colores = enlaces.toArray( new String[ enlaces.size() ] );

System.out.println( "colores: " );


System.out.println( color );

} // fin del constructor de UsoToArray


{

new UsoToArray();

} // fin de main

} // fin de la clase UsoToArray

4. Vector // Uso de la clase Vector.

import java.util.Vector;

import java.util.NoSuchElementException;

public class PruebaVector

{

private static final String colores[] = { "rojo", "blanco", "azul" };

6

public PruebaVector()

{

Vector< String > vector = new Vector< String >();

imprimirVector( vector ); // imprime el vector

// agrega elementos al vector


vector.add( color );


// imprime los elementos primero y último

try

{

System.out.printf( "Primer elemento: %s\n", vector.firstElement());

System.out.printf( "Ultimo elemento: %s\n", vector.lastElement() );

} // fin de try

// atrapa la excepción si el vector está vacío

catch ( NoSuchElementException excepcion )

{

excepcion.printStackTrace();

} // fin de catch

// ¿el vector contiene "rojo"?

if ( vector.contains( "rojo" ) )

System.out.printf( "\nse encontro \"rojo\" en el indice %d\n\n",

vector.indexOf( "rojo" ) );

else

System.out.println( "\nno se encontro \"rojo\"\n" );

vector.remove( "rojo" ); // elimina la cadena "rojo"

System.out.println( "se elimino \"rojo\"" );


// ¿el vector contiene "rojo" después de la operación de eliminación?

if ( vector.contains( "rojo" ) )

System.out.printf(

"se encontro \"rojo\" en el indice %d\n", vector.indexOf( "rojo" ) );

else

System.out.println( "no se encontro \"rojo\"" );

// imprime el tamaño y la capacidad del vector

System.out.printf( "\nTamanio: %d\nCapacidad: %d\n", vector.size(),

vector.capacity() );

} // fin del constructor de PruebaVector

private void imprimirVector( Vector< String > vectorAImprimir )

{

if ( vectorAImprimir.isEmpty() )

System.out.print( "el vector esta vacio" ); // vectorAImprimir está vacío

else // itera a través de los elementos

{

System.out.print( "el vector contiene: " );

// imprime los elementos

for ( String elemento : vectorAImprimir )

System.out.printf( "%s ", elemento );

} // fin de else

System.out.println( "\n" );

} // fin del método imprimirVector


{

new PruebaVector(); // crea objeto y llama a su constructor

} // fin de main

} // fin de la clase PruebaVector

5. Algoritmos de las colecciones

5.1. Algoritmo sort

5.1.1. Ordenamiento ascendente // Uso del algoritmo sort.



7

import java.util.Collections;

public class Ordenamiento1

{

private static final String palos[] =

{ "Corazones", "Diamantes", "Bastos", "Espadas" };

// muestra los elementos del arreglo

public void imprimirElementos()

{

List< String > lista = Arrays.asList( palos ); // crea objeto List

// imprime lista

System.out.printf( "Elementos del arreglo desordenados:\n%s\n", lista );

Collections.sort( lista ); // ordena ArrayList

// imprime lista

System.out.printf( "Elementos del arreglo ordenados:\n%s\n", lista );

} // fin del método imprimirElementos


{

Ordenamiento1 orden1 = new Ordenamiento1();

orden1.imprimirElementos();

} // fin de main

} // fin de la clase Ordenamiento1

5.1.2. Ordenamiento descendente // Uso de un objeto Comparator con el algoritmo sort.





{

private static final String palos[] =

{ "Corazones", "Diamantes", "Bastos", "Espadas" };

// imprime los elementos del objeto List


{

List< String > lista = Arrays.asList( palos ); // crea objeto List



// ordena en forma descendente, utilizando un comparador

Collections.sort( lista, Collections.reverseOrder() );


System.out.printf( "Elementos de lista ordenados:\n%s\n", lista );



{

Ordenamiento2 ordenamiento = new Ordenamiento2();

ordenamiento.imprimirElementos();

} // fin de main


5.1.3. Ordenamiento mediante un objeto Comparator

//***************************************************************************************

public class Tiempo2

{

private int hora; // 0 - 23

private int minuto; // 0 - 59

private int segundo; // 0 - 59

// Constructor de Tiempo2 sin argumentos: inicializa cada variable de instancia

// a cero; asegura que los objetos Tiempo2 empiecen en un estado consistente

public Tiempo2()

{

this( 0, 0, 0 ); // invoca al constructor de Tiempo2 con tres argumentos

} // fin del constructor de Tiempo2 sin argumentos

// Constructor de Tiempo2: se suministra hora, minuto y segundo con valor predeterminado de 0

public Tiempo2( int h )

8

{

this( h, 0, 0 ); // invoca al constructor de Tiempo2 con tres argumentos

} // fin del constructor de Tiempo2 con un argumento

// Constructor de Tiempo2: se suministran hora y minuto, segundo con valor predeterminado de 0

public Tiempo2( int h, int m )

{

this( h, m, 0 ); // invoca al constructor de Tiempo2 con tres argumentos

} // fin del constructor de Tiempo2 con dos argumentos

// Constructor de Tiempo2: se suministran hora, minuto y segundo

public Tiempo2( int h, int m, int s )

{

establecerTiempo( h, m, s ); // invoca a establecerTiempo para validar el tiempo

} // fin del constructor de Tiempo2 con tres argumentos

// Constructor de Tiempo2: se suministra otro objeto Tiempo2

public Tiempo2( Tiempo2 tiempo )

{

// invoca al constructor de Tiempo2 con tres argumentos

this( tiempo.obtenerHora(), tiempo.obtenerMinuto(), tiempo.obtenerSegundo() );

} // fin del constructor de Tiempo2 con un objeto Tiempo2 como argumento

// Métodos "establecer"

// establece un nuevo valor de tiempo usando la hora universal; asegura que

// los datos sean consistentes, estableciendo los valores inválidos en cero

public void establecerTiempo( int h, int m, int s )

{

establecerHora( h ); // establece la hora

establecerMinuto( m ); // establece el minuto

establecerSegundo( s ); // establece el segundo

} // fin del método establecerTiempo

// valida y establece la hora

public void establecerHora( int h )

{

hora = ( ( h >= 0 && h < 24 ) ? h : 0 );

} // fin del método establecerHora

// valida y establece el minuto

public void establecerMinuto( int m )

{

minuto = ( ( m >= 0 && m < 60 ) ? m : 0 );

} // fin del método establecerMinuto

// valida y establece el segundo

public void establecerSegundo( int s )

{

segundo = ( ( s >= 0 && s < 60 ) ? s : 0 );

} // fin del método establecerSegundo

// Métodos "obtener"

// obtiene el valor de la hora

public int obtenerHora()

{

return hora;

} // fin del método obtenerHora

// obtiene el valor del minuto

public int obtenerMinuto()

{

return minuto;

} // fin del método obtenerMinuto

// obtiene el valor del segundo

public int obtenerSegundo()

{

return segundo;

} // fin del método obtenerSegundo

// convierte a String en formato de hora universal (HH:MM:SS)

public String aStringUniversal()

{

return String.format(

"%02d:%02d:%02d", obtenerHora(), obtenerMinuto(), obtenerSegundo() );

} // fin del método aStringUniversal

// convierte a String en formato de hora estándar (H:MM:SS AM o PM)

public String toString()

{

return String.format( "%d:%02d:%02d %s",

( (obtenerHora() == 0 || obtenerHora() == 12) ? 12 : obtenerHora() % 12 ),

9

obtenerMinuto(), obtenerSegundo(), ( obtenerHora() < 12 ? "AM" : "PM" ) );

} // fin del método toString

} // fin de la clase Tiempo2

//***************************************************************************************

// Clase Comparator personalizada que compara dos objetos Tiempo2.

import java.util.Comparator;

public class ComparadorTiempo implements Comparator< Tiempo2 >

{

public int compare( Tiempo2 tiempo1, Tiempo2 tiempo2 )

{

int compararHora = tiempo1.obtenerHora() - tiempo2.obtenerHora(); // compara la hora

// evalúa la hora primero

if ( compararHora != 0 )

return compararHora;

int comparaMinuto =

tiempo1.obtenerMinuto() - tiempo2.obtenerMinuto(); // compara el minuto

// después evalúa el minuto

if ( comparaMinuto != 0 )

return comparaMinuto;

int compararSegundo =

tiempo1.obtenerSegundo() - tiempo2.obtenerSegundo(); // compara el segundo

return compararSegundo; // devuelve el resultado de comparar los segundos

} // fin del método compare

} // fin de la clase ComparadorTiempo

//***************************************************************************************

// Ordena una lista usando la clase Comparator personalizada ComparadorTiempo.





{


{

List< Tiempo2 > lista = new ArrayList< Tiempo2 >(); // crea objeto List

lista.add( new Tiempo2( 6, 24, 34 ) );







// ordena usando un comparador

Collections.sort( lista, new ComparadorTiempo() );


System.out.printf( "Elementos de la lista ordenados:\n%s\n", lista );



{

Ordenamiento3 ordenamiento3 = new Ordenamiento3();

ordenamiento3.imprimirElementos();

} // fin de main


5.2. Algoritmo Shuffle // Uso del algoritmo shuffle.




// clase para representar un objeto Carta en un mazo de cartas

class Carta

{

public static enum Cara { As, Dos, Tres, Cuatro, Cinco, Seis,

Siete, Ocho, Nueve, Diez, Joto, Quina, Rey };

public static enum Palo { Bastos, Diamantes, Corazones, Espadas };

10

private final Cara cara; // cara de la carta

private final Palo palo; // palo de la carta

// constructor con dos argumentos

public Carta( Cara caraCarta, Palo paloCarta )

{

cara = caraCarta; // inicializa la cara de la carta

palo = paloCarta; // inicializa el palo de la carta

} // fin del constructor de Carta con dos argumentos

// devuelve la cara de la carta

public Cara obtenerCara()

{

return cara;

} // fin del método obtenerCara

// devuelve el palo de la Carta

public Palo obtenerPalo()

{

return palo;

} // fin del método obtenerPalo

// devuelve la representación String de la Carta

public String toString()

{

return String.format( "%s de %s", cara, palo );

} // fin del método toString

} // fin de la clase Carta

// declaración de la clase MazoDeCartas

public class MazoDeCartas

{

private List< Carta > lista; // declara objeto List que almacenará los objetos Carta

// establece mazo de objetos Carta y baraja

public MazoDeCartas()

{

Carta[] mazo = new Carta[ 52 ];

int cuenta = 0; // número de cartas

// llena el mazo con objetos Carta

for ( Carta.Palo palo : Carta.Palo.values() )

{

for ( Carta.Cara cara : Carta.Cara.values() )

{

mazo[ cuenta ] = new Carta( cara, palo );

cuenta++;

} // fin de for

} // fin de for

lista = Arrays.asList( mazo ); // obtiene objeto List

Collections.shuffle( lista ); // baraja el mazo

} // fin del constructor de MazoDeCartas

// imprime el mazo

public void imprimirCartas()

{

// muestra las 52 cartas en dos columnas

for ( int i = 0; i < lista.size(); i++ )

System.out.printf( "%-20s%s", lista.get( i ),

( ( i + 1 ) % 2 == 0 ) ? "\n" : "" );

} // fin del método imprimirCartas


{

MazoDeCartas cartas = new MazoDeCartas();

cartas.imprimirCartas();

} // fin de main

} // fin de la clase MazoDeCartas

5.3. Algoritmos reverse, fill, copy, max y min // Uso de los algoritmos reverse, fill, copy, min y max.




public class Algoritmos1

{

private Character[] letras = { 'P', 'C', 'M' };

private Character[] copiaLetras;

private List< Character > lista;

11

private List< Character > copiaLista;

// crea un objeto List y lo manipula con los métodos de Collections

public Algoritmos1()

{

lista = Arrays.asList( letras ); // obtiene el objeto List

copiaLetras = new Character[ 3 ];

copiaLista = Arrays.asList( copiaLetras ); // vista List de copiaLetras

System.out.println( "Lista inicial: " );

imprimir( lista );

Collections.reverse( lista ); // invierte el orden

System.out.println( "\nDespues de llamar a reverse: " );

imprimir( lista );

Collections.copy( copiaLista, lista ); // copia el objeto List

System.out.println( "\nDespues de copy: " );

imprimir( copiaLista );

Collections.fill( lista, 'R' ); // llena la lista con Rs

System.out.println( "\nDespues de llamar a fill: " );

imprimir( lista );

} // fin del constructor de Algoritmos1

// imprime la información del objeto List

private void imprimir( List< Character > refLista )

{

System.out.print( "La lista es: " );

for ( Character elemento : refLista )

System.out.printf( "%s ", elemento );

System.out.printf( "\nMax: %s", Collections.max( refLista ) );

System.out.printf( " Min: %s\n", Collections.min( refLista ) );

} // fin del método imprimir


{

new Algoritmos1();

} // fin de main

} // fin de la clase Algoritmos1

5.4. Algoritmo bynarySearch // Uso del algoritmo binarySearch.





public class PruebaBusquedaBinaria

{

private static final String colores[] = { "rojo", "blanco",

"azul", "negro", "amarillo", "morado", "carne", "rosa" };

private List< String > lista; // referencia ArrayList

// crea, ordena e imprime la lista

public PruebaBusquedaBinaria()

{

lista = new ArrayList< String >( Arrays.asList( colores ) );

Collections.sort( lista ); // ordena el objeto ArrayList

System.out.printf( "ArrayList ordenado: %s\n", lista );

} // fin del constructor de PruebaBusquedaBinaria

// busca varios valores en la lista

private void buscar()

{

imprimirResultadosBusqueda( colores[ 3 ] ); // primer elemento

imprimirResultadosBusqueda( colores[ 0 ] ); // elemento medio

imprimirResultadosBusqueda( colores[ 7 ] ); // último elemento

imprimirResultadosBusqueda( "aqua" ); // debajo del menor

imprimirResultadosBusqueda( "gris" ); // no existe

imprimirResultadosBusqueda( "verdeazulado" ); // no existe

} // fin del método buscar

// método ayudante para realizar búsquedas

private void imprimirResultadosBusqueda( String clave )

{

int resultado = 0;

12

System.out.printf( "\nBuscando: %s\n", clave );

resultado = Collections.binarySearch( lista, clave );

if ( resultado >= 0 )

System.out.printf( "Se encontro en el indice %d\n", resultado );

else

System.out.printf( "No se encontro (%d)\n",resultado );

} // fin del método imprimirResultadosBusqueda


{

PruebaBusquedaBinaria pruebaBusquedaBinaria = new PruebaBusquedaBinaria();

pruebaBusquedaBinaria.buscar();

} // fin de main

} // fin de la clase PruebaBusquedaBinaria

5.5. Algoritmos addAll, frequency y disjoint // Uso de los algoritmos addAll, frequency y disjoint.


import java.util.Vector;



public class Algoritmos2

{

private String[] colores = { "rojo", "blanco", "amarillo", "azul" };

private List< String > lista;

private Vector< String > vector = new Vector< String >();

// crea objetos List y Vector

// y los manipula con métodos de Collections

public Algoritmos2()

{

// inicializa lista y vector

lista = Arrays.asList( colores );

vector.add( "negro" );

vector.add( "rojo" );

vector.add( "verde" );

System.out.println( "Antes de addAll, el vector contiene:" );

// muesta los elementos en el vector

for ( String s : vector )

System.out.printf( "%s ", s );

// agrega los elementos en colores a lista

Collections.addAll( vector, colores );

System.out.println( "\n\nDespues de addAll, el vector contiene: " );

// muestra los elementos en el vector

for ( String s : vector )


// obtiene la frecuencia de "rojo"

int frecuencia = Collections.frequency( vector, "rojo" );

System.out.printf(

"\n\nFrecuencia de rojo en el vector: %d\n", frecuencia );

// comprueba si lista y vector tienen elementos en común

boolean desunion = Collections.disjoint( lista, vector );

System.out.printf( "\nlista y vector %s elementos en comun\n",

( desunion ? "no tienen" : "tienen" ) );

} // fin del constructor de Algoritmos2


{

new Algoritmos2();

} // fin de main

} // fin de la clase Algorit

6. Clase Stack // Programa para probar la clase java.util.Stack.

import java.util.Stack;

import java.util.EmptyStackException;

13

public class PruebaStack

{

public PruebaStack()

{

Stack< Number > pila = new Stack< Number >();

// crea números para almacenarlos en la pila

Long numeroLong = 12L;

Integer numeroInt = 34567;

Float numeroFloat = 1.0F;

Double numeroDouble = 1234.5678;

// usa el método push

pila.push( numeroLong ); // mete un long

imprimirPila( pila );

pila.push( numeroInt ); // mete un int


pila.push( numeroFloat ); // mete un float


pila.push( numeroDouble ); // mete un double


// elimina los elementos de la pila

try

{

Number objetoEliminado = null;

// saca elementos de la pila

while ( true )

{

objetoEliminado = pila.pop(); // usa el método pop

System.out.printf( "%s se saco\n", objetoEliminado );


} // fin de while

} // fin de try

catch ( EmptyStackException emptyStackException )

{

emptyStackException.printStackTrace();

} // fin de catch

} // fin del constructor de PruebaStack

private void imprimirPila( Stack< Number > pila )

{

if ( pila.isEmpty() )

System.out.print( "la pila esta vacia\n\n" ); // la pila está vacía

else // la pila no está vacía

{

System.out.print( "la pila contiene: " );

// itera a través de los elementos

for ( Number numero : pila )

System.out.printf( "%s ", numero );

System.out.print( "(superior) \n\n" ); // indica la parte superior de la pila

} // fin de else

} // fin del método imprimirPila


{

new PruebaStack();

} // fin de main

} // fin de la clase PruebaStack

6.1. Clase PriorityQueue e interfaz Queue // Programa de prueba de la clase PriorityQueue de la biblioteca estándar.

import java.util.PriorityQueue;

public class PruebaPriorityQueue

{


{

// cola con capacidad de 11

PriorityQueue< Double > cola = new PriorityQueue< Double >();

// inserta elements en la cola

cola.offer( 3.2 );

cola.offer( 9.8 );

cola.offer( 5.4 );

System.out.print( "Sondeando de cola: " );

14

// muestra los elementos en la cola

while ( cola.size() > 0 )

{

System.out.printf( "%.1f ", cola.peek() ); // ve el elemento superior

cola.poll(); // elimina el elemento superior

} // fin de while

} // fin de main

} // fin de la clase PruebaPriorityQueue

7. Conjuntos

7.1. Conjuntos con HashSet // Uso de un objeto HashSet para eliminar duplicados.



import java.util.HashSet;

import java.util.Set;

import java.util.Collection;

public class PruebaSet

{

private static final String colores[] = { "rojo", "blanco", "azul",

"verde", "gris", "naranja", "carne", "blanco", "cyan",

"durazno", "gris", "naranja" };

// crea e imprime un objeto ArrayList

public PruebaSet()

{

List< String > lista = Arrays.asList( colores );

System.out.printf( "ArrayList: %s\n", lista );

imprimirSinDuplicados( lista );

} // fin del constructor de PruebaSet

// crea conjunto a partir del arreglo para eliminar duplicados

private void imprimirSinDuplicados( Collection< String > coleccion )

{

// crea un objeto HashSet

Set< String > conjunto = new HashSet< String >( coleccion );

System.out.println( "\nLos valores sin duplicados son: " );

for ( String s : conjunto )



} // fin del método imprimirSinDuplicados


{

new PruebaSet();

} // fin de main

} // fin de la clase PruebaSet

7.2. Conjuntos con SortedSet y TreeSet // Uso de TreeSet y SortedSet.


import java.util.SortedSet;

import java.util.TreeSet;

public class PruebaSortedSet

{

private static final String nombres[] = { "amarillo", "verde",

"negro", "carne", "gris", "blanco", "naranja", "rojo", "verde" };

// crea un conjunto ordenado con TreeSet, y después lo manipula

public PruebaSortedSet()

{

// crea objeto TreeSet

SortedSet< String > arbol =

new TreeSet< String >( Arrays.asList( nombres ) );

System.out.println( "conjunto ordenado: " );

imprimirConjunto( arbol ); // imprime el contenido del arbol

// obtiene subconjunto mediante headSet, con base en "naranja"

15

System.out.print( "\nheadSet (\"naranja\"): " );

imprimirConjunto( arbol.headSet( "naranja" ) );

// obtiene subconjunto mediante tailSet, con base en "naranja"

System.out.print( "tailSet (\"naranja\"): " );

imprimirConjunto( arbol.tailSet( "naranja" ) );

// obtiene los elementos primero y último

System.out.printf( "primero: %s\n", arbol.first() );

System.out.printf( "ultimo : %s\n", arbol.last() );

} // fin del constructor de PruebaSortedSet

// imprime el conjunto en pantalla

private void imprimirConjunto( SortedSet< String > conjunto )

{

for ( String s : conjunto )

System.out.print( s + " " );


} // fin del método imprimirConjunto


{

new PruebaSortedSet();

} // fin de main

} // fin de la clase PruebaSortedSet

8. Mapas

// Programa que cuenta el número de ocurrencias de cada palabra en una cadena

import java.util.StringTokenizer;

import java.util.Map;

import java.util.HashMap;


import java.util.TreeSet;

import java.util.Scanner;

public class ConteoTipoPalabras

{

private Map< String, Integer > mapa;

private Scanner scanner;

public ConteoTipoPalabras()

{

mapa = new HashMap< String, Integer >(); // crea objeto HashMap

scanner = new Scanner( System.in ); // crea objeto scanner

crearMap(); // crea un mapa con base en la entrada del usuario

mostrarMap(); // muestra el contenido del mapa

} // fin del constructor de ConteoTipoPalabras

// crea mapa a partir de la entrada del usuario

private void crearMap()

{

System.out.println( "Escriba una cadena:" ); // pide la entrada del usuario

String entrada = scanner.nextLine();

// crea objeto StringTokenizer para los datos de entrada

StringTokenizer tokenizer = new StringTokenizer( entrada );

// procesamiento del texto de entrada

while ( tokenizer.hasMoreTokens() ) // mientras haya más entrada

{

String palabra = tokenizer.nextToken().toLowerCase(); // obtiene una palabra

// si el mapa contiene la palabra

if ( mapa.containsKey( palabra ) ) // esta la palabra en el mapa?

{

int cuenta = mapa.get( palabra ); // obtiene la cuenta actual

mapa.put( palabra, cuenta + 1 ); // incrementa la cuenta

} // fin de if

else

mapa.put( palabra, 1 ); // agrega una nueva palabra con una cuenta de 1 al mapa

} // fin de while

} // fin del método crearMap

// muestra el contenido del mapa

private void mostrarMap()

{

16

Set< String > claves = mapa.keySet(); // obtiene las claves

// ordena las claves

TreeSet< String > clavesOrdenadas = new TreeSet< String >( claves );

System.out.println( "El mapa contiene:\nClave\t\tValor" );

// genera la salida para cada clave en el mapa

for ( String clave : clavesOrdenadas )

System.out.printf( "%-10s%10s\n", clave, mapa.get( clave ) );

System.out.printf(

"\nsize:%d\nisEmpty:%b\n", mapa.size(), mapa.isEmpty() );

} // fin del método mostrarMap


{

new ConteoTipoPalabras();

} // fin de main

} // fin de la clase ConteoTipoPalabras

9. Clase Properties

9.1. Archivo props.dat #Propiedades de ejemplo

#Mon Sep 17 16:22:53 CDT 2007

anchura=200

color=rojo

9.2. Archivo PruebaProperties.java // Demuestra la clase Properties del paquete java.util.

import java.io.FileOutputStream;

import java.io.FileInputStream;

import java.io.IOException;

import java.util.Properties;


public class PruebaProperties

{

private Properties tabla;

// establece la GUI para probar la tabla Properties

public PruebaProperties()

{

tabla = new Properties(); // crea la tabla Properties

// establece las propiedades

tabla.setProperty( "color", "azul" );

tabla.setProperty( "anchura", "200" );

System.out.println( "Despues de establecer propiedades" );

listarPropiedades(); // muestra los valores de las propiedades

// reemplaza el valor de una propiedad

tabla.setProperty( "color", "rojo" );

System.out.println( "Despues de reemplazar propiedades" );


guardarPropiedades(); // guarda las propiedades

tabla.clear(); // vacia la tabla

System.out.println( "Despues de borrar propiedades" );


cargarPropiedades(); // carga las propiedades

// obtiene el valor de la propiedad color

Object valor = tabla.getProperty( "color" );

// comprueba si el valor está en la tabla

if ( valor != null )

System.out.printf( "El valor de la propiedad color es %s\n", valor );

else

System.out.println( "La propiedad color no está en la tabla" );

17

} // fin del constructor de PruebaProperties

// guarda las propiedades en un archivo

public void guardarPropiedades()

{

// guarda el contenido de la tabla

try

{

FileOutputStream salida = new FileOutputStream( "props.dat" );

tabla.store( salida, "Propiedades de ejemplo" ); // guarda las propiedades

salida.close();

System.out.println( "Despues de guardar las propiedades" );


} // fin de try

catch ( IOException ioException )

{

ioException.printStackTrace();

} // fin de catch

} // fin del método guardarPropiedades

// carga las propiedades de un archivo

public void cargarPropiedades()

{

// carga el contenido de la tabla

try

{

FileInputStream entrada = new FileInputStream( "props.dat" );

tabla.load( entrada ); // carga las propiedades

entrada.close();

System.out.println( "Después de cargar las propiedades" );


} // fin de try

catch ( IOException ioException )

{

ioException.printStackTrace();

} // fin de catch

} // fin del método cargarPropiedades

// imprime los valores de las propiedades

public void listarPropiedades()

{

Set< Object > claves = tabla.keySet(); // obtiene los nombres de las propiedades

// imprime los pares nombre/valor

for ( Object clave : claves )

{

System.out.printf(

"%s\t%s\n", clave, tabla.getProperty( ( String ) clave ) );

} // fin de for


} // fin del método listarPropiedades


{

new PruebaProperties();

} // fin de main

} // fin de la clase PruebaProperties

laboratorio de colecciones en java

Documents