LECTURA DE FICHEROS CON 'JAVA.UTIL.SCANNER'

El otro día me encontré una clase JAVA bien interesante, se llama java.util.Scanner y buscando su significado supe que utiliza comúnmente para una scanero de ficheros línea por línea y obtención de sus datos, tiene bastante métodos interesantes y la verdad su manejo me trajo a la mente la clase java.util.StringTokenizer ya que trabaja casi idénticamente solo que java.util.Scanner aparece en JAVA en la versión 1.5. Aquí muestro un ejemplito en donde leo un Fichero línea por línea y sus datos separados por el símbolo "–" me permiten diferenciar cada dato y con esto amarrar los datos a un objeto usuario para hacerlo mas interesante el ejemplo y de paso orientar a objetos el demo. El código es el siguiente:

//Test_Scanner.java

import java.io.File;
import java.io.IOException;
import java.util.Scanner;

/**
* @author: cguerra.
* @clase: Test_Scanner.java
* @descripción: descripción de la clase.
* @author_web: http://frameworksjava2008.blogspot.com -
* http://viviendoconjavaynomoririntentandolo.blogspot.com
* @author_email: cesarricardo_guerra19@hotmail.com.
* @fecha_de_creación: 22-10-2009.
* @fecha_de_ultima_actualización: 22-10-2009.
* @versión: 1.0
*/
public class Test_Scanner{

/**
* @param args
* @throws IOException
*/
public static void main( String... argumentos ) throws IOException{

Test_Scanner scanner = new Test_Scanner();
scanner.manejoScanner();
}

/**
* manejoScanner
*/
public void manejoScanner(){
try{
File archivo = new File( "C:\\MiArchivo.txt" );
Scanner lectorLinea = new Scanner( archivo );
Scanner lectorDatos = null;
Usuario usuario = null;

for( ; lectorLinea.hasNext(); ){

//Obtiene las lineas del 'Fichero'.
String linea = lectorLinea.nextLine();
//Escanea cada linea del 'Fichero'.
lectorDatos = new Scanner( linea ); lectorDatos.useDelimiter( "-" );

for( ; lectorDatos.hasNext(); ){

String codigo = ( lectorDatos.next() );
String nombres = ( lectorDatos.next() );
String apellidos = ( lectorDatos.next() );
String edad = ( lectorDatos.next() );
String dni = ( lectorDatos.next() );

Usuario = new Usuario(
Integer.parseInt( codigo ),
nombres,
apellidos,
Integer.parseInt( edad ),
dni );

//Crea un Nuevo Usuario.
System.out.println( "" );
System.out.println( "Codigo: " + usuario.getId() );
System.out.println( "Nombres: " + usuario.getNombres() );
System.out.println( "Apellidos: " + usuario.getApellidos() );
System.out.println( "Edad: " + usuario.getEdad() );
System.out.println( "Dni: " + usuario.getDni() );
System.out.println( "" );

}
}
}
catch( IOException e ){
e.printStackTrace();
}
catch( Exception e ){
e.printStackTrace();
}
}
}


//Usuario.java

import java.io.Serializable;

/**
* @author: cguerra.
* @clase: Usuario.java
* @descripción: descripción de la clase.
* @author_web: http://frameworksjava2008.blogspot.com -
* http://viviendoconjavaynomoririntentandolo.blogspot.com
* @author_email: cesarricardo_guerra19@hotmail.com.
* @fecha_de_creación: 22-10-2009.
* @fecha_de_ultima_actualización: 22-10-2009.
* @versión: 1.0
*/
public class Usuario implements Serializable{

private static final long serialVersionUID = 936463798820971716L;

private int id;
private String nombres;
private String apellidos;
private int edad;
private String dni;

//Constructores ...
public Usuario(){
}

public Usuario( int id, String nombres, String apellidos,
int edad, String dni ){
this.id = id;
this.nombres = nombres;
this.apellidos = apellidos;
this.edad = edad;
this.dni = dni;
}

public int getId(){
return id;
}

public void setId( int id ){
this.id = id;
}

public String getNombres(){
return nombres;
}

public void setNombres( String nombres ){
this.nombres = nombres;
}

public String getApellidos(){
return apellidos;
}

public void setApellidos( String apellidos ){
this.apellidos = apellidos;
}

public int getEdad(){
return edad;
}

public void setEdad( int edad ){
this.edad = edad;
}

public String getDni(){
return dni;
}

public void setDni( String dni ){
this.dni = dni;
}

public static long getSerialVersionUID(){
return serialVersionUID;
}

}

