Java Algunas utilidades by tfu54501

VIEWS: 93 PAGES: 12

									Java: Algunas utilidades
                                    Temporización
        En ingeniería nos encontramos con tareas que deben repetirse de
         forma periódica. Son tareas temporizadas
        Debemos distinguir:
             Tarea temporizada (por ejemplo la lectura o escritura de un archivo,
              el mostrar algo por pantalla, accionar un brazo robot, etc.). Tenemos
              que crear una clase que hereda de la clase abstracta TimerTask, que
              tiene como método abstracto run()
             El temporizador: controla el tiempo y ejecuta la tarea temporizada. Es
              un objeto de la clase Timer
        Para implementarlo:
         1.   Creamos un objeto que representará la tarea temporizada, la clase
              hereda de TimerTask
               1.   TareaTemporizada tarea = new TareaTemporizada();
         2.   Iniciamos el temporizador:
               Timer t = new Timer();
               t.schedule( tarea, inicio, periodo );
               -   inicio: cuando se inicia en ms
               -   periodo: período de tiempo en ms
         3.   El temporizador llamará periódicamente al método run() de la tarea
              temporizada
Inicio                                                                            2
                                                            Un ejemplo
        La clase que representa la tarea temporizada, muestra un mensaje con la fecha y hora:
               package figuras.prueba;
               import java.util.TimerTask;
               import java.util.Calendar;

               public class TareaPeriodica extends TimerTask {
                  public void run() {
                      Calendar cal = Calendar.getInstance();
                      System.out.println( "Buenas, saludo repetitivo a las " + cal.getTime());
                  }
               }
        En main() temporizamos y, mientras el usuario no presione „Enter‟, no cancelamos:
               public static void main(String[] args) {

                     String opcion ="a";
                     BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));

                     figuras.prueba.TareaPeriodica tarea = new figuras.prueba.TareaPeriodica();
                     Timer timer = new Timer();
                     timer.schedule( tarea, 0, 15*1000 );

                     while (opcion.length() != 0) {
                        try {
                           opcion = entrada.readLine();
                        }
                        catch (Exception e) { e.printStackTrace(); }
                     }
                     timer.cancel();
               }

Inicio                                                                                                3
                                         Un ejercicio
        Volvamos a nuestro ejemplo de las figuras, que hemos
         visto en capítulos anteriores. Vamos a hacer una tarea
         temporizada que en su constructor arranque el Timer.
         El método run() de la tarea lee el archivo de figuras y
         las muestra por pantalla
        Desde main la única línea de código sería:
         TareaTemporizada temporizacion = new TareaTemporizada( 0, 60*1000, 5,
                                              "c:/DOC/Java_libre/Figuras/archivos/ejemplo.txt");

        Argumentos:
            Primero: tiempo hasta inicio
            Segundo: periodo
            Tercero: número máximo de ejecuciones de run(). Si llega al
             máximo, entonces se cancela la temporización
            Cuarto: archivo de figuras


Inicio                                                                                         4
                              Ordenando con Comparator
    A menudo nos planteamos la ordenación de elementos de una lista. El problema es que los tipos o clases
     de datos son muy diversos y, por tanto, las formas de comparar personas, caballos o coches pueden ser
     muy diferentes. Supongamos que tenemos la siguiente clase, que tiene un atributo identificador:
                 package j13_collection;
                 public class Ente {
                   private int id;                    // Identificativo del elemento
                   public Ente( int id ) {
                     this.id = id;
                   }
                   public int getId()    { return id; }
                 }
    Necesitamos comparar los objetos de menor a mayor en función de su “id”. Para ello vamos a crear la
     clase “Comparador”, que implementa el interfaz “Comparator”. Lo único que tenemos que hacer es
     sobreescribir el método “compare()”, que recibirá dos entes en la forma de Object. Este método debe
     devolver un int negativo si el primer objeto es menor, positivo si es mayor y cero si son iguales:
                 import java.util.Comparator;
                 public class Comparador implements Comparator {
                   public int compare( Object o1, Object o2 ) {
                     if ( ((Ente)o1).getId() < ((Ente)o2).GetId() )
                        return –1;
                     if ( ((Ente)o1).getId() > ((Ente)o1).getId() )
                        return 1;
                     return 0;
                   }
                 }
    Inicio                                                                                           5
                                Ordenando un ArrayList
