convertir String a Date

La necesidad de convertir cadenas a tipo de datos Date se puede decir que siempre nos encontraremos en esta situación.
Por lo tanto en esta entrada mostraremos como podemos realizar la conversión de tipo de dato String a Date utilizando la Clase SimpleDateFormat.
La clase SimpleDateFormat nos permite formatear y convertir la fecha dependiendo de la localidad que requerimos.



public class ToDate {

    public ToDate() {
    }

    public Date toDate(String fechaIn, String formatoIn) throws ParseException {

        SimpleDateFormat df = new SimpleDateFormat(formatoIn);
        ParsePosition pp = new ParsePosition(0);
        Date date = df.parse(fechaIn);

        return date;
    }

    public static void main(String arg[]) {
        try {
            ToDate fecha = new ToDate();
            String fechas = "01-Dic-2010 22:00:00.000";
            System.out.println(fecha.toDate(fechas, "dd-MMM-yyyy hh:mm:ss"));

        } catch (ParseException ex) {
            Logger.getLogger(ToDate.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
}
Leer más...

Año Bisiesto

El año bisiesto es un tema que nos encontramos cuando necesitamos obtener fechas exactas en cantidad de días.
Por lo tanto veremos en esta entrada como podemos programarlo con java.
Un año es año bisiesto dura 366 días, en vez de los 365 de un año común. Ese día adicional se añade al final del mes más corto,que viene siendo febrero y quedando con 29 días.
Este día se añade para corregir el desfase que existe con la duración real de los años: 365 días y 6 horas y 9min. Esto hace que se corrija cada cuatro años (los años múltiplos de cuatro) que se acumulan 24 horas.
para ver más detalle y explicación del tema en base a teoría leer bisiesto

public class NewClass {
    public boolean esBisiesto(int mesIn, int anioIn){
        boolean bis = false;

        if (anioIn % 4 == 0) {
            bis = true;
        } else if (anioIn % 100 == 0) {
            bis = true;
        } else if (anioIn % 400 == 0) {
            bis = true;
        }
        return bis;
    }
    public int obtenerDias(int mesIn, int anioIn) {

        
        if (mesIn == 1 || mesIn == 3 || mesIn == 5 || mesIn == 7
                || mesIn == 8 || mesIn == 10 || mesIn == 12) {
            return 31;
        } else if (mesIn == 2) {
            if (esBisiesto(int mesIn, int anioIn)) {
                return 29;
            } else {
                return 28;
            }
        } else {
            return 30;
        }
    }

    public static void main(String arg[]) {
        NewClass b = new NewClass();
        System.out.println(b.obtenerDias(2, 2024));
    }
}

Leer más...

StringBuffer - StringBuilder

Hoy hablaremos de las clases StringBuffer y StringBuilder.
En la versión del jdk 1.4 se creó la clase StringBuffer que permitía y permite la manipulación de buffer de cadenas teniendo la ventaja, ante la clase String, que podemos utilizar los diferentes métodos para modificar,agregar y eliminar de la cadena uno o varios caracteres.
En esta clase, entre los métodos que contienen, se encuentran los métodos:
- append(..)
- insert(..)
que vienen siendo los más usados de esta clase, en la práctica ambos métodos tienen la misma funcionalidad con la diferencia que el método append() siempre ingresará el dato al final del buffer y el método insert nos permitirá ingresar el dato en la posición que necesitemos y ambos métodos se encuentran sobrecargados para permitir el uso de cualquier tipo de dato.
Una de las ventajas que podemos encontrar con esta clase en términos de rendimiento y optimización de código es la disminución de cadenas temporales al permitirnos concatenar cadenas con el método append() y no usar el signo más. Esta ventaja es la que lleva a recomendar su uso en la programación móvil por el rendimiento.
Ejemplo:

   String strCadena="ampliando"+"conocimientos"+"java";
   StringBuffer bufferString = new StringBuffer();
   bufferString.append("ampliando").append("conocimientos").append("java");

Ahora no todo es tan bonito como parece, la desventaja que presenta es su comportamiento de sincronización en los métodos, que en términos de funcionalidad de subprocesos es fabuloso pero en rendimiento no lo es.
Esta desventaja trajo la creación de la clase StringBuilder en la versión 1.5, que nos permite el mismo comportamiento e inclusive es compatible con clase StringBuffer.
Se entiende que se eliminó la sincronización de los métodos por lo que solo permitirá el uso de un solo hilo.
La última recomendación realizada por el personal de oracle (antigua Sun, no me acostumbro todavía :D), es el uso de StrinBuilder, siempre y cuando no sea para varios subprocesos.

Para terminar un detalle bastante importante con ambas clases inicializan por defecto con una longitud de 16 sumados a la longitud del valor o cadena ingresada inicialmente.
Verificar el método setLength(); para la longitud.

Leer más...

Persistencia con XMLEncoder

En esta ocasión veremos el tema de Persistencia de datos con xml y para el caso usaremos la clase XMLEncoder del paquete java.beans.XMLEncoder, que nos permite serializar diferentes tipos de datos sean primitivos o de objetos y que nos será de gran utilidad para ocaciones donde necesitemos almacenar datos con su estructura completa (valor y tipo de dato).

Crearemos un bean llamado

Usuario y tendrá los siguientes atributos: nombre,apellido,edad,correo.
quedando así
public class Usuario {

 private String nombre;
 private String apellido;
 private int edad;
 private String correo;


 /**
  * @return the nombre
  */
 public String getNombre() {
  return nombre;
 }

 /**
  * @param nombre the nombre to set
  */
 public void setNombre(String nombre) {
  this.nombre = nombre;
 }

 /**
  * @return the apellido
  */
 public String getApellido() {
  return apellido;
 }

 /**
  * @param apellido the apellido to set
  */
 public void setApellido(String apellido) {
  this.apellido = apellido;
 }

 /**
  * @return the edad
  */
 public int getEdad() {
  return edad;
 }

 /**
  * @param edad the edad to set
  */
 public void setEdad(int edad) {
  this.edad = edad;
 }

 /**
  * @return the correo
  */
 public String getCorreo() {
  return correo;
 }

 /**
  * @param correo the correo to set
  */
 public void setCorreo(String correo) {
  this.correo = correo;
 }

 /**
  *
  */
 public Usuario() {
  // TODO Auto-generated constructor stub
 }

}

Seguido creamos una clase SerializarDatos

public class SerializarDatos {

 public SerializarDatos() {

 }

 public boolean xmlEnconder(String rutaIn, Usuario usuariosIn)
   throws FileNotFoundException {

  FileOutputStream fileOutputStream;
  XMLEncoder encoder;
  Usuario user;

  fileOutputStream = new FileOutputStream(rutaIn);
  encoder = new XMLEncoder(fileOutputStream);
  user = new Usuario();

  user.setNombre(usuariosIn.getNombre());
  user.setApellido(usuariosIn.getApellido());
  user.setEdad(usuariosIn.getEdad());
  user.setCorreo(usuariosIn.getCorreo());

  encoder.writeObject(user);
  encoder.close();

  return true;
 }
}

Agregamos la clase Teclado y creamos la clase
public class ProcesarDatos {

    /**
     *
     */
    public ProcesarDatos() {
        // TODO Auto-generated constructor stub
    }
    public void leerDatos(String rutaIn) {

        StringBuffer buffer;
        FileInputStream fileInputStream;
        XMLDecoder decoder;

        Usuario usuario;

        try {
            fileInputStream = new FileInputStream(rutaIn);

            decoder = new XMLDecoder(fileInputStream);
            usuario = (Usuario) decoder.readObject();
            buffer = new StringBuffer();

            buffer.append("Nombre: ").append(usuario.getNombre()).append("\n");
            buffer.append("Apellido: ").append(usuario.getApellido()).append("\n");

            buffer.append("Edad: ").append(usuario.getEdad()).append("\n");
            buffer.append("Correo: ").append(usuario.getCorreo());
            System.out.println(buffer.toString());

        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    public void escribirDatos(String rutaIn) {

        Usuario usuario;
        SerializarDatos serializarDatos;
        String strDatos;

        usuario = new Usuario();
        strDatos = "";

        try {
            System.out.print("Ingresar nombre:");

            strDatos = Teclado.lectura();
            usuario.setNombre(strDatos);
            System.out.println();

            System.out.print("Ingresar Apellido:");
            strDatos = Teclado.lectura();
            usuario.setApellido(strDatos);
            System.out.println();

            System.out.print("Ingresar Edad:");
            strDatos = Teclado.lectura();
            usuario.setEdad(Integer.parseInt(strDatos));
            System.out.println();

            System.out.print("Ingresar Correo:");
            strDatos = Teclado.lectura();
            usuario.setCorreo(strDatos);
            System.out.println();

            System.out.println("Procesando información introducida.");

            serializarDatos = new SerializarDatos();
            serializarDatos.xmlEnconder(rutaIn, usuario);

            System.out.println("Proceso Terminado.");

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}


Y por último agregamos la clase Principal que será nuestro programa principal.
public class Principal {

    /**
     * @param args
     */
    public static void main(String[] args) {
        String strOpcion = "";
        String rutaIn;
        rutaIn = "/home/arielb/ampliandoconocimientosjava/usuarios.xml";
        ProcesarDatos procesarDatos;

        do {
            System.out.println("\n\n\t Serialización de datos xml");
            System.out.println("\t\t1 - Escribir datos.");
            System.out.println("\t\t2 - Leer datos.");
            System.out.println("\t\t3 - Salir.");
            try {
                procesarDatos = new ProcesarDatos();
                strOpcion = Teclado.lectura();
                switch (Integer.parseInt(strOpcion)) {

                    case 1:
                        procesarDatos.escribirDatos(rutaIn);
                        break;
                    case 2:
                        procesarDatos.leerDatos(rutaIn);
                        break;
                    case 3:
                        System.out.println("Saliendo del sistema");
                        break;
                    default:
                        System.out.println("Opción no considerada");
                        break;
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } while (!strOpcion.trim().equals("3"));

    }
}

Al tener estas clase podremos ejecutar nuestro programa y después de introducir los datos que solicita el programa podremos buscar en la ruta que colocamos en la variable rutaIn.
En esa ruta buscaremos un archivo llamado archivo.xml o el nombre que pusimos a nuestro gusto. el contenido del archivo según los datos que ingrese son:
C
Como verán existen dos métodos en la clase Procesar datos, uno que nos permite escribir los datos en el archivo y el otro que nos permite leerlos.

Leer más...

Properties

La clase Properties nos ayuda a manejar preferencias de los usuarios y otras puntos más que se requieran como datos de configuración del sistema.
Utilizando un atributo seguido por un signo igual se coloca la información que queremos persistir.
Haremos un ejemplo donde creamos un archivo de nombre "datos.properties", dentro de este archivo le agregamos un atributo de nombre blog y el contenido será http://ampliandoconocimientosjava.blogspot.com/.
El archivo debe quedar así
blog=http://ampliandoconocimientosjava.blogspot.com/

Lo guardamos y probamos este código

public class ObtenerPropiedades {

    public static String getPropiedades(String archivoIn, String nombrePropiedad)
            throws FileNotFoundException, IOException, PropertyException {

        Properties prop;
        InputStream in;
        String propiedad = "";

        in = ObtenerPropiedades.obtenerArchivo(archivoIn);

        prop = new Properties();

        prop.load(in);
        if (!nombrePropiedad.trim().equals("")) {
            propiedad = prop.getProperty(nombrePropiedad);
            if (propiedad == null) {
                throw new PropertyException("Propiedad \"" + nombrePropiedad + "\" no fue encontrada.");
            }
        }else{
            throw new PropertyException("Falta el nombre de la propiedad.");
        }


        return propiedad;
    }

    public static InputStream obtenerArchivo(String archivoIn) throws FileNotFoundException {
        InputStream in = new FileInputStream(archivoIn);
        return in;
    }
}

public class DatosProperties {

    public static void main(String arg[]) {
        try {
            String strBlog;
            strBlog = ObtenerPropiedades.getPropiedades("/home/arielb/datos.properties", "blog");
            System.out.println("Valor: " + strBlog);
        } catch (FileNotFoundException ex) {
            Logger.getLogger(DatosProperties.class.getName()).log(Level.SEVERE, null, ex);
        } catch (IOException ex) {
            Logger.getLogger(DatosProperties.class.getName()).log(Level.SEVERE, null, ex);
        } catch (PropertyException ex) {
            System.err.println(ex);
            //Logger.getLogger(DatosProperties.class.getName()).log(Level.SEVERE, null, ex);
        }

    }
}

public class PropertyException extends Exception {

    public PropertyException(String mensaje) {
        super(mensaje);
    }

    public PropertyException() {
        super();
    }

    public PropertyException(String mensaje, Throwable causa) {
        super(mensaje, causa);
    }

    public PropertyException(Throwable mensaje) {
        super(mensaje);
    }
}

resultado:

Dirección del blog: http://ampliandoconocimientosjava.blogspot.com/
Leer más...

Pattern, verificando número entero

La clase Pattern, nos permite decirle a la máquina virtual como manipular o encontrar en una cadena de una forma específica según nuestra necesidad.
Si revisamos la ayuda de la página de oracle podemos encontrar que una expresión regular debe ser especificada como una cadena y que primero se debe compilar una instancia de esta clase (Pattern) y que el patrón resultante se puede utilizar para crear un objeto Matcher que puede coincidir con secuencias arbitrarias de caracteres en contra de la expresión regular.
usandolo de la siguiente manera cuando son casos donde la expresión regular se utilice más de una vez

Pattern p = Pattern.compile("a*b");
   Matcher m = p.matcher("aaaaab");
   boolean b = m.matches();

Pero para casos que la expresión regular solo la necesitemos una ves podemos y la secuencia coincida en la compilación podemos realizarlo con el método matches de la clase Pattern.
Bueno una forma de emplearlo verificando si un número es entero, sería así:

import java.util.regex.Matcher;
      import java.util.regex.Pattern;

public class Entero {

    public Entero() {
    }

    public static boolean esEntero(String numero) {


        if (Pattern.matches("^\\d+$", numero)) {
            return true;
        }

        return false;
    }

    public static void main(String arg[]) {
        String dato = new String("125rtf");
        
        if (Entero.esEntero(dato)) {
            System.out.println("Es un Número");
        } else {
            System.out.println("No es un número");
        }

    }
}

Leer más...

algoritmos de ordenamiento

En esta entrada estaremos viendos unos cuantos algoritmos de ordenamiento para implementarlos con java, se puede decir que son los más conocidos y utilizados.

Método de Burbuja: Este método revisa todos los valores o elementos de una lista y los intercambia si están en una posición u orden equivocado.
Este método es conocido como el más fácil de implementar, pero realmente en concepto de eficiencia es el menos recomendado.


El método burbuja lo podemos representar de la siguiente forma
 public String[] ordenarLista(String[] listaIn) {

        int posicion_menor = 0;

        int tamanio = listaIn.length;

        int i, j;
        String intercambiar = "";

        for (i = 0; i < tamanio; i++) {

            posicion_menor = i;
            for (j = i + 1; j < tamanio; j++) {

                if (listaIn[j].compareToIgnoreCase(listaIn[posicion_menor]) < 0) {

                    posicion_menor = j;

                }

            }

            intercambiar = listaIn[i];
            listaIn[i] = listaIn[posicion_menor];

            listaIn[posicion_menor] = intercambiar;

        }
        return listaIn;
    }
}


//un ejemplo más completo

public class OrdenarLista {

    public static void main(String arg[]) {
        OrdenarLista lista = new OrdenarLista();
        String[] datos = null;
        int cantidad = 0;
        String reg = "";
        try {
            System.out.print("Introduzca la cantidad de datos que va a ingresar==>");

            reg = Teclado.lectura();
            if (reg != null) {
                if (reg.length() > 0) {
                    datos = new String[Integer.parseInt(reg)];
                    int i;
                    String temp = "";
                    for (i = 0; i < Integer.parseInt(reg); i++) {

                        do {
                            System.out.print("Introduzca valor "+(i+1)+"==>");
                            temp = Teclado.lectura();
                        } while (temp.trim().equals(""));
                        datos[i] = temp;
                    }
                    datos = lista.ordenarLista(datos);
                    cantidad = datos.length;
                    for (i = 0; i < cantidad; i++) {
                        System.out.println((i+1)+ "==>" + datos[i]);
                    }
                }
            }
        } catch (IOException ex) {
            Logger.getLogger(OrdenarLista.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public String[] ordenarLista(String[] listaIn) {

        int posicion_menor = 0;

        int tamanio = listaIn.length;

        int i, j;
        String intercambiar = "";

        for (i = 0; i < tamanio; i++) {

            posicion_menor = i;
            for (j = i + 1; j < tamanio; j++) {

                if (listaIn[j].compareToIgnoreCase(listaIn[posicion_menor]) < 0) {

                    posicion_menor = j;

                }

            }

            intercambiar = listaIn[i];
            listaIn[i] = listaIn[posicion_menor];

            listaIn[posicion_menor] = intercambiar;

        }
        return listaIn;
    }
}



Leer más...

Vector

La clase Vector es una clase que nos ayuda a realizar varias funciones que con un arreglo no se puede, aunque existen desventajas en comparación con los arreglos, y esk par que el acceso y la manipulación es más lenta.
Una de las ventajas que nos dá la clase Vector es que no necesito declarar o definirle la dimensión, ya que por defecto o de forma implicita ella se define en un tamaño de 10.
Ahora bien al hacer esto, debemos considerar si el uso del objeto declarado sobrepasará el tamaño definido, es decir si declaramos un objeto sin definir el tamaño o si le definimos el tamaño, al sobrepasarse este se duplicará al llegar al tamaño fijado.
Por lo tanto, en una buena práctica de programación, se le debe asignar cuanto debe ser el incremento y así evitamos el uso imnecesario de memoria que es un punto bien importante al momento de rendimiento.
Veamos las diferentes formas de definir un objeto con las clase Vector

//en esta instanacia el objeto tomará una dimensión de 10 y 
//su incremento será de 10
Vector vtrPrimero = new Vector();

//en esta instanacia el objeto se le dió una dimensión de 15 y 
//su incremento será de 15
Vector vtrSegundo = new Vector(15);

//en esta instanacia el objeto se le dió una dimensión de 15 y
su incremento será de 2
//Este es el recomendado
Vector vtrTercero = new Vector(15,2);

Otra ventaja es que podemos almacenar diferentes tipos de datos, desde tipos de datos primitivos hasta tipos de datos de objetos, esto no lo podemos realizar con un arreglo solo permite un solo tipo de datos






Leer más...