//MiArchivo.txt
001-Cesar Ricardo-Guerra Arnaiz-26-41816133
002-Catherine Magaly-Cotrina Vasquez-24-49866233

ACTIVAR Y DESACTIVAR 'ASSERT' EN ECLIPSE

Algo raro y común que sucede, cuando se desea trabajar con ASSERT en ECLIPSE es que por defecto no esta habilitado y la pregunta es como habilitarlo ???. Aqui la soluciòn:

Windows -> Preferences -> Java -> Installed JREs.

Luego selecciona tu JDK y click el boton Edit y en el textfield "Default VM Arguments" agregar los còdigos siguientes, dependiendo como se desee trabajar:

-ea
Activa las 'Aserciones' de mi programa.

-da
Desactiva Las 'Aserciones' de mi programa.

-ea:class
Activa las 'Aserciones' de mi programa, pero sólo en la clase class.

-da:class
Desactiva las 'Aserciones' de la clase class.

-ea:package...
Activa las 'Aserciones' de mi programa; pero sólo en el paquete package.

-da:package...
Desactiva las 'Aserciones' del paquete package.

LABELED & UNLABELED EN BUCLES

Un gran aporte que da Java 1.6 es el manejo de Labels por cada ‘For’ utilizado, estos Labels son etiquetas que están directamente relacionadas a cada ‘For’ y la gran ventaja que te da es la facilidad de poder hacer un Break or Continue de un ‘For’ anidado Hijo a Otro ‘For’ que esta como Padre. El manejo es de la siguiente forma:

public class Test{

//Descomentar el ejemplo que se quiera ejecutar.
public static void main( String… args ){
Test test = new Test();
test.forUnLabeled (); //Habilitar el 1er ejemplo.
//test.forLabeled (); //Habilitar el 2do ejemplo.
}

/**
* forUnLabeled se muestra un For anidado simple.
*/
public void forUnLabeled(){

String cadena = "Ricardo X Guerra";
String newCadena = "";

//Forzando un bucle infinito.
for( int i=0; i Character caracter_01 = (Character)cadena.charAt( i );
newCadena += caracter_01;

System.out.println( "'FOR' [PAPA]==>: " + caracter_01 );

if( caracter_01 == 'X' ){

for( int j=10; j>=0; j-- ){
System.out.println( "'FOR' [HIJO]==>: " + j );
}
}
}
}

/**
* forLabeled se muestra un For anidado con una Etiqueta (Labeled) en su interior que
* esta asignada un cada 'For', permitiendo con esto desde un 'For' hijo hacer
* un Break a un 'For' Padre.
*/
public void forLabeled(){

String cadena = "Ricardo X Guerra";
String newCadena = "";

TagForPapa: //Etiqueta del 1er 'For'
//Forzando un bucle infinito.
for( int i=0; i Character caracter_01 = (Character)cadena.charAt( i );
newCadena += caracter_01;

System.out.println( "'FOR' [PAPA]==>: " + caracter_01 );

if( caracter_01 == 'X' ){

TagForHijo: //Etiqueta del 2do 'For'
for( int j=5; j>=0; j-- ){
System.out.println( "'FOR' [HIJO]==>: " + j );
}

break TagForPapa; //Manda a parar el 1er 'For' desde el 2do 'For'.
}
}
}

MANEJO BUCLE 'FOR' COMO 'WHILE'.

Java te da la verdad muchas ventajas a comparación de otros lenguajes de programación, una de ella es el trabajar los bucles de distintas maneras una de ellas y de la que hablaré a continuación es sobre el manejo de un bucle For pero trabajado de una forma distinta a la comúnmente conocida ya que un For lo trabajar para iterar: cadenas, arrays, listas, etc pero siempre como un limitante en su interior peroahora vamos a ver una forma distinta de trabajar el For sin dicho limitante, un trabaja que normalmente esta destinado a un While o a un Do While. El manejo es de la siguiente manera:

public class Test{

//Descomentar el ejemplo que se quiera ejecutar.
public static void main( String… args ){
Test test = new Test();
test.forWhileIliminado(); //Habilitar el 1er ejemplo.
//test.forWhileLimitado(); //Habilitar el 2do ejemplo.
}

/**
* forWhileIliminado aqui se muestra el manejo de un FOR/WHILE Ilimitado, ya que dicho For iterará infinitamente, porque no tiene una confición de Stop en su interior.
*/
public void forWhileIliminado(){

int contador = 0;

//Forzando un bucle infinito.
for( ; ; ){

contador += 1;

System.out.println( "CONTANDO ... " + contador );
}
}

/**
* forWhileLimitado aqui se muestra el manejo de un FOR/WHILE limitado, ya que en dicho For estamos
* condicionando un toque que es '654321' y si se llega a ese numero el Bucle
* para ( break,System.exit( 0 ), return ) sino continua su recorrido infinito
* (continue) .
*/
public void forWhileLimitado(){

int contador = 0;

//Forzando un bucle infinito.
for( ; ; ){

contador += 1;

if( contador == 654321 ){
System.out.println( "EL 'CONTADO' LLEGO A SU [FIN] EN: " + contador + " ...!!! " );
break; //Parar el 'LOOP'.
//System.exit( 0 ); //Parar el 'LOOP'.
//return; //Parar el 'LOOP'.
}
else{
System.out.println( "CONTANDO ... " + contador );
continue; //Continuar el 'LOOP'.
}
}

}

}

JAVA REFLEXION

Hace unos días estuve indagando en el manejo de interno que comúnmente los Frameworks de JAVA utilizan y me tope con el tema de Reflexion. Este tema de Reflexion. es uno de los temas más avanzados que JAVA y su programación orientada a objetos maneja, la reflexión es comúnmente utilizada cuando se quiere examinar o modificar en tiempo de ejecución el comportamiento de las aplicaciones. Por ejemplo, sabiendo el nombre de una clase, podríamos saber:

Propiedades, campos, constructores, métodos, clases, interfaces, etc.
Este es un concepto que permite la programación dinámica, es como cuando uno obtiene la metadata de una tabla, pero en este caso es la metadata de una clase.

Se puede instanciar objetos, solo con saber el nombre de la clase, o ejecutar sus métodos en tiempo de ejecución.

El demo presentando preparado es una clase utilitaria que maneja el concepto de un POJO, esta clase brinda mediante métodos de acceso una seria de métodos como estos:

• public Method[] getArrayMetodos( Class claseProcesar ) ...
• public Method[] getArrayMetodos( String rutaClaseProcesar ) ...
• public Class[] getArrayInterfaces( Class nombreClaseProcesar ) ...
• public Class[] getArrayInterfaces( String rutaClaseProcesar ) ...
• public Field[] getArrayCamposDeclarados( Class nombreClaseProcesar ) ...
• public Field[] getArrayCamposDeclarados( String rutaClaseProcesar ) ...
• public String getClasePadre( String rutaClaseProcesar ) ...
• public String getClasePadre( Class nombreClaseProcesar ) ...
• public String getClasePadre( String rutaClaseProcesar ) ...
• public String getRutaPaquete( Class nombreClaseProcesar ) ...
• etc ...


Para descargar el demo pulsar:
AQUÌ.

LIBERACIÓN DE MEMORIA CON JAVA Y EL GARBAGE COLECTOR

Estudiando un día mi libro de certificación llegue al tema del manejo del Garbage Colector en JAVA y encontré temas muy importantes e interesantes que no sabía como que el Garbage Colector uno no puede ser forzado a pasar y liberar memoria, sino que cuando uno cuando en su aplicación genera X procesos que son muy pesados la memoria puede incrementarse a tal punto que le puede aparecer una Excepcion [java.lang.OutOfMemoryError] refiriéndose que ya no hay memoria suficiente y automaticamente tu aplicación se cuelga, para ello este método que acontinuación implemento puede ser llamado. Dicho ejemplo muestra un simple Test, en el que se imprime el total de memoria que se maneja al inicio, el total de memoria libre que queda luego de ejecutar un 'For' GIGANTE y el total de memoria que queda luego de ejecutar el método de liberacion de memoria que hace una solicitud a la JVM, para que el Garbage Colector pase:


import java.sql.Date;

/**
* @author: Ricardo Guerra.
* @clase: TestGarbageColector.java
* @descripción: Clase utilizada para probar el manejo del Garbage Colector en casos que las aplicaciones
* consuman mucha memoria.
* @author_web: http://frameworksjava2008.blogspot.com
* http://viviendoconjavaynomoririntentandolo.blogspot.com
* @author_email: cesarricardo_guerra19@hotmail.com.
* @fecha_de_creación: 05-08-2009.
* @fecha_de_ultima_actualización: 20-03-2009.
* @versión: 1.0
*/
public class TestGarbageColector{

/**
* @param args
*/
public static void main( String[] args ){
TestGarbageColector test = new TestGarbageColector();
test.testGarbageColector();
}

/**
* testGarbageColector Método que prueba un incremento de memoria para ver el manejo de la
* liveracion de esta al solicitar a la 'JVM' el 'GC'.
*/
public void testGarbageColector(){

Date fecha = null;

for( int i=0; i<1000000; i++) {
fecha = new Date( 10, 10, 2009 );
fecha = null;
}

//Solicitamos a la 'JVM' el 'GC', para liverar memoria.
this.getSolicitaGarbageColector();
}

/**
* getSolicitaGarbageColector Método que invoca al Garbage Colector( NO LO FUERZA a venir,
* envia una solicitud a la JVM para su proceso..!!! )
*
*/
public void getSolicitaGarbageColector(){

try{
System.out.println( "********** INICIO: 'LIMPIEZA GARBAGE COLECTOR' **********" );
Runtime basurero = Runtime.getRuntime();
System.out.println( "MEMORIA TOTAL 'JVM': " + basurero.totalMemory() );
System.out.println( "MEMORIA [FREE] 'JVM' [ANTES]: " + basurero.freeMemory() );
basurero.gc(); //Solicitando ...
System.out.println( "MEMORIA [FREE] 'JVM' [DESPUES]: " + basurero.freeMemory() );
System.out.println( "********** FIN: 'LIMPIEZA GARBAGE COLECTOR' **********" );
}
catch( Exception e ){
e.printStackTrace();
}
}
}

El resultado en CONSOLA obtenido es el siguiente:


********** INICIO: 'LIMPIEZA GARBAGE COLECTOR' **********
MEMORIA TOTAL 'JVM': 4194304
MEMORIA [FREE] 'JVM' [ANTES]: 1137312
MEMORIA [FREE] 'JVM' [DESPUES]: 3749208
************ FIN: 'LIMPIEZA GARBAGE COLECTOR' ***********

DBHelper v2.0

Pensando en los diferentes problemas de sintaxis que a diario se presentan cuando uno trabaja en el Àrea de Sistemas como: P, AP, DBA en la creaciòn y manipulaciòn de datos en diferentes Motores de Datos, creè DBHelper v2.0.

DBHelper v2.0 es una aplicación hecha en JAVA SWING con la finalidad de brindar ayuda a los desarrolladores, DBA's, etc. en lo que respecta a la sintaxis para la construcción de:

Stores Procedure, Fuction, View, Trigger, Package, Sequence.

En los diferentes y muy conocidos Motores de Datos:

Oracle, MySql, Postgres, SqlServer.

Ya que dicha sintaxis varìa según el Motor de Datos utilizado, en lo que respecta a delaraciòn de variables, nombres de funciones internas, asignaciones, etc. Ya que todos los Motores de Datos estàn orientados a un mismo Lenguaje de Programaciòn como base que es el SQL y de ese ya nacen los personalizados que varian un poco como son:

PLSQL, TRANSACSQL, PGSQL, etc.

DB_JavaHelper esta orientado a ayudar en lo que a sintaxis por Motor de Datos respecta y muestra tambien como probar cada uno, dando una plantilla base para cada Motor de Datos para cada procediento a realizar.



Requisitos Previos: DB_JavaHelper, esta creado para trabajar con JAVA 1.6 y es IMPORTANTE el NO cambiar los nombres de las carpetas y ejecutables encontrados dentro del comprimido. Simplemente se descomprime el .zip, se guarda un una ruta respectiva y se crea un acceso directo al ejecutable (DB_JavaHelper.jar).

- NOMBRE CARPETA RAIZ = DB_JavaHelper
- NOMBRE CARPETA_SCRIPT = Script
- NOMBRE EJECUTABLE = DB_JavaHelper.jar

Desde DB_JavaHelper tambien se puede descargar los Script por BD, los cuales sirvieron de base para las plantillas mostradas en los ejemplos.

Para descargar DB_JavaHelper pulsar:
AQUÌ.