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