Post on 15-Feb-2015
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.printf( "%d ", valorInt );
System.out.print( "\ncopiaArregloInt: " );
for ( int valorInt : copiaArregloInt )
System.out.printf( "%d ", valorInt );
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
public static void main( String args[] )
{
new PruebaCollection();
} // fin de main
} // fin de la clase PruebaCollection
3.2. LinkedList // Uso de objetos LinkList.
import java.util.List;
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
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 mayúsculas
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 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
public static void main( String args[] )
{
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;
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" };
6
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 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\"" );
imprimirVector( vector ); // imprime el vector
// ¿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
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;
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
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 de un objeto Comparator con el algoritmo sort.
import java.util.List;
import java.util.Arrays;
import 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 método 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 )
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.
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( new Tiempo2( 6, 24, 34 ) );
lista.add( new Tiempo2( 18, 14, 58 ) );
lista.add( new Tiempo2( 6, 05, 34 ) );
lista.add( new Tiempo2( 12, 14, 58 ) );
lista.add( new 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 método imprimirElementos
public static void main( String args[] )
{
Ordenamiento3 ordenamiento3 = new Ordenamiento3();
ordenamiento3.imprimirElementos();
} // fin de main
} // fin de la clase Ordenamiento3
5.2. Algoritmo Shuffle // Uso del algoritmo shuffle.
import java.util.List;
import java.util.Arrays;
import 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 };
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
public static void main( String args[] )
{
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.
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
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
public static void main( String args[] )
{
new Algoritmos1();
} // fin de main
} // fin de la clase Algoritmos1
5.4. Algoritmo bynarySearch // Uso del algoritmo binarySearch.
import java.util.List;
import java.util.Arrays;
import java.util.Collections;
import 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 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
public static void main( String args[] )
{
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.List;
import java.util.Vector;
import java.util.Arrays;
import 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 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 )
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 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
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;
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
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 método 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á 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
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 estándar.
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: " );
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.List;
import java.util.Arrays;
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 )
System.out.printf( "%s ", s );
System.out.println();
} // fin del método imprimirSinDuplicados
public static void main( String args[] )
{
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.Arrays;
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 + " " );
System.out.println();
} // fin del método imprimirConjunto
public static void main( String args[] )
{
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.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 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
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" );
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" );
listarPropiedades(); // muestra los valores de 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" );
listarPropiedades(); // muestra los valores de 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
System.out.println();
} // fin del método listarPropiedades
public static void main( String args[] )
{
new PruebaProperties();
} // fin de main
} // fin de la clase PruebaProperties