Leer un Archivo TXT desde JAVA

Muchas de las veces es necesario trabajar en nuestras aplicaciones con datos externos que se encuentran en un archivo. Bueno puse para ello podemos intentar copiar cada uno de ellos dentro de nuestra aplicación cuando los necesitemos que sería lo más fácil si son pocos datos pero que sucede si son cientos?? O miles?? Pues ahí es donde se hace más fácil leer un archivo externo y cargarlo a nuestra aplicación.

Para ello podemos hacer lo siguiente utilizando las librerías dentro del paquete java.io:

Cargamos la ruta de un archivo:

File archivo = new File("C:\\ demo.txt");

Creamos una estructura del tipo FileReader:

FileReader    fileR = new FileReader(archivo);

Lo cargamos en un buffer de lectura para que pueda ser más fácil la lectura:

BufferedReader bufferR = new BufferedReader(fileR);

Con ello podremos recuperar una a una las líneas del archivo mediante:

bufferR.readLine()

Aquí un ejemplo sencillo utilizando un archivo separado por comas (su lectura es igual). descarga

Saludos,

JFormattedTextField y MaskFormatter

Si bien dentro de las aplicaciones bajo swing (java) podemos utilizar un componente como el JTextField para capturar una entra de texto. Pero que sucede si esta entrada debe seguir un formato específico? o posee un tamaño obligatorio al cual debe llegar? Claros ejemplos de esto son al querer capturar un número de telefóno o un número de cédula (DNI).

Para ello se puede utilizar un componente conocido como JFormattedTextField. Al que podemos indicar el formato de nuestra entrada. Lo que tenemos que hacer es crear una instancia de la Clase MaskFormatter en base a un patrón y este enviarlo en el constructor del JFormattedTextField.

