Laboratorio de Colecciones en Java

Una coleccin es una estructura de datos que puede guardar referencia a otros objetos. Las ms importantes son Vector, Stack, Dictionary, HashTable y la interfaz Enumeration para recorrer los elementos de una coleccin. Existen tres tipos generales de colecciones: conjuntos, listas y mapas; las interfaces Set, List y Map describen las caractersticas de estos. La interfaz Collection especifica el comportamiento comn de las colecciones.

Instrucciones (Trabajo a ser realizado en grupos de dos personas) a) Ejecute cada uno de los programas considerados en la siguiente prctica. b) Comente en una hoja aparte el resultado de cada programa. c) Para cada programa: comente cada mtodos o clase (relacionados a la interfaz Collection o Collections) usado para cada uno de los programas 1

De preferencia use el siguiente formato: Nombre de programa: nombre y comentario Clase: nombre y comentario (es importante indicar si se implementa alguna interfaz) Mtodo1:nombre y comentario Mtodo2: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.printf( "%d ", valorInt ); System.out.print( "\ncopiaArregloInt: " ); for ( int valorInt : copiaArregloInt ) System.out.printf( "%d ", valorInt ); System.out.println( "\n" ); } // fin del mtodo imprimirArreglos // busca un valor en el arreglo arregloInt public int buscarUnInt( int valor ) { return Arrays.binarySearch( arregloInt, valor ); } // fin del mtodo 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 ? "==" : "!=" ) );

} // fin del mtodo 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 raz en la jerarqua de colecciones, a partir de la cual se derivan las interfaces Set, Queue y List. La clase Collections contiene operaciones masivas en una coleccin.

3. Listas
3.1.
// Uso import import import import

ArrayList e Iterator
de la interfaz Collection. java.util.List; java.util.ArrayList; java.util.Collection; 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 )

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 coleccin tenga elementos while ( iterador.hasNext() ) if ( coleccion2.contains( iterador.next() ) ) iterador.remove(); // elimina el color actual } // fin del mtodo eliminarColores public static void main( String args[] ) { new PruebaCollection(); } // fin de main } // fin de la clase PruebaCollection

3.2.
// Uso import import import

LinkedList
de objetos LinkList. java.util.List; java.util.LinkedList; 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 for ( String color : colores ) 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 maysculas imprimirLista( lista1 ); // imprime los elementos de lista1 System.out.print( "\nEliminando elementos 4 a 6..." ); eliminarElementos( lista1, 4, 7 ); // elimina los elementos 4 a 7 de la lista imprimirLista( lista1 ); // imprime los elementos de lista1 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 mtodo imprimirLista // localiza los objetos String y los convierte a maysculas private void convertirCadenasAMayusculas( List< String > lista ) { ListIterator< String > iterador = lista.listIterator();