Tomemos el ejemplo anterior y vamos a ordenar un ArrayList:
     package j13_collection;
     import java.util.*;

      public class j13_collection {
        public static void main(String[] args) {
          List lista = new ArrayList( 2 );       // Creo lista con capacidad de 2
          lista.add(new Ente(23));                // Añado ente
          lista.add(new Ente(12));                // Añado ente
          mostrarLista( (ArrayList) lista ); // Muestra la lista
          lista.remove( 0 );                      // Borro el primer elemento
          mostrarLista( (ArrayList) lista ); // Muestro lista
          lista.add(new Ente(9));                 // Añado ente
          lista.add(new Ente(34));                // Añado ente
          mostrarLista( (ArrayList) lista ); // Muestro lista
          /* INTERESANTE: llamo al método static sort() de la clase Collections, le paso como primer arg
               la lista y como segundo arg un objeto comparador (ver comparador.java) */
          Collections.sort( lista, new comparador() );
          mostrarLista( (ArrayList) lista ); // Muestra la lista ordenada
        }
        public static void mostrarLista( ArrayList lista ) {
          System.out.println( "ENTIDADES. TAMAÑO: " + lista.size());
          for ( int i = 0; i < lista.size(); i++) {
              Ente e = (Ente) lista.get(i);
              System.out.println( " Ente: " + e.getId());
          }
        }
  Inicio                                                                                                 6
      }
                          Introducción a las fechas (I)
    La clase java.util.Date es la primera clase implementada en el API para el manejo de
     fechas. Tiene severas limitaciones, en especial en la internacionalización.
    A partir de la versión 1.1 manejamos java.util.Calendar y su subclase
     java.util.GregorianCalendar.
    Para mostrar el resultado por pantalla crearemos el método util.mostrar():
           package figuras.util;
           import java.util.Calendar;

           public class Fechas {
              /**************************************************************************
               * Muestra en consola la fecha y hora
               **************************************************************************/
              static public void mostrar(String mensaje, Calendar fec) {
                         System.out.println( mensaje + " Dia:"+fec.get( Calendar.DAY_OF_MONTH) + " Mes:" +
                                                                 (fec.get( Calendar.MONTH)+1) +
                                                   " Año:" + fec.get( Calendar.YEAR) +
                                                   " Hora:" + fec.get( Calendar.HOUR_OF_DAY) +
                                                   " Minuto:" + fec.get( Calendar.MINUTE) +
                                                   " Segundos:" + fec.get( Calendar.SECOND) +
                                                   " Milisegundos:" + fec.get( Calendar.MILLISECOND));
              }
           }
    La llamada, con la fecha actual, podría ser:
           Calendar cal = Calendar.getInstance();
           Fechas.mostrar("Hola", cal);
    El mes lo calcula empezando por 0, por lo que para mostrarlo sumamos uno

Inicio                                                                                                  7
                   Introducción a las fechas (II)

        Formas de crear, definir (set) y aumentar (add)
         una fecha. Observar que en el método set() el
         mes empieza en cero (si quiere poner Marzo
         debe indicar un 2):
             Calendar fechaIni = Calendar.getInstance();
             fechaIni.set(2007, 2, 1);             // Empieza en 0. El 2 es Marzo
             Fechas.mostrar("Fecha de inicio.", fechaIni);
             Calendar fechaFin = Calendar.getInstance();
             fechaFin.add( Calendar.DAY_OF_MONTH, 30);
             Fechas.mostrar( "Fecha de fin (actual+30 días).", fechaFin);
        Para disminuir una fecha se usa también add(), usando
         como segundo argumento un número negativo

