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

StringTokenizer-separación de cadenas

La clase StringTokenizer es una clase que nos permite manipular cadenas. Con esta clase podemos dividir una cadena en tokens, a base de un delimitador, donde un delimitador puede ser un pipe(|),asterisco(*),ampersan(&), una coma(,) que es el más utilizado en la separación de textos en archivos planos, y otros más.
También podemos pasarle a esta clase la cadena sin el parámetro del delimitador de separación, en donde la clase hace una revisión de forma implicita para nosostros de " \t\n\r\f" , y realiza la separación de la cadena.
Está clase tenemos muchas formas de implementarlas por ejemplo:
Si tenemos un archivo de texto el cual está separado por coma, solo queda leer el archivo creando una cadena con los datos obtenidos y luego le decimos a la clase StringTokenizer que nos separe la cadena por coma.
Hagamos un ejemplo donde asumimos que ya obtuvimos la cadena del archivo y le decimos a la clase StringTokenizer que nos la separe por coma



import java.util.StringTokenizer;

public class Token {

    private String token;
    private String cadena;
    StringTokenizer tk;

    public Token(String cad,String tok ) {
        this.token = tok;
        this.cadena = cad;
    }

    public Token(String cad) {
        this.cadena = cad;
    }

    public void desglosar() {


        if (token == null) {
            tk = new StringTokenizer(cadena);

        } else {
            tk = new StringTokenizer(cadena, token);
        }

    }

    public StringTokenizer getToken() {
        return tk;
    }

    public int cantidadToken() {
        if (getToken() == null) {
            return 0;
        } else {
            return getToken().countTokens();
        }
    }

    public void imprimir() {
        desglosar();
        if (getToken() != null) {
            if (cantidadToken() > 0) {
                while (getToken().hasMoreTokens()) {
                    System.out.println("||===> " + getToken().nextToken());
                }
            }
        }
    }
    @Override
    public String toString(){
        String finalcad="";
      desglosar();
        if (getToken() != null) {
            if (cantidadToken() > 0) {
                while (getToken().hasMoreTokens()) {
                   finalcad += getToken().nextToken()+"\n";
                }
            }
        }
      return finalcad;
    }
    public static void main(String arg[]) {

        
      String cad = "uno dos tres cuatro cinco seis siente ocho nueve diez";
      String cad2= "uno,dos,tres,cuatro,cinco,seis,siente,ocho,nueve,diez";
        
        Token tk;
        Token tk2;
        
        tk  = new Token(cad);
        tk2 = new Token(cad2,",");
        System.out.println("||==================================||");
        tk.imprimir();
        System.out.println("||==================================||");
        tk2.imprimir();
        System.out.println("||==================================||");
        System.out.println(tk);
        System.out.println("||==================================||");
    }
}

El resultado es
Leer más...

buscar Mayúsculas


Con la clase pattern podriamos realizar la búsqueda con menos líneas de código.
Pero para este caso vamos hacerlo de una forma sencilla recorriendo una cadena.
Suponiendo que recibimos una cadena y necesitamos saber si en esa cadena se encuentran mayúsculas



public boolean esMayuscula(String cadena){

boolean trueOrFalse = false;

int tamanioCadena, inicioFor;

tamanioCadena = cadena.length();

for (inicioFor = 0; inicioFor < tamanioCadena; inicioFor++) {

int datoChar = (int) cadena.charAt(inicioFor);
if (datoChar >= 65 && datoChar <= 90) {
trueOrFalse = true;
break;
}

}

return trueOrFalse;
}
Leer más...

BufferedReader

Los programas de java realizan su entrada y salida a través de flujos.
Podemos decir que flujo es una abstración que produce y consume información.
Todos los flujos se comportan de la misma manera, aunque sean dispositivos.
Dado esto todos los métodos y clases de entrada y salida se pueden aplicar a cualquier tipo de dispositivos.
Es decir que si queremos utilizar un método para escribir en consola también lo podemos emplear para escribir en un archivo en el disco.

Para este caso estaremos viendo la lectura de un teclado empleado las clases BufferedReader ,InputStreamReader y System.

BufferedReader: Es una clase del paquete java.io que permite manejar el flujo de caracteres de entrada almacenado en búfer.
Con esta clase podemos leer u obtener los datos introducidos mediante el teclado y también los datos que se encuentren en la primera línea de un archivo.

