Curso JAVA   Unidad 6: "Utilidades"
	www.bit.es - Calendario de cursos - Solicitud de información

Curso Java
Curso Analista Programador entorno Java

Objetivos de la Unidad:

• Conocer las clases envoltorio de los tipos básicos y su utilidad
• Conocer las clases básicas de la gestión de colecciones: Vector, Stack, Hashtable
• Inciso: Noción de atributos estáticos
• Conocer la clase Properties
• Comprender los iteradores en Java: clase Enumeration
• Clase StringTokenizer
• Clase Runtime. Ejecución de comandos del sistema
• Miscelánea: System, Date y Math
• FIN de la parte sobre el lenguaje. Comparación con Smalltalk

1.- Introducción

• Esta unidad presenta una miscelánea de clases.
• Las clases que se verán están en los package java.lang o java.util.

2.- Las clases envoltorio (Wrappers)

• Los tipos básicos de Java (char, int, double, etc) no son objetos de deriven de Object.
• Por lo tanto, ¿qué hacer cuando queramos de un elemento de un Vector querramos que sea un int? (ver EjemploVector2)
• Para ello están las clases envoltorio: Proporcionan un objeto de Java para envolver a un tipo básico y poderlo usarlo como tal.
• La correspondencia entre los tipos primitivos y los envoltorios son:

  boolean ... Boolean
  byte    ... Byte
  char    ... Character
  short   ... Short
  int     ... Integer
  long    ... Long
  float   ... Float
  double  ... Double
  

• Los envoltorios se organizan en la siguiente jerarquía de clases:

  Object
     +---- Number
     |       +---- Byte
     |       +---- Short
     |       +---- Integer
     |       +---- Long
     |       +---- Float
     |       +---- Double
     +---- Boolean
     +---- Character
  

3.- Clase Vector

• Su finalidad es trabajar de un modo lo más similar posible que con un array pero una mayor flexibilidad.
• Se corresponde con las lista enlazadas de C/C++.
• Trabajando con un Vector no se tiene que realizar una reserva de memoria (de una cantidad fijada a priori) previa a su utilización.
• Se expone a continuación un código comparado entre el uso de un array de Object y un Vector:

• public class EjemploArray
  {
    public static void main(String args[])
    {
      // Declaración
      Object x[] = new Object[3];

      // Inicialización
      x[0] = new String("Hola");
      x[1] = "que tal";  // Sin constructor explícito
      x[2] = new StringBuffer("bien");

      // Recorrido
      int n = x.length;
      for (int i = 0; i < n; i++)
      {
        System.out.println(x[i]);
      }
     }
  }

  ---

  import java.util.*;

  public class EjemploVector
  {
    public static void main(String args[])
    {
      // Declaración
      Vector x = new Vector();

      // Inicialización
      x.addElement(new String("Hola"));
      x.addElement("que tal");
      x.addElement(new StringBuffer("bien"));

      // Recorrido
      int n = x.size();
      for (int i = 0; i < n; i++)
      {
        System.out.println(x.elementAt(i));
      }
    }
  }

  ---

• 
  import java.util.*;

  public class EjemploVector2
  {
    public static void main(String args[])
    {
      // Declaración
      Vector x = new Vector();

      // Inicialización
      x.addElement(new Integer(3));
      x.addElement(new Double(4.5));

      // Recorrido
      int n = x.size();
      for (int i = 0; i < n; i++)
      {
        System.out.println(x.elementAt(i)); // println(Object) llama a toString()
      }
    }
  }

  Con el casting (Number)x.elementAt(i) podríamos convertir a cualquier formato numérico (ver la documentación de la clase Number)

• Para obtener el valor primitivo de un Integer hay el método intValue()
• Para obtener el valor primitivo de un Double hay el método doubleValue()

4.- Clase Hashtable

