bibigeek.com  Tu blog de Programación Geek: Java, php, J2EE... y mucho más

Archive for the ‘ Java ’ Category

En el trabajo estamos constantemente al pie del cañon para introducir mejoras, nuevos métodos de trabajo, nuevas tecnologías o simplemente mejorando las tecnología actual (no siempre se puede)… y en un nuevo proyecto que está llevando a cabo Andrés Nieto, tenemos la posibilidad de introducir MUCHAS MEJORAS y una de ellas es: “Leer de ficheros .properties”

La verdad que no pensaba que fuera tan fácil, pero para aquellos que deseen realizar aquí les dejo la solución de cómo hacerlo y algunos consejos JAVADIENSES :P :P

Leer de ficheros PROPERTIES desde JAVA (teoría)

1. Primera cosa a tener en cuenta, necesitamos el nombre de un fichero con la extensión .properties y la ruta pertinente.
Supongamos que estamos en la raiz, ejemplo:
- Mac: /Users/<nombre usuario>/config.properties
- Linux: /home/<nombre usuario>/config.properties
- Windows: C:/config.properties

2. Necesitaremos abrir el fichero y leer su contenido. Para ello utlizaremos la clase FileInputStream.

3. Después de abrirlo ya podremos utilizar la clase Property.

Código para leer ficheros .properties en  Java (ejemplo prático)

1. Veamos como abrimos el fichero con la clase Java:


/* Atributos necesarios */
FileInputStream file = null;
/* Abrimos el fichero properties para leer de el */
try {
   file = new FileInputStream(pathName);
} catch (FileNotFoundException ex) {
   ex.printStackTrace();
} catch (IOException e) {
   e.printStackTrace();
}

2. Dado un objeto FileInputStream creamos un objeto Property y leemos del fichero:


/* Instanciamos el objeto Properties */
Properties propers = new Properties();
try {
   propers.load(file);
} catch (IOException ex) {
   ex.printStackTrace();
}

3. Ahora necesitamos obtener un objeto HashMap para leer u obtener el resultado:


/**
 * METODO PUBLICO QUE DEVUELVE UN OBJETO HASHMAP CON LOS VALORES
 * DEL FICHERO .PROPERTIES
 *
 * @param name, string con el path y el nombre del fichero .properties a leer
 * @return HashMap con los valores, de lo contrario devolvemos null
 */
public HashMap getProperties(String name) {
	/* Atributos necesarios */
	FileInputStream file = null;

	/* Abrimos el fichero properties para leer de el */
	try {
		file = new FileInputStream(name);

		/* Instanciamos el objeto Properties */
		Properties propers = new Properties();
		try {
			propers.load(file);
		} catch (IOException ex) {
			ex.printStackTrace();
		}finally {
			try {
				/* Cerramos el fichero desde de leerlo */
				file.close();
			} catch (IOException ex) {
				ex.printStackTrace();
			}
		}

		/* Return */
		if (!propers.isEmpty())
			return new HashMap(propers);

	} catch (FileNotFoundException ex) {
		ex.printStackTrace();
		return null;
	} catch (IOException e) {
		e.printStackTrace();
		return null;
	} catch (NullPointerException nulo){
		nulo.printStackTrace();
		return null;
	} catch (Exception excep){
		excep.printStackTrace();
		return null;
	}

	return null;
}

Conclusión

Con este útlimo método podremos obtener un objeto HashMap con los valores de un fichero .properties cualquiera. En el caso que se produzca un error, devolveremos null (eso ya va a vuestro gusto, tambien podríais devolver un HashMap vacío así: return new HashMap() ).

Espero que os haya servido!!!!!

Dios mio… ya tenemos disponible para descargar el nuevo Netbeans 6.8. Vaya rapidez!

Netbeans 6.8

En fin que yo estoy probando el Netbeans 6.8 (NO BETA) para descargar. Desde mi punto de vista sigue siendo el mejor entorno de trabajo… “peroooo que conste en acta” es bastante pesado, aunque si no tenéis que utilizar muchos frameworks (por ejemplo en Java FX) o si no necesitáis soporte para el Java ME y a la hora de instalarlo lo deseleccionáis, notaréis una mejoría en la velocidad.

Yo desde un VirtualBox que tengo en el trabajo instalada una distribución Ubuntu Karmic Koala, asignándole 512 MB de Ram, procesador Pentium 4 a 2.8 GHz, eliminando las aplicaciones expuestas anteriormente, y con un montón de aplicaciones rulando en mi windows… VA BIEN!!!! Os adjunto las imágenes para que sepáis que tenéis que eliminar:

Eliminar Opciones

Instalacion Mejorada

Para descargar el nuevo Netbeans versión 6.8 pulsar el link.

Buenas,
Ya estoy de nuevo otra vez. Siento el retraso, no es que haya abandonado el blog :P , he estado super liado con cursos en la empresa y la verdad que no me ha permitido dedicarme mucho al blog.

Hoy vamos hablar de nuevo sobre las fechas en Java, es un tema tan amplio que pienso que aun me quedan múchisimos posts para escribir sobre el tema.
Veamos, este Post en concreto, tiene mucho que ver con el anterior que escribí sobre fechas: como utilizar correctamente las fechas en Java. ¿Por qué? Porque es realmente importante utilizar las herramientas que proporciona Java para las fechas, ya que a veces cuyas herramientas tienen en cuenta factores que nosotros no podemos controlar, como ejemplo podéis leer el Post del link anterior y lo comprobaréis con vuestros ojos.
Hoy voy a explicar una cosa que me he dejado en todos los Posts de Java que he escrito anteriormente, y que omití (perdonadme):

¿Qué herramienta utilizar para restar dos fechas en Java? ¿Qué utilizar para obtener la diferencia entre dos fechas en java?

Yo recomiendo, plenamente, utilizar el GregorianCalendar. Es lo que comentaba antes, hay que utilizar las herramientas de Java destinadas a la solución/manejo del tema a tratar, en este caso las Fechas.

¿Por qué no utilizar la clase Date? Si miráis minuciosamente la API de la clase Date, podréis comprobar que muchos de los métodos están siendo Deprecated y SUN están dando más relevancia las clases Calendar, Gregorian Calendar, etc.

Con eso no quiero decir que funcione mejor o peor una Clase u otra, pero desde mi punto de vista siempre hay que utilizar las clases idóneas. Reitero, MI PUNTO DE VISTA.

¿Cómo restar dos fechas en Java? ¿Cómo obtener la diferencia entre dos fechas en Java?

Necesitamos los siguientes datos para calcular la resta:

  1. Tener dos objetos GregorianCalendar o Date (ya sea obtenidos con string, con Calendar, etc…)
  2. Efectuar operaciones matemáticas simples (como mucho una multiplicación) sin que intervengan los milisegundos :P

A este punto voy a dividirlo en dos subpuntos: restar fechas del mismo año o restar fechas de distinto año. Empecemos:

Restar dos Fechas en Java que son del mismo año


/*CREAMOS EL GREGORIAN CALENDAR DE LAS DOS FECHAS*/
GregorianCalendar t1 = new GregorianCalendar(2009,9,23);
GregorianCalendar t2 = new GregorianCalendar(2009,9,28);

/*RESTAR FECHAS*/
int dias =  t2.get(Calendar.DAY_OF_YEAR) - t1.get(Calendar.DAY_OF_YEAR);

/*IMPRESION POR PANTALLA*/
System.out.println("Valor de días es: " + dias);

Están fácil como esto, RESTAR y PUNTO. Salida por pantalla es:


Valor de días es: 5

Se puede dar el caso de que necesitemos crear los dos objetos GregorianCalendar dados dos objetos Date. El código quedaría así:


        /* CREAMOS LOS OBJETOS GREGORIAN CALENDAR PARA EFECTUAR LA RESTA */
        GregorianCalendar date1 = new GregorianCalendar();
        date1.setTime(dateIni); //dateIni es el objeto Date

        GregorianCalendar date2 = new GregorianCalendar();
        date2.setTime(dateFin); //dateFin es el objeto Date

¿Qué problemas puede conllevar esto?
Pues el problema está cuando cogemos dos fechas de distinto año, el problema que puede darse es que el número no sea el correcto o el que esperamos. Veamos como es la salida por pantalla de la resta de las fechas: 2009/12/25 y 2010/01/02 (teóricamente deberían ser 8 días):


Valor de días es: -357 //( si le restásemos 365 días que tiene el año daría 8) 

Restar dos Fechas en Java de diferente año