InputStreamReader: Es una clase del paquete java.io que permite traducir los bytes, capturados a caracteres. Para usar la internacionalización con caracteres acentuados y demás podemos agregar la codificación ISO-8859-1.

System: Es una clase del paquete java.lang, java.lang es un paquete que todos los programas importan automáticamente, esta clase tiene 3 variables declaradas de manera public y static, esto permite que se pueda emplear sin crear realizar una instancia en especifico. Estos métodos son in,out y err.
in: este campo hace referencia a la entrada estándar que viene siendo el teclado.
out: este campo hace referencia a la salida estándar que viene siendo la consola.
err : Este campo hace referencia al flujo de error estándar que viene siendo la consola.

Crearemos una clase de nombre Teclado, y le agregaremos un método de nombre lectura()




import java.io.BufferedReader;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Teclado {

    public static String lectura() throws IOException {
        String dato = "";
        BufferedReader leer;
        leer =
                new BufferedReader(new InputStreamReader(System.in,"ISO-8859-1"));
        dato = leer.readLine();

        return dato;
    }   
}


Luego le agregamos el método main


public static void main(String arg[]) {
        try {
            System.out.print("Introduza su nombre : ");
            String lectura = Teclado.lectura();
            System.out.println("Su nombre es ==> "
                    + lectura);
        } catch (IOException ex) {
            System.err.println("Error causado durante la lectura ==  >" + ex);
        }
    }





Código completo



import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Teclado {
public static String lectura() throws IOException {
String dato = "";
BufferedReader leer;
leer  = 
new BufferedReader(new InputStreamReader(System.in));
dato = leer.readLine();
return dato;
}

public static void main(String arg[]){
try {
System.out.print("Introduza su nombre : ");
String lectura = Teclado.lectura();
System.out.println("Su nombre es ==> " + lectura);
} catch (IOException ex) {
System.err.println("
Error causado durante la lectura ==>" + ex);
}
}
}

Leer más...

Mostrar carpetas en forma recursiva


Mostrar direcotorios en forma recursiva.
La clase File de java contiene diferentes métodos para el manejo de archivos, entre estos tenemos el método listFiles().
Este método nos retorna un arreglo de tipo File[].

File[] archivos = path.listFiles();

Con esto podemos crear un método que según la ruta que le demos obtenga los archivos y directorios que se encuentran en el path.


public static void mostrarDirectorios ( File path ) {
File[] archivos = path.listFiles(); int tamanio = archivos.length; System.out.println(path); for ( int i=0 ; i < tamanio ; i++ ) {
System.out.println( archivos[i].getAbsolutePath() ); if ( archivos[i].isDirectory() ) {
mostrarDirectorios( archivos[i] );
}
}
}
Leer más...

Calcular edad

Manejos de Fechas http://java.sun.com/j2se/1.4.2/docs/api/java/util/GregorianCalendar.html


En ocaciones nos hemos visto en la necesidad de obtener los años transcurrido en un rango de fecha, que para este caso solo obtenemos los años y no los meses ni los días transcurridos.
Un algoritmo corto y sencillo que nos ayuda.



/**Método que calcula la edad a partir de dos fecha, retorna un entero
*parametros: pNacio es la fecha en que la persona nació.
*pFecha = es la fecha en la que apartir de esta fecha se quiere calcular.
*/

public int calcularEdad(Date pNacio,Date pFecha){

      Calendar fecha = new GregorianCalendar();
      fecha.setTime(pNacio);
       int diaNacio = fecha.get(Calendar.DATE);
       int mesNacio = fecha.get(Calendar.MONTH)+1;
      int anoNacio = fecha.get(Calendar.YEAR);
      fecha.setTime(pFecha);

      int anoFecha = fecha.get(Calendar.YEAR);
      int mesFecha = fecha.get(Calendar.MONTH)+1;
      int diaFecha = fecha.get(Calendar.DATE);

      int difAno = anoFecha - anoNacio;
      int difMes = mesFecha - mesNacio;
      int difDia = diaFecha - diaNacio;

      if(difMes <0){

         difAno-=1;

      }else if(difMes == 0){

           if(difDia < 0){
             difAno-=1;
      }  

      }


         return difAno;
      }
Leer más...