• Una Hashtable es una tabla de dos columnas que relacionan dos Object.
• La columna de la izquierda (arbitraro) está compuesta por las claves y la de la derecha por los objetos identificados por estas claves (elementos).
• En general las claves son referencias a objetos ligeros como String o envoltorios de los tipos básicos.
• Los elementos son referencias a objetos más pesados (ObjGraf pej.)
• La búsqueda por una clave es rápida.
• Ejemplo:
•  

  import java.util.*;

  public class EjemploHashtable
  {
    public static void main(String args[])
    {
      // Declaración
      Hashtable ht = new Hashtable();
      
      ObjGraf obj1 = new Rectangulo(1, 2, 3, 4);  // Se pueden obtener en la Ud3
      ObjGraf obj2 = new Circulo(5, 6, 10);
      ObjGraf obj3 = new Rectangulo(11, 22, 10, 20);
      
      // Inicialización
      ht.put("rect1", obj1);
      ht.put("circ1", obj2);
      ht.put("rect2", obj3);
  

      // Obtención de un elemento de clave conocida
       ObjGraf objg = (ObjGraf) ht.get("circ1");

  
      // Recorrido mediante una Enumeration, que es una implementación del
      // design pattern Iterator incluido en el JDK
         
      Enumeration enum = ht.keys();
      while (enum.hasMoreElements())
      {
       String clave = (String) enum.nextElement();
        ObjGraf valor = (ObjGraf) ht.get(clave);
        System.out.println(" Area de : " + clave + " = " + valor.area());
      }
    }
  }

Inciso: Noción de atributos estáticos

Supongamos que queremos manejar a los objetos gráficos mediante un identificador que decidimos sea tipo String. Ello permitiría bautizar a los objetos para su uso en tiempo de ejecución, como cuando en un programa de flow-chart se le asigna un nombre a cada objeto. Una solución sería que al crear un objeto automáticamente se insertara en una Hashtable que denominaremos ht la pareja nombre-ref. al objeto tal y como se muestra en el ejemplo anterior. La pregunta es ¿dónde declarar y definir ht?. ht es un atributo de la clase Aplicacion pero resulta que no hay ninguna instancia de la clase Aplicacion. En realidad ht no es atributo de ningún objeto concreto y por lo tanto puede existir al margen de la existencia o no de objetos de una clase. En definitiva la solución es:

public class Aplicacion
{
   static Hashtable ht = new Hashtable();
   ...

El segundo punto a implementar es que el constructor adecuado inserte al objeto en ht. Como es una caracteristica que queremos para todos los ObjGraf se añadirá el constructor ObjGraf. y nombre será una nueva propiedad de todos los ObjGraf por lo que habrá que añadir por lo menos su setter:

protected ObjGraf(int xInicial, int yInicial, String nombre)
{
   setX(xInicial);
   setY(yInicial);
   setNombre(nombre);
   Aplicacion.ht.put(nombre, this);
}

Ello forzará a añadir nuevos constructores para Rectangulo y Circulo que admitan la propiedad nombre. Luego habría que modificar el constructor ObjGraf(int, int) de modo que cree un valor por defecto para la propiedad nombre como "SinNombre", se apoye en el otro constructor (el de mayor detalle) y garantize que todos los objetos ObjGraf estarán en la Hashtable:

protected ObjGraf(int xInicial, int yInicial)
{
   this(xInicial, yInicial, "SinNombre");
}

Finalmente para redondear habría que garantizar que al destruirse un objeto éste fuera eliminado automáticamente de la Hashtable. Para ello hay que sobreescribir el método finalize. Como queremos que sea un comportamiento de todos los ObjGraf sobreescribiremos el de ObjGraf que quedaría como:

protected void finalize() throws Throwable
{
  Aplicacion.ht.remove(nombre);
}

Las propiedades estáticas y los métodos estáticos tienen en común la existencia per-se independientemente de un objeto específico. Los métodos estáticos no reciben el parámetro implícito this. Un método estático corresponde al concepto clásico de función o subrutina (que tampoco recibían ningún parámetro implícito this).

5.- Culturilla:

• Los algoritmos de hash son aquellos que asocian la clave a la situación física del objeto referenciado. Ejemplo salvaje: Un fichero en que cada registro ocupa 100 bytes y establecer que la clave del registro i-ésimo sería 100 * i.
• Ventajas: Velocidad de acceso elevadísima y algoritmo super simple:
• Inconveniente: Para amacenar 10000 elementos haría falta 1Mb, el cual podría sólo estar parcialmete ocupado (despilfarro de espacio en dicso).
• Mejora de los algoritmos de hash: Utilizar una función para reducir el dominio de valores posibles (función de hashing). Pej: Para almacenar 10000 registros prever sólo 100 Kb de espacio.
• En consecuencia puede darse que la función de hashing aplicada a dos o más claves nos lleven a la misma clave reducida de hash. En este caso la primera ocupa el espacio asignado y las otras se ubican en una área de desbordamiento donde sólo hay claves reducidas repetidas.
• En una primera aproximación la búsqueda en el área de desbordamieno puede realizarse secuencialmente.

6.- Clases Properties y Dictionary

• Es una subclase de Hashtable que se particulariza a los casos en que tanto los elementos de la columna de la izquierda como los de la derecha son del tipo String.
• Es el caso típico de las lista de propiedades (ficheros .ini, etc en que se relaciona una variable y su valor.
• La clase Dictionary es la clase base para las Hashtable. Representa la asociación en general de parejas de objetos. Senta la base de implementaciones diferentes a una tablas de hash como por ejemplo algoritmos basados en ficheros o bases de datos.

7.- Interfaz Enumeration

• Está basada en el design pattern "Iterator".
• La idea consiste en proporcionar un sistema único de recorrido por coleciones independientemente de cómo estén origanizadas por dentro.
• El interface Enumeration obliga a implementar dos métodos: hasMoreElements() y nextElement(). La segunda es la que deberá encapsular toda la lógica de saber ir hacia el siguiente elemento de la coleción.
• En la práctica todo recorrido por una colección de la que podamos obtener un iterador (en Java una referencia al tipo Enumeration):

• ...
  Enumeration e = ...funciónQueDevuelveUnEnumeration();

  while (e.hasMoreElements())
  {
      ...
      ... e.nextElement();
      ...
  }
   

• Ejemplo completo del montaje y uso de una Enumeration propia:
  

  import java.util.*;

  public class EjemploEnumeration
  {
     public static void main(String[] args) throws Exception
     {
         Enumeration enum = getColeccion();
         while (enum.hasMoreElements())
         {
             System.out.println(enum.nextElement());
         }
      }

    /**
      * Mezcla un array y una colección en un mismo iterador
      */
    public static Enumeration getColeccion()
      {
         String[] arrayObjetos = {"aaaa", "bbbb", "cccc", "dddd"};
         Vector vectorObjetos = new Vector();
  

      vectorObjetos.addElement("1111");
      vectorObjetos.addElement("2222");
          vectorObjetos.addElement("3333");

      FusionadorArrayVector e = new FusionadorArrayVector(arrayObjetos, vectorObjetos);
      return e;
      }
  }
  
  
  /*******************************************************/
  import java.util.*;

  public class FusionadorArrayVector implements Enumeration
  {
      private Object[] z;
      private Vector v;

    private boolean estoyEnArray = true;
      private boolean heAcabado = false;

    int i = 0;
      int j = 0;

    public FusionadorArrayVector(Object[] z, Vector v)
      {
         this.z = z;
         this.v = v;
      }

    public boolean hasMoreElements()
      {
         return !heAcabado;
      }

    public Object nextElement()
      {
         if (estoyEnArray)
         {
           i++;
           if (i >= z.length)
               estoyEnArray = false;

       return z[i-1];
         }
         else
         {
            j++;
            if (j >= v.size())
                 heAcabado = true;

       return v.elementAt(j-1);
         }
      }
  }

   

8.- Clase StringTokenizer

• Es una clase muy práctica que ayuda en el análisis léxico de expresiones.
• Separa cadenas en tokens según caracteres separadores previamente indicados.
• En general su uso se puede observar con en siguiente ejemplo: 
  
  import java.util.*;

  public class EjemploStringTokenizer
  {
      public static void main(String[] args) throws Exception
      {
          String s = "aaaa;bbbb;cccc;ddd";
          StringTokenizer st = new StringTokenizer(s, ";");
    // StringTokenizer st = new StringTokenizer(s, ";", true);

      while(st.hasMoreTokens())
          {
             System.out.println(st.nextToken());
          }
      }
  }
  
  

• Ejercicio: La cadena expuesta a continuación podría ser generada por un Navegador Web que tuviera un formulario con un submit:
  
  s = "NOM=Joan&TELEFON=9876543&CODI=2273";

  Para obtener una Hashtable con las parejas "<campo>=<valor>":
  

  import java.util.*;

  public class Tokenizador
  {
      public static void main(String[] args) throws Exception
      {
          String tira = "NOM=Joan&TELEFON=9876543&CODI=2273";
           Hashtable stira = getParamsHashtable(tira);

          System.out.println( (String) stira.get("TELEFON"));
       }
   
  
      public static Hashtable getParamsHashtable(String s)
      {
          StringTokenizer st = new StringTokenizer(s, "&");
           Hashtable ht = new Hashtable();

      while (st.hasMoreTokens())
          {
            String token = st.nextToken();
            int posIgual = token.indexOf("=");
            if (posIgual > 0)
            {
               String lvalue = token.substring(0, posIgual);
               String rvalue = token.substring(posIgual + 1);
               ht.put(lvalue, rvalue);
            }
        }
        return ht;
     }
  }

   

9.- Clase Runtime

• La clase Runtime representa al proceso de la propia máquina virtual Java (en Visual J++ sería el jview..
• Cuando main() throws una Exception, ésta es recogida por el objeto Runtime.
• Ofrece diversos servicios como los de obtener la memoria disponible o ejecutar un comando del sistema con el método exec().
• exec() es un método de Runtime:
•  
  Runtime.getRuntime().exec(...);
   
• El método exec() proporciona una valiosa puerta para utilizar Java como herramienta integradora en el mantenimiento de sistemas.
• Notas acerca de exec() en Win 95 y NT:

• • Invoca archivos .exe, pero éstos deben ser de 32 bits.
  • Los comandos del command (como dir, del, cd ,etc) no funcionan directanmente. Hay que invocarlos como:
  • • .exec("command /c dir") en Win 95
    • .exec("cmd /c dir") en NT
  • Las salidas pueden redirigirse a un fichero con un pipe:
  • • .exec("command /c dir > pp.txt")

• Por defecto la invocación de .exec() provoca el arranque de una tarea en paralelo. Si se desea una ejecución con bloqueo de la llamante (es decir no tener paralelismo, el ejemplo típico es que el comando invocado por exec genera un fichero y queremos saber que hay en él). Para ello está el método de la clase Process denominado waitFor(). Ejemplo:
• 
  Runtime r = Runtime.getRuntime();
  Process p = r.exec(...);
  p.waitFor();    // se espera a que el proceso lanzado por exec se termine.

10.- Clases System, Date y Math

• La primera ofrece una miscelánea de servicios de sistema.
• Casi todas las funciones son estáticas.
• Por ejemplo los objetos in, out que ya hemos usado en las i/o por pantalla.
• En system hay metida una función de copia rápida de arrays.
• La clase Date permite manejar información del tipo fecha tal y como saber el día de la semana o el tiempo transcurrido entre dos fechas.
• A partir del JDK 1.1 la mayoría de servicios de la clase Date aparecen como deprecated. Para manejar fechas deben usarse las clases Date, SimpleDateFormat y Calendar.
• Obtención de la fecha del sistema en modo texto en formato dd/mm/aaaa:
  
  import java.util.*;
  import java.text.*;
  
  ...
  
  Date d = new Date(); // fecha actual del sistema
  SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
  System.out.println(sdf.format(d));
  
  
• Obtención de una fecha concreta (11/09/99) en modo texto en formato dd/mm/aaaa:
  
  import java.util.*;
  import java.text.*;
  
  ...
  
  Calendar c = Calendar.getInstance();
  c.set(1999, 9-1, 11);
  
  // También prodríamos hacer:
  // GregorianCalendar c = new GregorianCalendar(1999, 9-1, 11);
  
  Date d = c.getTime();
  SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
  System.out.println(sdf.format(d));
  
  
• En la línea del punto anterior está relacionado la cuestión del formato de números con decimales comentado en la Unidad 2
• En relación a las converiones de tipo se puede destacar en general dos opciones:
  • De cualquier tipo a String: Método toString()
  • Para pasar de String a tipos primitivos puede pasarse por los tipos envoltorio (wrappers) correspondientes mediante la función valueOf() (que está disponible en todos ellos) y luego pasar al tipo primitivo específico.
• Adicionalmente a los tipos primitivos y envoltorio de Java se encuantran disponibles en el JDK las clases BigInteger y BigDecimal destinadas a ámbitos como criptografía o cálculos financieros en los que se precisa de un control completo sobre el redondeo.
• La clase Math ofreve las funciones matemáticas dentro de una clase que las agrupa:
• Para llamar al seno(x) hay que indicar:   Math.sin(x).
• Con la clase Random se dispone de buenos algoritmos para la generación de números aleatorios.
• Ejemplos de cálculos con fechas:

import java.util.*;

public class PruebaFechas
{
  public static void main(String args[]) throws Exception
  {
    Calendar calHoy = Calendar.getInstance();
    calHoy.setTime(new Date());

    // Fecha al cabo de 5 días
    cal = (Calendar)calHoy.clone();
    Date d = cal.getTime();
    long nuevoTime = d.getTime() + (5 * 86400000L); // 3600 * 24 * 1000
    d = new Date(nuevoTime);
    System.out.println(d.toString());

    // Dias de diferencia entre dos fechas
    cal.set(2000, 11, 28); // 0: Enero, ..., 11: Diciembre
    d = cal.getTime();

    long dif = d.getTime() - new Date().getTime();
    System.out.println("Dias entre fechas: " + dif / 86400000L); // 3600 * 24 * 1000

    // Otra forma de calcular la fecha al cabo de 5 días
    cal = (Calendar)calHoy.clone();
    cal.add(Calendar.DAY_OF_MONTH, 5);
    System.out.println("Dia despues de 5 dias: " + cal.getTime());

    // Y Otra forma de calcular la fecha al cabo de 5 días
    cal = (Calendar)calHoy.clone();
    cal.set(Calendar.DAY_OF_MONTH, cal.get(Calendar.DAY_OF_MONTH) + 5);
    System.out.println("Dia despues de 5 dias: " + cal.getTime());

    // Otra forma de calcular la fecha al cabo de 1 semana
    Calendar cal = (Calendar)calHoy.clone();
    cal.set(Calendar.WEEK_OF_MONTH, cal.get(Calendar.WEEK_OF_MONTH) + 1);
    System.out.println("Dia despues de una semana: " + cal.getTime());

  }
}

11.- Protocolo Observer/Observable (Patrón de diseño Observer)
 
En el JDK el patrón de diseño Observer aparece en varias ocasiones. La gestión de eventos JDK 1.1 está basada en él (Observable = Componente emisor y Observer = Listeners), así como el mecanismo de actualización de datos del modelo en la separación modelo/vista de Swing. Además se incluyen unas clases genéricas para que las apliquemos en nuestros casos. Sin embargo aunque ya estaban en el JDK 1.02 no han sido utilizadas de forma genérica por Sun en el desarrollo del propio JDK.  

import java.util.*;
 

public class PruebaObservable
{
  public static void main(String[] args)
  {
    ElQueNotifica x = new ElQueNotifica();   // El Observado
    ElNotificado y = new ElNotificado();     // El Observador

    x.addObserver(y);

    x.indicarCambio();
    x.notifyObservers(" Desde main");
  }
}
 

public class ElQueNotifica extends Observable
{
  public void indicarCambio()
  {
    setChanged();
  }
}

// El observador (en este caso ElNotificado) es el que recibe noticaciones
// cada vez que hay un cambio en el observado (en este caso ElQueNotifica)
// mediante la llamada el update(). En cierto modo update() es un evento.
public class ElNotificado implements Observer
{

  public void update(Observable obj, Object arg)
  {
    System.out.println("Recibida notificación. Parámetro recibido: " + arg);
  }
}
 

12.- Resumen operativo de la unidad: Una clase de utilidades

Es recomendable disponer de una clase de propósito general con funciones de utilidades. A continuación se propone una posible clase de utilidades basada en funciones estáticas con servicios de conversión de tipos entre otros.

import java.util.*;
import java.text.*;

public class Util
{
  public Util()
  {
    Locale locale = new Locale("es", "ESP");
    Locale.setDefault(locale);
  }

  // conversiones String to ...
  public static int stringToInt (String s)
  {
    int a = 0;
    try
    {
      a = Integer.parseInt(s);
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.stringToInt()");
    }
    return a;
  }

  public static double stringToDouble (String s)
  {
    double x = 0;
    try
    {
      x = Double.valueOf(s).doubleValue();
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.stringToDouble(). Recibida: " + s);
    }
    return x;
  }

  public static Date stringToDate (String s)
  {
    Date d = null;
    try
    {
      SimpleDateFormat sd = new SimpleDateFormat();
      sd.applyPattern("dd/MM/yy");
      d = sd.parse(s);
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.stringToDate(). Recibida: " + s);
    }
    return d;
  }

  public static String stringToStringBD (String s)
  {
    String sBD = "";
    try
    {
      Date d = stringToDate (s);
      sBD = fechaToStringBD(d);
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.stringToStringBD(). Recibida: " + s);
    }
    return sBD;
  }

  public static String stringBDToString (String sBD)
  {
    String s = "";
    try
    {
      Date d = stringBDToDate (sBD);
      s = fechaToString(d);
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.stringBDToString(). Recibida: " + sBD);
    }
    return s;
  }

  public static Date stringBDToDate (String s)
  {
    Date d = null;
    try
    {
      d = (Date) java.sql.Date.valueOf(s);
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.stringBDToDate(). Recibida: " + s);
    }
    return d;
  }

  // conversiones ... to String
  public static String fechaToString(Date d)
  {
    String s = "";
    try
    {
      SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
      s = sdf.format(d);
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.fechaToString(). Recibida: " + d);
    }
    return s;
  }

  public static String fechaToStringBD(Date d)
  {
    String s = "";
    try
    {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
      s = sdf.format(d);
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.fechaToStringBD(). Recibida: " + d);
    }
    return s;
  }

  public static String doubleToString(double d)
  {
    String s = "";
    try
    {
      DecimalFormat df = new DecimalFormat("#,##0.00");    // .00 => 2 decimales fijos
      s = df.format(d);                                    // .## => 2 decimales máximo
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.doubleToString(). Recibido: " + d);
    }
    return s;
  }

  // obtenciones de fechas en diveros formatos
  public static Date getFecha(int dia, int mes, int anyo)
  {
    Date d = null;
    try
    {
      Calendar c = Calendar.getInstance();
      c.set(anyo, mes-1, dia);
      d = c.getTime();
    }
    catch (Exception e)
    {
      System.out.println("Capturada en Util.getFecha(). Recibidos: dia = "
                          + dia + ", mes = " + mes + ", anyo = " + anyo);
    }
    return d;
  }

  public static int diasDeUnMes(int mes, int anyo)
  {
    GregorianCalendar gc = new GregorianCalendar();
    gc.set(anyo, (mes-1), 1);
    return gc.getActualMaximum(Calendar.DAY_OF_MONTH);
  }

  public static String getFechaString(int dia, int mes, int anyo)
  {
    return fechaToString(getFecha(dia, mes, anyo));
  }

  public static String getFechaString()
  {
    return fechaToString(new Date());
  }

  public static String nvl(String s)
  {
    return s == null ? "" : s.trim();
  }
}

13.- Fin de la parte sobre el lenguaje

En http://www.chimu.com/publications/JavaSmalltalkSyntax.html se expone una tabla comparativa entre Java i Smaltalk, lenguaje pionero en muchos aspectos del que Java ha incorporado diversos aspectos.
 

Unidad anterior - Unidad siguiente