Utilidades

Existe un conjunto de utilidades dentro del lenguaje Java

Se encuentran en el paquete java.util

Son clases útiles y de uso cotidiano, entre las que destacamos:

• Colecciones
  • Collection
    • List
    • Set
    • Map
• Fechas
  • Date
  • Calendar
• Properties
• Scanner

Collection

El API de colecciones de Java incluye clases que son capaces de albergar conjuntos de objetos

Representan contenedores de objetos

Son estructuras dinámicas, crecen a medida que se añaden elementos y trabajan con Objects

• Se puede añadir cualquier cosa

• Al recuperar el elemento se debe hacer casting

Básicamente hay dos conjuntos:

• Clases que implementan Collection

  • Representan contenedores de objetos

  • Básicamente hay listas (List) y conjuntos (Set)

• Clases que implementan Map

Algunos de sus métodos más importantes son:

• boolean add(Object o)

  añade un elemento a la colección

• boolean addAll(Collection c)

  añade un grupo de objetos (otra colección) a la colección

• void clear()

  vacía la colección

• boolean contains(Object o)

  chequea si un elemento se encuentra dentro de la colección

• boolean isEmpty()

  chequea si la colección está vacía

• Iterator iterator()

  devuelve un java.util.Iterador para recorrer los elementos de la colección

• boolean remove(Object o)

  quita un elemento de la colección

• int size()

  número de objetos almacenados

• Object[] toArray(Object[] a)

  devuelve un array con los elementos de la colección

List

Sirve como interface para clases que representan listas de datos o vectores dinámicos

Sus elementos son accesibles por medio de un indice

Hereda los métodos de Collection y además añade:

• void add(int index, Object element)

  añade un elemento en una posición determinada

• Object get(int index)

  devuelve el elemento que ocupa una posición determinada

• int indexOf(Object o)

  devuelve el indice de la primera aparición del elemento en la lista (o -1 si no lo encuentra)

• Object remove(int index)

  elimina el elemento que ocupa una posición determinada

• Object set(int index, Object element)

  cambia el elemento que ocupa una posición determinada por otro elemento

Al añadir un objeto con add(Object), el elemento se añade al final

Al eliminar un objeto con remove(Object), todos los demás se desplazan para no dejar huecos

Los objetos List más habituales son Vector (es threadsafe) y ArrayList (no es threadsafe)

import java.util.List;
import java.util.Vector;

class Ejemplo{
    class Persona{
        private String name;

        public Persona(String name){
            this.name = name;
        }

        public String getName(){
            return this.name;
        }

        public void setName(String name){
            this.name = name;
        }
    }