MaskFormatter patron = new MaskFormatter(“#########-#”);

JFormattedTextField campoEntrada = new JFormattedTextField(patron);

y listo nuestra entrada será validada, en este caso solo para números.

Si utilizamos NetBeans, deberemos colocar una instancia de la clase AbstractFormatterFactory en la propiedad FormatterFactory del elemento gráfico.

Resulta muy útil en varias ocaciones.

Configurar Notepad++ y UltraEdit para ejecutar aplicaciones Java

Si bien estas aplicaciones permiten la edición de cualquier clase de documento. También se puede aprovechar esto para compilar y ejecutar directamente nuestros códigos.

En Notepad++

Crear un archivo por lotes ‘compiladorJava.bat’ que contenga:

PATH=”ruta del compilador de java: el javac”
TITLE COMPILANDO %1
echo Generando archivo .class
javac %1
echo Corriendo aplicación:
echo.
java %2
pause

En el menú ejecutar del notepad++ escribimos $(NPP_DIRECTORY) ejecutamos. En la siguiente ventana pegamos nuestro archivo ‘compiladorJava.bat’

Una vez guardado el archivo por lotes ejecutamos el siguiente texto:

$(NPP_DIRECTORY)\compilar_java.bat $(FILE_NAME) $(NAME_PART)

y listo nos aparecerá una nueva opción bajo el menú Ejecutar.

En UltraEdit

Nos dirigimos a la opción ‘Configuración de herramientas’ en el menú Avanzado y colocamos lo siguiente:

• En nombre del item:

CompiladorJava

• En línea de comando:

javac “%n%e”   (Si tenemos agregado el compilador como variable de entorno)
o
c:\Archivos de programa\Java\jdk1.6.0\bin\javac “%n%e”

• En el directorio de trabajo:

%p

• En la pestaña Salida marcamos las opciones:

Capturar salida

Salida al cuadro de lista y damos en Insertar.

Ahora colocamos el nombre del item como ejecutarJava

• En línea de comando:

java “%n”   (Si lo tenemos agregado como variable de entorno)
o
c:\Archivos de programa\Java\jdk1.6.0\bin\java “%n”

• En el directorio de trabajo:

%p

• En la pestaña Salida marcamos las opciones:

Capturar salida
Salida al cuadro de lista

Hecho esto deberán aparecer dos nuevas opciones en el menú avanzado y con esto podremos compilar y ejecutar archivos java.

Y listo ahora podemos crear nuestro código  ejecutarlo desde la misma aplicación.

Saludos,

La Sincronización de Procesos.

Dentro de los Sistemas Operativos los procesos que se ejecutan son muy variados, algunos utilizan la cpu para realizar de lectura de memoria, u otros campos que competen a la aplicación. Y también los mismos pudieran modificar los datos que leen. Pero que sucede si dos o mas procesos tienen que hacer estas operaciones? Es decir por ejemplo el modificar los datos que un proceso esta leyendo.

Pues es aquí en donde el caos podría entrar, pues la información podría ser modificada sin previo aviso o suceder acciones que no estaban planteadas. Para esto se plantea la Sincronización de Procesos.

Esto consiste en utilizar estructuras algorítmicas que permitan implementar el control de los procesos o hilos que se van a ejecutar de acuerdo a condiciones dadas, para que no se produzca situaciones como Bloqueos, Bloqueos mutuos(inanición) o accesos a secciones críticas del programa que no pueden ser accedidas en ese momento.

Para este control los algoritmos emplean sentencias(o pedazos de código) conocidos como semáforos o monitores.

Semáforos.- Se los considera como variables enteras que poseen solo dos métodos a través de los cuales se puede acceder a ellos. Lo que condiciona la entrada a zonas críticas o uso de recursos.

Monitores.- En cambio son estructuras más avanzadas de alto nivel que permiten mayor control que si son empleados correctamente permiten detectar error de temporización conocidos como timing.

Dentro de este ámbito de la Sincronización se han planteado numerosos casos como el de los filósofos comensales, el barbero dormilón y otros muchos más.

A continuación pueden encontrar una solución a un problema conocido como “El problema de los fumadores de cigarrillos” en donde existen 3 fumadores y un agente. Cada fumador continuamente enrolla un cigarro y luego lo fuma. Pero para enrollar y fumar un cigarrillo, el fumador necesita tres ingredientes: tabaco, papel y cerillos. Donde cada fumador tiene un solo elemento. El agente tiene un suministro infinito de los tres materiales. El agente coloca dos de los ingredientes en la mesa. El fumador que tiene el ingrediente restante hace entonces un cigarrillo y lo fuma, indicando al agente que terminó para que nuevamente coloque 2 nuevos elementos y el ciclo se repite.

El enlace para su descarga esta aquí, la aplicación fue desarrolla en Java bajo NetBeans 6.0. A continuación coloco algunas capturas de pantalla de la corrida del programa.

Saludos,

Simulación del Algoritmo SJF

A continuación pongo en consideración una pequeña simulación del algoritmo “primero el trabajo más corto” (shortest – job – first).

La aplicación esta desarrollada en Java bajo el IDE NetBeans 6.0 y permite crear procesos(en realidad son solo objetos no hilos) que ocuparán cada uno un tiempo de ejecución o uso de CPU determinado por el usuario.

Esto funciona de la siguiente manera al establecer cuantos procesos se realizarán el usuario deberá especificar que tiempo tardará cada uno en terminar, para luego la aplicación planifique su ejecución empezando por el más pequeño.

Una vez encontrado el orden exacto cada proceso ocupará el thread(hilo) central de la aplicación haciéndola detener para que nadie pueda ocuparlo mientras él se ejecuta, además cabe recalcar que por ser una demostración se estima el tiempo en segundos(el hacerlo unidades menores no daría mucha idea de lo que sucede). Luego abandonará el control del hilo y pasará al siguiente. Al terminar todos los procesos la aplicación también terminará.

Puedo decir que este algoritmo presenta varias ventajas pues al realizar los procesos con menor tiempo primero el tiempo de espera disminuye considerablemente aunque en una situación real la única dificultad es el cálculo de la ráfaga de CPU que como mencioné en un post anterior es aproximada.

Pueden descargar la aplicación desde  aquí 

Saludos,

Actualización: Si el link de descarga presenta problemas accede desde aquí o desde el widget que se encuentra en la parte izquierda del blog.

OTRO JUEGO EN GREENFOOT

Y aún sigo en la aventura del mundo Greenfoot, y vaya que es súper divertido a parte de fácil, pues en esta ocasión he estado trabajando en un juego basado en un laberinto, de dos jugadores en donde el objetivo es recolectar la mayor cantidad de puntos, el juego termina cuando cualquiera de los jugadores tome el hongo central del escenario que tiene un valor de 200 !!!! puntos.

Bueno ahora vamos a la parte interesante(el bajo mundo –> código….), pues está por demás decir que la aplicación es creada con el IDE Greenfoot y por supuesto Java, como el laberinto utiliza elementos como paredes, los tipos de puntos y los jugadores, cada uno de estos serán un OBJETO dentro del programa( en un próximo post hablaré sobre la POO programación orientada a objetos) lo que hacemos es crear una clase para cada objeto encapsulando todos sus atributos y claro agrupándolos en clases comunes en donde se pueda aplicar herencia, como los puntos.

Muy bien, ahora el juego reconoce 4 clases de puntos con diferentes valores que aumentarán el puntaje del jugador, para implementar esto en código utilizamos las sentencias:

if(getOneIntersectingObject( NombreClasePuntos.class)!=null){

}

Lo que localizará todos los objetos que “choquen” con el jugador.

Al final, lo que queda por hacer es tomar los marcadores de los dos jugadores y encontrar quien tiene el puntaje más alto, o si hay un empate.

 

Claro, el juego implementa algunos métodos importantes como movimientos, la puesta de marcadores para los puntos, por eso les colocó el link de descarga de la aplicación como proyecto de GreeFoot. Aquí unas capturas de pantalla de la aplicación ya terminada.

Pantalla de Incio

Pantalla Final al ganar un jugador…

Si quieres más detalles de la aplicación, escribe un comentario.

Saludos,

Lector de Correo con GWT(Google Web ToolKit)

Hace ya algún tiempo que esta herramienta viene funcionando. Y la idea de hacer algo como esto nació de una simple curiosidad de saber que podía traer de novedades. Así que nos embarcamos en el mundo de GWT.
Pero vaya si esto es novedoso, saber que estas escribiendo el código de tu aplicación en java y al compilar este se vuelve javascript. Bueno, para nuestra aplicación utilizamos el conocido IDE NetBeans 6.0 y los respectivos frameworks de GWT, y claro no la empezamos desde cero pues utilizamos un ejemplo de correo que viene con el GWT.
Uno de los principales retos que nos encontramos fue que no existe aún en este IDE componentes que se puedan arrastrar y colocar para crear una interfaz…!!! Así que la tarea de modificar y arreglar la interfaz a nuestro gusto fue algo tediosa.. y como diría un profe A Pata…
Algo que me llamó mucho la atención es saber que los componentes gráficos se colocan directamente en el panel del Explorador…. Es decir no es necesario crear un panel y luego montar todo dentro( claro que es lo más recomendable)
Esta ventaja hace que entre cambio de una pantalla a otra sea más rápido que otros.
Y claro como nuestro ejemplo trabajará con un servidor de correo(El de nuestra U), decidimos utilizar JavaMail, pero nos dimos cuenta que esta librería no podía ser transformada a JavaScript… vaya… Así que luego de leer y leer como podíamos solucionar esto descubrimos que el mismo GWT lo soluciona con la Ayuda de RPC propios del Framework, estos permiten crear un pequeño servlet con todo el código de conexión y acceso que simplemente es llamado desde la aplicación.

Pero vaya si fue algo muy interesante, pues para mí era un mundo desconocido…
A continuación está el código de nuestra aplicación… Claro que no está terminada a su totalidad, por falta de tiempo no logramos terminar la parte de leer mensajes MIME, y nos limitamos a los de texto Plano… pero aún no hemos tirado la toalla y seguimos tratando de mejorarla… Les estaré comentando nuestros nuevos avances….

Si tienes alguna pregunta escribe un comentario… Hasta la próxima…

Enlace de Descarga: http://www.box.net/shared/p428gxm8sg