Gracias al comentario anterior, y buscando en san Google se me ocurrió la brillante idea (que buscando, buscando, también lo encontré en un foro inglés :-( ) de hacer lo siguiente:


        /*CREAMOS EL GREGORIAN CALENDAR DE LAS DOS FECHAS*/
        GregorianCalendar date1 = new GregorianCalendar(2009,11,25);
        GregorianCalendar date2 = new GregorianCalendar(2010,0,2);

        /* COMPROBAMOS SI ESTAMOS EN EL MISMO ANYO */
        if (date1.get(Calendar.YEAR) == date2.get(Calendar.YEAR)) {
            System.out.println( "Valor de Resta simple: " +String.valueOf(date2.get(Calendar.DAY_OF_YEAR) - date1.get(Calendar.DAY_OF_YEAR)));
        } else {
            /* SI ESTAMOS EN DISTINTO ANYO COMPROBAMOS QUE EL ANYO DEL DATEINI NO SEA BISIESTO
             * SI ES BISIESTO SON 366 DIAS EL ANYO
             * SINO SON 365
             */
            int diasAnyo = date1.isLeapYear(date1.get(Calendar.YEAR)) ? 366 : 365;

            /* CALCULAMOS EL RANGO DE ANYOS */
            int rangoAnyos = date2.get(Calendar.YEAR) - date1.get(Calendar.YEAR);

            /* CALCULAMOS EL RANGO DE DIAS QUE HAY */
            int rango = (rangoAnyos * diasAnyo) + (date2.get(Calendar.DAY_OF_YEAR) - date1.get(Calendar.DAY_OF_YEAR));

        }
        System.out.println("Valor de rangoDias:" + (date2.get(Calendar.DAY_OF_YEAR) - date1.get(Calendar.DAY_OF_YEAR)));
        System.out.println("Valor de rangoAnyos: " + nAnyos);
        System.out.println("Valor de rango: " + rango);

El resultado importante es el de rango, resultado por pantalla es:


Valor de rangoAnyos: -357
Valor de nAnyos: 1
Valor de diasCorrectos: 8

Fijáos que he tenido que controlar la opción del AÑO BISIESTO… que también se tiene que controlar. Si volvéis a mirar el código lo he solucionado con esta simple operacion:


int diasAnyo = date1.isLeapYear(date1.get(Calendar.YEAR)) ? 366 : 365;

También deseo remarcar que he realizado un IF para controlar si la resta se hace con fechas del mismo año o si son diferentes años

Cómo restar con la clase Date (MI OPINIÓN INCORRECTO)

Utilizando los milisegundos es problemático… desde mi punto de vista, INCORRECTO. Problemas con cambios de hora,…


        Date actual = new Date();
        Date fecha =null;
        String dateFrom = "20091023";
        SimpleDateFormat day= new SimpleDateFormat("yyyyMMdd");
        try {
            fecha = day.parse(dateFrom);
        } catch (ParseException ex) {
            ex.getMessage();
            ex.printStackTrace();
        }
        long diferencia= ( fecha.getTime() - actual.getTime() );

        System.out.println("Valor de diferencia: " + diferencia/(1000*60*60*24));

¿Es una opción viable? SÍ, menos cuando hay cambios de hora por el medio. Debemos ir con precaución y repito: mejor utilizar las clases Java preparadas para el problema en cuestión.

Espero que os haya servido de algo, al menos para solucionar algún problema o ayudaros a entender un poco más las fechas en Java.

ACTUALIZACIÓN

Actualizo este post por el mero echo que aNieto2K me ha sugerido que pusiera estadísticas :P . Lo sé Andrés, tengo que currarmelo más jejeje.

[More]

Gracias que en el trabajo surgen siempre algunas que otras problemáticas, vimos un mal USO de las Fechas utilizando Java en un Servicio concreto. Voy a exponerlo aquí y cómo se ha solucionado.

Repaso de la Clase Date para las Fechas en Java (no es la mejor práctica)

En muchas páginas de Internet, y en algunos que otros libros de referencia, a la hora de crear una fecha se utiliza la Clase Date.
Pero poco a poco, han ido apareciendo nuevas clases para el manejo de Fechas en Java (así cómo se explicó en Posts Anteriores: Parsear Fechas, Utilizar Calendar y operaciones con Gregorian Calendar),  y muchos de los métodos de la clase Date se han ido poniendo como “Deprecated”.

Veamos un repaso de la clase Date:
Repaso 1. Coger el instante actual:


/* FECHA DE ESTE MISMO MOMENTO */
Date fecha = new Date();
System.out.println("Fecha actual: " + fecha);
/* FECHA DE ESTE MISMO MOMENTO */
Date fecha = new Date();
System.out.println("Fecha actual: " + fecha);

La salida por pantalla es el siguiente:


Fecha actual: Mon Sep 28 13:25:15 CEST 2009

Nos tenemos que fijar en una serie de puntos relevantes:

  1. Prueba realizada el 28 de Septiembre del 2009
  2. Y la hora en la cual se construido el objeto Date es a las 13:25:15

Fijaos en la hora, es muy importante… ya que está cogiendo la hora real del momento de la ejecución del constructor.

Repaso 2. Crear un objeto Date dado un String con el día concreto:


/* FECHA DE ESTE MISMO MOMENTO */
Date fecha = new Date();
System.out.println("Fecha actual: " + fecha);

/* CREAMOS LA FECHA (TIPO DATE) Y NOS PASAN UNA DIA CONCRETO (SIN HORA) */
String fechaString = "28092009";

/* FORMATO DE ENTRADA DE LA FECHA - DESPUES RECUPERAMOS EL TIPO DATE */
SimpleDateFormat day= new SimpleDateFormat("ddMMyyyy");
/*INSTACIAMOS UN OBJETO DE TIPO DATE A NULL*/
Date fechaDate = null;
try {
/*CONTRUIMOS UN OBJETO DATE DADO UN STRING DE ENTRADA*/
fechaDate = day.parse(fechaString);
System.out.println("Fecha Dado un String: " + fechaDate);
} catch (ParseException ex) {
ex.printStackTrace();
}

La salida por pantalla es:


Fecha Dado un String: Mon Sep 28 00:00:00 CEST 2009

Vemos algunas diferencias entre la salida anterior y ésta ¿verdad? La hora, exactamente. El día es el mismo, la hora por defecto, si no se la indicamos, el constructor la define como si fueran las 00:00:00.

MAL USO de las Fechas en Java

Si queremos operar con las fechas y la clase Date, será necesario operar en un “lenguaje común” los milisegundos. Para ello necesitamos conocer que:

  • La clase Date tiene un método llamado getTime(), que retorna los milisegundos del objeto Date
  • Tenemos que realizar una multiplicación (Factor de Conversion) para obtener los milisegundos dado el número de días
  • Este factor de conversión se hace como: días * 24 * 60 * 60 * 1000

Veamos un ejemplo de SUMA:
[More]

Ahí va mi segundo Post sobre las mejoras en el Java 5.

Novedad y Mejora Java 5: El For Mejorado (for-each)

Este nuevo bucle es para recorrer Colecciones con una Sintaxis más simple, aunque desde mi punto de vista es más costoso. Veamos su sintaxis:


for(tipo idParam : colección){
          Sentencias;
}

- Necesitamos la colección por la que iterar
- El tipo no es más que la clase de los elementos que contiene esta colección
- Finalmente necesitaremos también un nombre de parámetro (idParam) que representa el elemento de la colección que se va extrayendo en cada iteración

Anidar con el For Mejorado

Sí, podemos anidar con el For Mejorado. Aquí os dejo la sintaxis:


for(tipo id1 : coleccion1){
     for(tipo id2 : coleccion2){
          Sentencias;
     }
}

Ejemplo del For mejorado VS For Clásico


/* Declaramos dos colecciones de tipo Vector */
Vector v1 = new Vector(2);
Vector v2 = new Vector(1);

/* Rellenamos v1 con valores */
v1.add("Soy");
v1.add("Me llamo");

v2.add("Francisco Jose Bibiloni");

/* FOR CLASICO VERSION 1 - recorremos el v1 */
for(int i=0;i<v1.size();i++){
     System.out.println((<Object>v1.get(i)).toString());
}

/* FOR CLASICO VERSION 2 - recorremos v1 */
for(Iterator<Object> i = v1.iterator(); i.hashNext();){
     System.out.println(i.next().toString());
}

/* FOR MEJORADO - recorremos v1 */
for(Object a : v1){
     System.out.println(a.toString());
}

/* FOR MEJORADO ANIDADO - recorremos v1 y v2 */
for(Object a : v1){
     for(Object b : v2){
          System.out.println(a.toString() +" " + b.toString());
     }
}

Espero que os sirva para utilizarlo, ya que es bastante útil y rápido. Ahora bien:

  • ¿Esto crea que a nivel interno tarde más tiempo resolver el bucle?
  • ¿Puede llegar a consumir más recursos?

Para la primera pregunta puedo tener una respuesta, os prometo poner algún benchmark para evaluar si el tiempo de procesamiento varía, y ya de paso pondré algunas estadísticas.

Saludos a tod@s!!!!!!!

Buenas a tod@s,
No es que haya dejado el blog…., pero he tenido mucho curro y no he podido dedicarle mucho tiempo al blog. Ahora espero ayudaros con nuevos POST. Este Post en concretamente van a ser varios…voy a explicar algunas de las mejoras y Novedades que tienen el Java 5, y así me servirá para repasar un poco.

Novedad y Mejora Java 5.0: Colecciones Genéricas

Definición de Colecciones:
Lo podemos definir como una estructura de Datos que almacena otros objetos, las cuales pueden ser recorridas de distintas formas según el tipo de Colección seleccionado.

Colecciones No-Genéricas VS Colecciones Genéricas

Las No – Genéricas:

  • Es el funcionamiento estándard de las Colecciones en Java, que es permitir el almacenamiento de cualquier Clase de Objeto. Por lo tanto se requirirá realizar un CASTING de cada una de las posiciones de la Colección
  • Esto suele ser una gran Fuente de Errores en Tiempo de Ejecución

Las Genéricas:

  • Sólo almacenan Objetos de una Clase
  • Tipo de la Colección se deberá indicar en la declaración de la Variable
  • Obtenemos como beneficio: más rendimiento y menores errores desde Compilación

Cómo Declarar Clases Genéricas


class nombreClase <alias> extends nombreSuperClase{
          /* Contenido Clase */
}

Este alias representa un Tipo que se definirá en Tiempo de Declaración.

Ejemplo:


class MyList<T> extends Vector{
.....
}

[More]

Hola a tod@s,
A la hora de intalar un Netbeans nos dá varias posibilidades de instalar un Servidor/Contenedor de aplicaciones Java (y más lenguajes), pero al no ser necesario lo omitimos (para qué consumir Disco y Tiempo innecesario). Pero llegó el GRAN DÍA!!!!!

Necesitamos un Servidor Tomcat en el Netbeans ya instalado, ¿tenemos que volver a instalar el Netbeans?

La respuesta es ¡NO!

Hoy os voy a comentar y a explicar como poder instalar un Servidor Tomcat (probadas las versiones 5.5 y 6.0) en un IDE Netbeans (ya sea 6.1 o 6.5) ya instalado en nuestro ordeandor.

1. Necesitaremos descargar un Servidor Tomcat, aquí os dejo los links correspondientes según la versión que deseéis:

2. Nos tenemos que descargar la opción “Binary Distributions/Core” la versión .ZIP o .TAR.GZ. Estas versiones contienen los scripts necesarios (para linux – mac -  win) que se utilizan para Netbeans. Os dejo dos imágenes para que veáis que os tenéis que descargar:

tomcat5

tomcat6

[More]

Hola a todos, 

Como de costumbre, cuando me siento con Andrés Nieto (que es cada día, es un honor sentarme con un Master de la Web) solemos entablar noticias, discusiones, … y en una de ellas me comentó la aparición del Nuevo Netbeans 6.7 Beta. Leyendo un poco más sobre los nuevos cambios que aportará el nuevo Netbeans (que no son pocos…), hay un cambio que me ha sorprendido mucho, la incorporación con el Proyecto Kenai.

netbeans 6.7

Gracias a la colaboración de los Proyectos Kenai podemos utilizar la versión Netbeans 6.5 para trabajar con Android.

Seguiré leyendo las novedades para informaros de primera mano cuales son estos cambios, y en español :P , salud@s!!!!

Hola a todos,

¡¡¡El SDK 1.5_r1 de Android Falla para Netbeans!!!

Tras dos comentarios que ha escrito David en el POST de Instalación del SDK de Android, he podido confirmar que el nuevo SDK 1.5_r1 está teniendo problemas con el Plugin de Netbeans, ya que al descargar el nuevo SDK (disponibles desde finales de Abril del 2009) el plugin de Netbeans no reconoce el nuevo SDK 1.5_r1 como una Plataforma Java, por lo tanto, al no reconocerlo no podemos añadir la nueva Plataforma.
Lo que si os recomiendo es instalar el SDK 1.1_r1, este funciona correctamente tanto en Mac, Windows (testeado por un servidor) y gracias a David pruedo verificar que en Ubuntu también funciona correctamente.

En breve os intentaré explicar una posible solución para utilizar el nuevo SDK, ya que seguro que hay cambios, pero no podemos disfrutar de ellos.

Descargar SDK 1.5_r1

Descargar SDK 1.1_r1

Y aqué lo tenéis el tercer POST: “Como Crear un Proyecto Android con Netbeans”

Paso1. Especificar a Netbeans que queremos crear un proyecto

newprojectandroid

Paso2. Después le indicamos la ubicación donde se creará el Proyecto

androidapplication
[More]