Inicio                                                                         8
                    Diferencia y comparación de fechas
    Vamos a calcular la diferencia entre fechas. Para ello nos
     serviremos de getTimeInMillis(), que devuelve la fecha en
     milisegundos:
             System.out.println("\nCALCULO DE DIAS DE DIFERENCIA:");
             long dif = fechaFin.getTimeInMillis() - fechaIni.getTimeInMillis();
             double d = dif / (1000 * 60 * 60 * 24); // conversion miliseg a dias
             System.out.println( "Hay " + d + " días entre la fecha de inicio y la de fin");

    Para la comparación tenemos los métodos before(), after()
     e equals(). Un ejemplo:
             if ( fechaIni.before(fechaFin) )
                 System.out.println( fechaIni.getTime() +" ES ANTERIOR A "+ fechaFin.getTime());




    Inicio                                                                                     9
                  Entrada de usuario en forma de String
   Un problema típico es que el usuario introduce por teclado un String con la fecha en su formato
    local y tenemos que convertirlo en un tipo Calendar. En nuestro ejemplo simulamos que el usuario
    ha introducido el 28 de Febrero de 1988:
         String strFecha = "28/2/1988"; // Así lo introduciría el usuario por teclado
         System.out.println("\nVAMOS A CONVERTIR A CALENDAR LA FECHA “ + strFecha );
         Calendar cFecha = Fechas.getFecha( strFecha, "/");
         Fechas.mostrar("La fecha en formato Calendar es ", cFecha );
   Para resolver el problema hemos creado el método getFecha():
         static public Calendar getFecha( String strFecha, String separador ) {
               try {
                  java.util.StringTokenizer st = new java.util.StringTokenizer(strFecha, separador);
                  int dia = 0, mes = 1, anio = 0;

                 if (st.hasMoreElements())
                     dia = Integer.parseInt((String) st.nextElement());

                 if (st.hasMoreElements())
                     mes = Integer.parseInt((String) st.nextElement()) - 1; // El mes empieza en 0

                 if (st.hasMoreElements())
                     anio = Integer.parseInt((String) st.nextElement());

                  Calendar cal = Calendar.getInstance();
                  cal.set(anio, mes, dia);
                  return cal;
               } catch (Exception e) {
                  return null;
               }
           }
Inicio                                                                                                 10
                                 Formateo de fechas

   Vamos a convertir la fecha a un formato local. Para más
    información ver http://java.sun.com/j2se/1.4.2/docs/api/java/text/SimpleDateFormat.html:
     java.text.SimpleDateFormat sdfFecha =new java.text.SimpleDateFormat("dd/MM/yyyy");
     java.text.SimpleDateFormat sdfHora = new java.text.SimpleDateFormat("HH:mm");
     System.out.println("Fecha formateada:" + sdfFecha.format(fechaIni.getTime()));
     System.out.println("Hora formateada:" + sdfHora.format(fechaIni.getTime()));




    Inicio                                                                              11
                                                 Otros
        La clase Random (java.util.Random) genera números
         aleatorios. Ejemplo que genera números aleatorios entre
         cero y uno:
              Random r = new Random();
                for (int i=1; i<=10; i++ )
                  System.out.println( r.nextDouble() );
            Aunque el uso del método static double random() de la clase
             Math tiene el mismo resultado
            En Random tenemos double nextGaussian(), que nos da
             una distribución gaussiana centrada en el cero y con una
             desviación estándar en torno a 1. También tenemos nextInt(n)
             que nos da números entre 0 y n-1 (incluido)
        En la clase Math tiene múltiples utilidades: abs(a) para
         el valor absoluto, pow(a,b) para elevar “a” a “b”,
         sqrt(a) para la raiz cuadrada, etc.

Inicio                                                               12

								
To top