while ( iterador.hasNext() ) { String color = iterador.next(); // obtiene elemento iterador.set( color.toUpperCase() ); // convierte a maysculas } // fin de while } // fin del mtodo convertirCadenasAMayusculas // obtiene sublista y utiliza el mtodo 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 mtodo 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 mtodo imprimirListaInversa public static void main( String args[] ) { new PruebaList(); } // fin de main } // fin de la clase PruebaList

3.3.

Arreglo como una coleccin List

// Uso del mtodo toArray. import java.util.LinkedList; import java.util.Arrays; 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: " ); for ( String color : colores ) System.out.println( color ); } // fin del constructor de UsoToArray public static void main( String args[] ) { 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" };

public PruebaVector() { Vector< String > vector = new Vector< String >(); imprimirVector( vector ); // imprime el vector // agrega elementos al vector for ( String color : colores ) vector.add( color ); imprimirVector( vector ); // imprime el vector // 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 excepcin si el vector est vaco 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\"" ); imprimirVector( vector ); // imprime el vector // el vector contiene "rojo" despus de la operacin de eliminacin? 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 tamao 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 vaco else // itera a travs 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 mtodo imprimirVector public static void main( String args[] ) { 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. import java.util.List; import java.util.Arrays;

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 mtodo imprimirElementos public static void main( String args[] ) { Ordenamiento1 orden1 = new Ordenamiento1(); orden1.imprimirElementos(); } // fin de main } // fin de la clase Ordenamiento1

5.1.2. Ordenamiento descendente

// Uso import import import de un objeto Comparator con el algoritmo sort. java.util.List; java.util.Arrays; java.util.Collections;

public class Ordenamiento2 { private static final String palos[] = { "Corazones", "Diamantes", "Bastos", "Espadas" }; // imprime los elementos del objeto List public void imprimirElementos() { List< String > lista = Arrays.asList( palos ); // crea objeto List // imprime los elementos del objeto List System.out.printf( "Elementos del arreglo desordenados:\n%s\n", lista ); // ordena en forma descendente, utilizando un comparador Collections.sort( lista, Collections.reverseOrder() ); // imprime los elementos del objeto List System.out.printf( "Elementos de lista ordenados:\n%s\n", lista ); } // fin del mtodo imprimirElementos public static void main( String args[] ) { Ordenamiento2 ordenamiento = new Ordenamiento2(); ordenamiento.imprimirElementos(); } // fin de main } // fin de la clase Ordenamiento2

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 )

{ 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 // Mtodos "establecer" // establece un nuevo valor de tiempo usando la hora universal; asegura que // los datos sean consistentes, estableciendo los valores invlidos 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 mtodo establecerTiempo // valida y establece la hora public void establecerHora( int h ) { hora = ( ( h >= 0 && h < 24 ) ? h : 0 ); } // fin del mtodo establecerHora // valida y establece el minuto public void establecerMinuto( int m ) { minuto = ( ( m >= 0 && m < 60 ) ? m : 0 ); } // fin del mtodo establecerMinuto // valida y establece el segundo public void establecerSegundo( int s ) { segundo = ( ( s >= 0 && s < 60 ) ? s : 0 ); } // fin del mtodo establecerSegundo // Mtodos "obtener" // obtiene el valor de la hora public int obtenerHora() { return hora; } // fin del mtodo obtenerHora // obtiene el valor del minuto public int obtenerMinuto() { return minuto; } // fin del mtodo obtenerMinuto // obtiene el valor del segundo public int obtenerSegundo() { return segundo; } // fin del mtodo 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 mtodo aStringUniversal // convierte a String en formato de hora estndar (H:MM:SS AM o PM) public String toString() { return String.format( "%d:%02d:%02d %s", ( (obtenerHora() == 0 || obtenerHora() == 12) ? 12 : obtenerHora() % 12 ),

obtenerMinuto(), obtenerSegundo(), ( obtenerHora() < 12 ? "AM" : "PM" ) ); } // fin del mtodo 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 // evala la hora primero if ( compararHora != 0 ) return compararHora; int comparaMinuto = tiempo1.obtenerMinuto() - tiempo2.obtenerMinuto(); // compara el minuto // despus evala 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 mtodo compare } // fin de la clase ComparadorTiempo //*************************************************************************************** // Ordena una lista usando la clase Comparator personalizada ComparadorTiempo. import java.util.List; import java.util.ArrayList; import java.util.Collections; public class Ordenamiento3 { public void imprimirElementos() { List< Tiempo2 > lista = new ArrayList< Tiempo2 >(); // crea objeto List lista.add( lista.add( lista.add( lista.add( lista.add( new new new new new Tiempo2( 6, 24, 34 ) Tiempo2( 18, 14, 58 ) Tiempo2( 6, 05, 34 ) Tiempo2( 12, 14, 58 ) Tiempo2( 6, 24, 22 ) ); ); ); ); );

// imprime los elementos del objeto List System.out.printf( "Elementos del arreglo desordenados:\n%s\n", lista ); // ordena usando un comparador Collections.sort( lista, new ComparadorTiempo() ); // imprime los elementos del objeto List System.out.printf( "Elementos de la lista ordenados:\n%s\n", lista ); } // fin del mtodo imprimirElementos public static void main( String args[] ) { Ordenamiento3 ordenamiento3 = new Ordenamiento3(); ordenamiento3.imprimirElementos(); } // fin de main } // fin de la clase Ordenamiento3

5.2.
// Uso import import import

Algoritmo Shuffle
del algoritmo shuffle. java.util.List; java.util.Arrays; java.util.Collections;

// 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 };

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 mtodo obtenerCara // devuelve el palo de la Carta public Palo obtenerPalo() { return palo; } // fin del mtodo obtenerPalo // devuelve la representacin String de la Carta public String toString() { return String.format( "%s de %s", cara, palo ); } // fin del mtodo toString } // fin de la clase Carta // declaracin 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; // nmero 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 mtodo imprimirCartas public static void main( String args[] ) { MazoDeCartas cartas = new MazoDeCartas(); cartas.imprimirCartas(); } // fin de main } // fin de la clase MazoDeCartas

5.3.
// Uso import import import

Algoritmos reverse, fill, copy, max y min

de los algoritmos reverse, fill, copy, min y max. java.util.List; java.util.Arrays; java.util.Collections;

public class Algoritmos1 { private Character[] letras = { 'P', 'C', 'M' }; private Character[] copiaLetras; private List< Character > lista;

10

private List< Character > copiaLista; // crea un objeto List y lo manipula con los mtodos 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 informacin 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 mtodo imprimir public static void main( String args[] ) { new Algoritmos1(); } // fin de main } // fin de la clase Algoritmos1

5.4.
// Uso import import import import

Algoritmo bynarySearch
del algoritmo binarySearch. java.util.List; java.util.Arrays; java.util.Collections; java.util.ArrayList;

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 mtodo buscar // mtodo ayudante para realizar bsquedas private void imprimirResultadosBusqueda( String clave ) { int resultado = 0;

11

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 mtodo imprimirResultadosBusqueda public static void main( String args[] ) { PruebaBusquedaBinaria pruebaBusquedaBinaria = new PruebaBusquedaBinaria(); pruebaBusquedaBinaria.buscar(); } // fin de main } // fin de la clase PruebaBusquedaBinaria

5.5.
// Uso import import import import

Algoritmos addAll, frequency y disjoint

de los algoritmos addAll, frequency y disjoint. java.util.List; java.util.Vector; java.util.Arrays; java.util.Collections;

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 mtodos 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 ) System.out.printf( "%s ", s ); // 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 comn 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 public static void main( String args[] ) { 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;

12

public class PruebaStack { public PruebaStack() { Stack< Number > pila = new Stack< Number >(); // crea nmeros para almacenarlos en la pila Long numeroLong = 12L; Integer numeroInt = 34567; Float numeroFloat = 1.0F; Double numeroDouble = 1234.5678; // usa el mtodo push pila.push( numeroLong ); // mete un long imprimirPila( pila ); pila.push( numeroInt ); // mete un int imprimirPila( pila ); pila.push( numeroFloat ); // mete un float imprimirPila( pila ); pila.push( numeroDouble ); // mete un double imprimirPila( pila ); // elimina los elementos de la pila try { Number objetoEliminado = null; // saca elementos de la pila while ( true ) { objetoEliminado = pila.pop(); // usa el mtodo pop System.out.printf( "%s se saco\n", objetoEliminado ); imprimirPila( pila ); } // 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 vaca else // la pila no est vaca { System.out.print( "la pila contiene: " ); // itera a travs 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 mtodo imprimirPila public static void main( String args[] ) { 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 estndar. import java.util.PriorityQueue; public class PruebaPriorityQueue { public static void main( String args[] ) { // 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: " );

13

// 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.
// Uso import import import import import

Conjuntos con HashSet

de un objeto HashSet para eliminar duplicados. java.util.List; java.util.Arrays; java.util.HashSet; java.util.Set; 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 ) System.out.printf( "%s ", s ); System.out.println(); } // fin del mtodo imprimirSinDuplicados public static void main( String args[] ) { new PruebaSet(); } // fin de main } // fin de la clase PruebaSet

7.2.
// Uso import import import

Conjuntos con SortedSet y TreeSet

de TreeSet y SortedSet. java.util.Arrays; java.util.SortedSet; 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 despus 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"

14

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 + " " ); System.out.println(); } // fin del mtodo imprimirConjunto public static void main( String args[] ) { new PruebaSortedSet(); } // fin de main } // fin de la clase PruebaSortedSet

8. Mapas
// Programa que cuenta el nmero de ocurrencias de cada palabra en una cadena import java.util.StringTokenizer; import java.util.Map; import java.util.HashMap; import java.util.Set; 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 ms 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 mtodo crearMap // muestra el contenido del mapa private void mostrarMap() {

15

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 mtodo mostrarMap public static void main( String args[] ) { 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; import java.util.Set; 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" ); listarPropiedades(); // muestra los valores de las propiedades guardarPropiedades(); // guarda las propiedades tabla.clear(); // vacia la tabla System.out.println( "Despues de borrar propiedades" ); listarPropiedades(); // muestra los valores de las 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" );

16

} // 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" ); listarPropiedades(); // muestra los valores de las propiedades } // fin de try catch ( IOException ioException ) { ioException.printStackTrace(); } // fin de catch } // fin del mtodo 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( "Despus de cargar las propiedades" ); listarPropiedades(); // muestra los valores de las propiedades } // fin de try catch ( IOException ioException ) { ioException.printStackTrace(); } // fin de catch } // fin del mtodo 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 System.out.println(); } // fin del mtodo listarPropiedades public static void main( String args[] ) { new PruebaProperties(); } // fin de main } // fin de la clase PruebaProperties

17