Clases Java

Java tiene matrices para almacenar grupos de datos de tipo similar, que son muy útiles para modelos simples de acceso a datos. Sin embargo, las Colecciones o enumeraciones ofrecen una manera más completa y orientada a objetos para almacenar conjuntos de datos de tipo similar. Las Colecciones tienen su propia asignación de memoria y posibilidad de una nueva asignación para ampliarlas. Tienen interfaces de método para su iteración y recorrido. Se pueden indexar mediante algo más complejo y útil que los simples enteros. Hasta el JDK 1.1, las Colecciones parecían estar incorporadas a Java por necesidad de aportar alguna herramienta para el almacenamiento de datos. Pero en el JDK 1.2, se han revisado completamente las Colecciones y ahora el programador dispone de toda la potencia de estas nuevas estructuras de datos, a las cuales se ha hecho referencia en secciones anteriores, a las cuales debe remitirse el lector, aquí solamente se citarán por estar incluidas dentro de las clases base de Java, y muy por encima.

Enumeraciones

Enumeration es un interfaz simple que permite enumerar todos los elementos de cualquier conjunto de objetos. Especifica dos métodos:

Bboolean hasMoreElements()
Object nextElement()

El primer método devuelve true cuando todavía quedan más elementos que extraer y false cuando se han enumerado todos los elementos del conjunto. El segundo método, devuelve una referencia a objeto genérica, cuyo tipo hay que convertir al tipo de clase de la cual el objeto es una instancia.

En el programa de ejemplo, java816.java, se utiliza una clase llamada Coleccion para implementar una enumeración de objetos de tipo Integer, y la clase principal que crea una instancia de Coleccion, itera sobre sus valores e imprime cada uno de ellos. Coleccion no contiene realmente ningún dato; simplemente devuelve la secuencia de enteros que ha construido.

import java.util.Enumeration;

class Coleccion implements Enumeration {
    private int cnt = 0;
    private boolean mas = true;

    public boolean hasMoreElements() {
        return( mas );
        }

    public Object nextElement() {
        cnt++;
        if( cnt > 4 )
            mas = false;

        return( new Integer( cnt ) );
        }
    }

class java816 {
    public static void main( String args[] ) {
        Enumeration enum = new Coleccion();

        while( enum.hasMoreElements() ) {
            System.out.println( enum.nextElement() );
            }
        }
    }

Vector

Un Vector es una matriz ampliable de referencia a objeto. Internamente, un Vector implementa una estrategia de crecimiento para minimizar la reasignación y el espacio desperdiciado. Los objetos se pueden almacenar al final de un Vector utilizando el método addElement() o en un índice dado mediante el método insertElement(). Se puede almacenar una matriz de objetos en un Vector utilizando el método copyInto(). Una vez se ha almacenado un conjunto de objetos en un Vector, se puede utilizar para buscar un elemento en concreto utilizando los métodos contains(), indexOf() o lastIndexOf(). También se puede extraer un objeto de una posición específica de un Vector utilizando los métodos elementAt(), firstElement() y lastElement().

Un Stack, pila, es una subclase de Vector que implementa una pila simple del tipo FIFO (primero en entrar, primero en salir. Además de los métodos estándar de la clase padre, Stack implementa el método push(), que coloca objetos en la parte superior de la pila y el método pop() que retira y devuelve el objeto superior de la pila. También dispone del método peek() para obtener el objeto superior de la pila, pro no retirarlo. El método empty() devolverá true si no hay nada en la pila. El método search() comprobará si existe un objeto en la pila y devolverá el número de llamadas al método pop() que se necesitarán realizar para que dicho objeto se quede en la parte superior de la pila, o –1 si el objeto pasado como parámetro no se encuentra.

El programa java817.java, crea una pila, introduce varios objetos Integer en ella y después los extrae.

import java.util.Stack;
import java.util.EmptyStackException;

class java817 {
    static void hacePush( Stack st,int a ) {
        st.push( new Integer( a ) );
        System.out.println( "push( "+a+" )" );
        System.out.println( "pila: "+st );
        }

    static void hacePop( Stack st ) {
        System.out.print( "pop -> " );
        Integer a = (Integer)st.pop();
        System.out.println( a );
        System.out.println( "pila: "+st );
        }

    public static void main( String args[] ) {
        Stack st = new Stack();
        System.out.println( "pila: "+st );
        hacePush( st,15 );
        hacePush( st,45 );
        hacePush( st,69 );
        hacePop( st );
        hacePop( st );
        hacePop( st );

        try {
            hacePop( st );
        } catch( EmptyStackException e ) {
            System.out.println( "pila vacia" );
               }
        }
    }

A continuación se reproduce la salida de la ejecución de esta demostración del uso de pila. Nótese cómo se captura el gestor de excepciones de EmptyStackException, de manera que se pueda manejar con elegancia un desbordamiento de la pila.

C:\> java java817
pila: []
push( 15 )
pila: [15]
push( 45 )
pila: [15, 45]
push( 69 )
pila: [15, 45, 69]
pop -> 69
pila: [15, 45]
pop -> 45
pila: [15]
pop -> 15
pila: []
pop -> pila vacia

Diccionario

Un Dictionary es una clase abstracta que representa un depósito para almacenar claves/valores. Una clave es un nombre que se utiliza para recuperar un valor más adelante. Dada una clave y un valor, se puede almacenar el valor en un Dictionary con el método put( clave,valor ). Después se puede utilizar get( clave ) para recuperar el valor. Se pueden devolver las claves y valores como una Enumeration utilizando los métodos keys() y elements(). El método size() devuelve el número de parejas clave/valor almacenadas en un diccionario y el método isEmpty() devuelve true cuando no queda ninguna pareja. Se puede utilizar el método remove( clave ) para eliminar una pareja clave/valor.

Una Hashtable, tabla hash, es una implementación concreta de un Dictionary. Se puede utilizar una instancia de Hashtable para almacenar objetos arbitrarios que están indexados por cualquier otro objeto arbitrario. La utilización más habitual de una Hashtable es utilizar un String como clave para almacenar objetos como valores. El ejemplo java818.java, crea una tabla hash para almacenar información acerca del Tutorial.

import java.util.Dictionary;
import java.util.Hashtable;

class java818 {
    public static void main( String args[] ) {
        Hashtable ht = new Hashtable();
        
        ht.put( "titulo","Tutorial de Java" );
        ht.put( "autor","Agustin Froufe" );
        ht.put( "email","froufe@arrakis.es" );
        ht.put( "patria","Spain" );
        ht.put( "edad",new Integer( 31 ) );
        show( ht );
        }

    static void show( Dictionary d ) {
        System.out.println( "Titulo: " + d.get( "titulo" ) );
        System.out.println( "Autor: " + d.get( "autor" ) );
        System.out.println( "E-mail: " + d.get( "email" ) );
        System.out.println( "Pais: " + d.get( "patria" ) );
        System.out.println( "Edad: " + d.get( "edad" ) );
        }
    }

La salida del programa, muestra cómo el método show(), que toma un Dictionary abstracto como parámetro, es capaz de recuperar todos los valores que se han almacenado en el método main().

C:\> java java818
Titulo: Tutorial de Java
Autor: Agustin Froufe
E-mail: froufe@arrakis.es
Pais: Spain
Edad: 31

Home | Anterior | Siguiente | Indice | Correo