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...