    public static void main(String args[] ){
        List pers = Vector();

        pers.add(new Persona("PEPE"));
        pers.add(new Persona("LUIS"));
        pers.add(new Persona("ANA"));
        Persona juan = new Persona("JUAN");
        pers.add(juan);
        Persona carlos = new Persona("CARLOS");
        pers.add(carlos);
        System.out.println("Carlos está en " + pers.indexOf(carlos); // devuelve 4
        pers.remove(juan);
        System.out.println("Carlos está en " + pers.indexOf(carlos); // devuelve 3
        System.out.println("El tamaño es " + pers.size()); // devuelve 4
        System.out.println("¿Está Carlos? " + pers.contains(new Persona("CARLOS"))); // devuelve false
        System.out.println("¿Está Carlos? " + pers.contains(carlos)); // devuelve true
    }
}

Set

Sirve como interface para clases que representan conjuntos de datos

No pueden tener elementos duplicados

Sus elementos no son accesibles por un indice

No añade métodos nuevos

Los objetos Set más habituales son HashSet y TreeSet

import java.util.Set;
import java.util.HashSet;

class Ejemplo{
    class Persona{
        private String name;

        public Persona(String name){
            this.name = name;
        }

        public String getName(){
            return this.name;
        }

        public void setName(String name){
            this.name = name;
        }
    }

    public static void main(String args[] ){
        Set pers = HashSet();

        pers.add(new Persona("PEPE"));
        pers.add(new Persona("LUIS"));
        pers.add(new Persona("ANA"));
        pers.add(new Persona("JUAN"));
        pers.add(new Persona("CARLOS"));
        pers.remove(new Persona("JUAN"));
        System.out.println("El tamaño es " + pers.size()); // devuelve 4
        System.out.println("¿Está Ana? " + pers.contains(new Persona("ANA"))); // devuelve true
        System.out.println("¿Está Carlos? " + pers.contains(new Persona("JUAN"))); // devuelve false
    }
}

Map

Representan tablas de datos

Todo mapa se compone de un conjunto de entradas compuestas de:

• Una clave, sirve para recuperar el elemento
• Un valor

import java.util.Map;

class Ejemplo{
    class Persona{
        private String name;

        public Persona(String name){
            this.name = name;
        }

        public String getName(){
            return this.name;
        }

        public void setName(String name){
            this.name = name;
        }
    }

    public static void main(String args[] ){
        Map agenda;
        Persona p = new Persona("PEPE");

        agenda.put("16444444E", p); //almacenamos una Persona con clave 16444444E
        //Para recuperarla no es necesario buscarla ni recorrer la estructura, se pide directamente usando la clave
        p = (Persona) agenda.get("16444444E");        
        System.out.println(p.getName());
}

Los métodos más importantes son:

• void clear()

  vacía la estructura

• boolean containsKey(Object key)

  devuelve true si hay algún objeto almacenado con esa clave

• boolean containsKey(Object value)

  devuelve true si el Map contiene ese objeto

• Object get(Object key)

  permite recuperar un determinado elemento a partir de su clave

• boolean isEmpty()

  indica si el Map está vacío

• Set keySet()

  devuelve un conjunto de claves del Map

• Object put(Object key, Object value)

  almacena un objeto en el mapa con una clase determinada. Si la clave ya esta almacenada se sustituye por un objeto asociado por el nuevo

• void putAll(Map t)

  incluye un submapa en el mapa

• Object remove(Object key)

  elimina un objeto de clave determinada

• int size()

  devuelve el número de objetos almacenados

• Collection values()

  devuelve el conjunto de valores almacenados en el mapa

Se implementan como tablas Hash

Los más habituales son HashMap (no es threadsafe) y Hashtable (es threadsafe)

import java.util.Map;
import java.util.Hashtable;

class Ejemplo{
    class Persona{
        private String name;

        public Persona(String name){
            this.name = name;
        }

        public String getName(){
            return this.name;
        }

        public void setName(String name){
            this.name = name;
        }
    }

    public static void main(String args[] ){
        Map agenda = new Hashtable();
        Persona p = new Persona("PEPE");

        agenda.put("1644444E", p);
        agenda.put("2222222A", new Persona("ANA"));
        agenda.put("3333333A", new Persona("LUIS"));
        agenda.put("4444444A", new Persona("MARIA");
        System.out.println("¿Existe el DNI 2222222A? "; + agenda.containsKey("2222222A")); // devuelve true
        Persona pr = (Persona) agenda.get("1644444E"); // pr será Pepe
        System.out.println("¿Es Pepe? " + pr.equals(p)); // devuelve true
        System.out.println("El tamaño es " + agenda.size()); // devuelve 4
}

Iterator

Hay colecciones a las que se accede por medio de un índice, otras no

Iterator permite recorrer colecciones de objetos independientemente de cómo estén organizadas

Otra ventaja, permite eliminar objetos sin tener que gestionar los indices

Los métodos más importantes son:

• boolean hasNext()

  devuelve True si el iterador tiene algún elemento más

• Object next()

  devuelve el siguiente elemento de la iteración

• void remove()

  elimina de la colección el último elemento devuelto por el iterador

import java.util.List;
import java.util.Vector;

class Ejemplo{
    class Persona{
        private String name;

        public Persona(String name){
            this.name = name;
        }

        public String getName(){
            return this.name;
        }

        public void setName(String name){
            this.name = name;
        }
    }

    public static void main(String args[] ){
        List pers = Vector();

        pers.add(new Persona("PEPE"));
        pers.add(new Persona("LUIS"));
        pers.add(new Persona("ANA"));
        pers.add(new Persona("JUAN");
        pers.add(new Persona("CARLOS");

        for(int i = 0; i < pers.size(); i++){
           Persona p = (Persona) pers.get(i);

           System.out.println(p.getName());
        }
    }
}

import java.util.List;
import java.util.Vector;
import java.util.Iterator;

class Ejemplo{
    class Persona{
        private String name;

        public Persona(String name){
            this.name = name;
        }

        public String getName(){
            return this.name;
        }

        public void setName(String name){
            this.name = name;
        }
    }

    public static void main(String args[] ){
        List pers = Vector();
        Iterator iter = pers.iterator();

        pers.add(new Persona("PEPE"));
        pers.add(new Persona("LUIS"));
        pers.add(new Persona("ANA"));
        pers.add(new Persona("JUAN");
        pers.add(new Persona("CARLOS");

        while(iter.hasNext()){
           Persona p = (Persona) iter.next();

           System.out.println(p.getName());
        }
    }
}

Fechas

Hay dos clases que permiten trabajar con fechas:

• Date

  casi todos sus métodos están en desuso por lo que no es muy recomendable su uso

• Calendar

  es una interface por lo que es muy fácil darle el comportamiento que queramos

Ambas representan internamente el tiempo mediante un valor de tipo long que representa el número de milisegundos desde la el 1 de Enero de 1970 a las 00:00:00 GMT

Ese valor puede ser obtenido usando System.currentTimeMillis()

Calendar permite muchas más operaciones con fechas que Date, aunque es más difícil de construir (al ser una interfaz deberemos hacer nosotros mismos su implementación)

Date

Es fácil de construir:

• new Date()

  construye un objeto Date con la fecha actual del sistema

Métodos que no están en desuso:

• boolean after(Date when)

  comprueba si la fecha es posterior a la entregada como parámetro

• boolean before(Date when)

  comprueba si la fecha es anterior a la entregada como parámetro

• long getTime()

  devuelve el número de milisegundos desde el 1 de Enero de 1970 a las 00:00:00 GTM

• void setTime(long time)

  cambia la fecha por otra fecha en milisegundos

Métodos en desuso:

• int getDay()

  devuelve el día de la semana para esa fecha o devuelve el día que representa ese instante en la zona local

  Día de la semana

  Día	Domingo	Lunes	Martes	Miércoles	Jueves	Viernes	Sábado
  Valor	0	1	2	3	4	5	6

• getMonth()

  devuelve el mes para esa fecha empezando por 0

  Meses

  Mes	Enero	Febrero	Marzo	Abril	Mayo	Junio	Julio	Agosto	Septiembre	Octubre	Noviembre	Diciembre
  Valor	0	1	2	3	4	5	6	7	8	9	10	11

• getYear()

  devuelve el año para esa fecha a la que se le ha restado 1900

• getHours()

  devuelve la hora para esa fecha, la cuál estará comprendida entre 0 y 23

• getMinutes()

  devuelve los minutos para esa fecha, los cuales estarán comprendidos entre 0 y 59

• getSeconds()

  devuelve los segundos para esa fecha, los cuales estarán comprendidos entre 0 y 61, los valores 60 y 61 sólo aparecerán cuando la MVJ se salte algunos segundos en una cuenta

import java.util.Date;
import java.text.SimpleDateFormat;

class Ejemplo{
    public static void main(String args[] ){
        Date d = new Date();    //La hora del sistema era 05-02-2004 7:35
        SimpleDateFormat df = new SimpleDateFormat("dd-mm-yyyy hh:mm");    //le ponemos el formato dd-mm-yyyy hh:mm

        System.out.println(df.format(d));    //lo veremos por pantalla como 5-2-2004
        Sytem.out.println("Día " + d.getDay());   //devuelve 4
        Sytem.out.println("Mes " + d.getMonth());    //devuelve 1
        Sytem.out.println("Año " + d.getYear());    //devuelve 104
        Sytem.out.println("Hora " + d.getHours());    //devuelve 7
        Sytem.out.println("Día " + d.getMinutos());    //devuelve 35
    }
}

Calendar

Clase abstracta para representar fechas en distintos tipos de calendarios

Incluye un montón de constantes para todos los días de la semana, meses, campos de una fecha…

En occidente para obtener la fecha del sistema utilizaremos el GregorianCalendar:

• new GregorianCalendar()
• new GregorianCalendar(2007, 1, 5)

  Hay que prestar atención a la fecha:

  • es año, mes, día

  • Corresponde al 5 de Febrero de 2007 y no al 5 de Enero de 2007 como podría parecer a primera vista

    Enero corresponde al valor 0

También podemos obtener la fecha del sistema mediante el método estático Calendar.getInstance()

Los métodos más destacable son:

• void add(int field, int amount)

  suma (o resta, según el signo del operando) tiempo a una fecha

• boolean after(Object when)

  comprueba si la fecha es posterior a la entregada como parámetro

• boolean before(Object when)

  comprueba si la fecha es anterior a la entregada como parámetro

• int get(int field)

  devuelve el valor de algún campo de la fecha, el cual especificamos con el parámetro field

• Date getTime()

  convierte el tipo Calendar a Date

• void set(int field, int value)

  cambia de valor un campo de la fecha

• void set(int year, int month, int date)

  cambia el año, el mes y el día de la fecha

• void setTime(Date date)

  a partir de un Date, crea un Calendar

import java.util.Calendar;
import Java.util.GregorianCalendar;
import java.text.SimpleDateFormat;

class Ejemplo{
    public static void main(String args[] ){
        Calendar gc = new GregorianCalendar(2004, 1, 28);    // 28-2-2004

        System.out.println("Día " + gc.get(Calendar.DAY_OF_MONTH);    // devuelve 28
        System.out.println("Mes " + gc.get(Calendar.MONTH);    //devuelve 1 (Febrero)
        System.out.println("Año " + gc.get(Calendar.YEAR);    //devuelve 2004
        System.out.println("Día de la semana " + gc.get(Calendar.DAY_OF_WEEK);    //devuelve 7 (Domingo)
        gc.add(Calendar.DAY_OF_MONTH, 1);    //sumamos un día

        SimpleDateFormat df = new SimpleDateFormat("dd-mm-yyyy");    //le ponemos el formato dd-mm-yyyy
        System.out.println(df.format(gc.getTime()));    //lo veremos por pantalla como 29-2-2004
    }
}

Properties

Habitualmente el comportamiento de las aplicaciones puede cambiar en función de parámetros

Es muy cómodo colocar esos parámetros de configuración en ficheros para que la aplicación los lea según los necesite

Java dispone de la clase Properties que automatiza esta gestión

Cada línea del fichero de propiedades guarda una variable y tiene el formato:

<nombre> = <valor>

Vamos a usar el fichero llamado conexion.properties que tendrá el siguiente contenido:

user=manpower
pwd=qwerty486intelinside
ip=192.168.0.48
machine=larioja.org

Para mostrar el uso de Properties con el siguiente ejemplo:

import java.io.FileInputStream;
import java.util.Properties;

class Ejemplo{
    public static void main(String args[] ){
        try{
            FileInputStream in = new FileInputStream("conexion.properties");
            Properties props = new Properties();

            props.load(in); 
            System.out.println(props.getProperty("user"));    //muestra manpower
            System.out.println(props.getProperty("pwd"));    //muestra qwerty486intelinside
            System.out.println(props.getProperty("ip"));    //muestra 192.168.0.48
            System.out.println(props.getProperty("machine"));    //muestra larioja.org
        }catch(IOEXception e){
            System.out.println("Error de E/S");
        }finally{
           try{
              in.close();   //Se cierra el flujo del fichero conexion.properties        
           }catch(IOEXception e){
              System.out.println("Error de E/S");
           }
        }
    }
}

Scanner

Se puede utilizar la clase Scanner para leer tipos primitivos y Strings usando expresiones regulares

La clase Scanner recoge los caracteres pulsados desde el teclado hasta encontrar un delimitador que por defecto es el espacio

Los datos recogidos son convertidos a los diferentes tipos usando el método next<tipo>(), para recoger textos como String usaremos sólamente next()

De esta forma podremos recoger del teclado o de otros medios, los tipos de datos que necesitemos

java.util.Scanner;

class Ejemplo{
    public static void main(String args[] ){
        try{
            Scanner sc = new Scanner(System.in);
            int i = sc.nextInt();
 
            System.out.println(i);    //muestra el entero que hemos leído por teclado
        }catch(IOEXception e){
            System.out.println("Error de E/S");
        }finally{
           try{
              sc.close();   //Se cierra el flujo con el teclado        
           }catch(IOEXception e){
              System.out.println("Error de E/S");
           }
        }
    }
}

En el ejemplo hemos leído un int desde el teclado

java.util.Scanner;
java.io.File;

class Ejemplo{
    public static void main(String args[] ){
        try{
            Scanner sc = new Scanner(new File("numeros.txt"));
            long aLong = 0;

            while(sc.hasNextLong()){
                aLong = sc.nextLong();
                System.out.println("%d", aLong);    //muestra el long que hemos leído del fichero
            }
        }catch(IOEXception e){
            System.out.println("Error de E/S");
        }finally{
           try{
              sc.close();   //Se cierra el flujo con el fichero numeros.txt
           }catch(IOEXception e){
              System.out.println("Error de E/S");
           }
        }
    }
}

En el ejemplo hemos leído varios long desde un fichero llamado numeros.txt

java.util.Scanner;

class Ejemplo{
    public static void main(String args[] ){
        try{
            String input = "Tres tristes tigres";
            Scanner sc = new Scanner(input);

            while (sc.hasNext()){
                System.out.println(sc.next());
            }
        }catch(IOEXception e){
            System.out.println("Error de E/S");
        }finally{
           try{
              sc.close();   //Se cierra el flujo con el String
           }catch(IOEXception e){
              System.out.println("Error de E/S");
           }
        }
    }
}

En el ejemplo hemos leído varias palabras desde un String

Mostrándonos por pantalla:

Tres
tristes
tigres

Es decir, las palabras que contenía el String, cada una en una línea cada vez porque usamos println para mostrarlas por pantalla

Trestristestigres

Como podemos ver, si en cambio, hubiésemos utilizado print las habría mostrado todas en la misma línea sin ningún delimitador entre ellas

java.util.Scanner;

class Ejemplo{
    public static void main(String args[] ){
        try{
            String input = "Tres1tristes1tigres";
            Scanner sc = new Scanner(input).useDelimiter("\\s*1\\s*");

            while (sc.hasNext()){
                System.out.println(sc.next());
            }
        }catch(IOEXception e){
            System.out.println("Error de E/S");
        }finally{
           try{
              sc.close();   //Se cierra el flujo con el String
           }catch(IOEXception e){
              System.out.println("Error de E/S");
           }
        }
    }
}

En el ejemplo hemos leído varias palabras desde un String cambiando el delimitador espacio por el delimitador 1

Para definir el nuevo delimitador usamos el método useDelimiter y le pasamos de parámetro una cadena que contiene una expresión regular, en este caso \\s*1\\s*

Mostrando por pantalla lo mismo que en el ejemplo anterior a pesar de usar un delimitador distinto