Dividir Cadenas en Java

28 abril 2009

Pareciera algo sencillo y simple, que no es digno para un artículo, sin embargo la división de cadenas de carácteres da algunos problemas, más que todo a los programadores principiantes. Este artículo explicará esta tarea con dos formas: con el método split() de la clase String y con la clase Tokenizer.

Este sencillo código realiza la separación de la cadena "Políticas de Calidad" en los espacios en blanco que se encuentren:

String cad = "Politicas de Calidad";

/*Primero lo realizaremos con Tokenizer. Hay que crear una nueva instancia de Tokenizer. Por defecto separa con cada espacio en blanco que encuentre de la cadena que se le manda como parámetro*/

StringTokenizer tokens = new StringTokenizer(cad);

//Mientras encuentre más tokens, es decir separaciones, que imprima cada token con nextToken():

while(tokens.hasMoreTokens()){
System.out.println(tokens.nextToken());
}

System.out.println("\n\n");

/*Ahora lo haremos con split(). Con los patrones \\ indicamos cuál es la condición para la separación. En este caso es el espacio en blanco. Recuerde que el resultado de split devuelve un arreglo de String */

String [ ] palabra = cad.split("\\ ");

int j=0;
while(j <= palabra.lenght-1){
System.out.println(palabra [ j ]);
j++;
}


Espero que este artículo ayude a muchos.

Librerías de Clases en Java y Netbeans

26 abril 2009

Guía de Laboratorio 3: Polimorfismo y Librerías de Clases

Auxiliar de Cátedra: Hugo Alejandro Barrientos

Esta guía está dedicada para poner en práctica los conocimientos aprendidos en las prácticas anteriores, tales como manejo de clases, métodos, instancias, herencia getters y setters. Además aprenderemos a manejar el polimorfismo, concepto de la programación orientada a objetos, para diseñar nuestras aplicaciones bajo un esquema de jerarquías de herencia, dentro del ámbito de Java con Netbeans, y aprenderemos además a crear nuestras propias librerías con clases y a añadirlas a un proyecto de Netbeans agregando a las referencias de librerías el respectivo Jar contenedor de la librería.

Operador instanceof

El operador instanceof sirve para consultar si un objeto es una instancia de una clase determinada, o de su padre. Pareciera absurdo tratar de conocer cuál es la clase que da lugar a una instancia específica, sin embargo es de mucha utilidad cuando se trabaja con interfaces y herencia a la vez. Veamos un ejemplo:

public class primo {

private int numero;
private int vectorPrimos[];
private int tamañoV;

public primo(){
this.tamañoV=25;
this.vectorPrimos= new int [this.tamañoV];
this.numero=0;
}
}


public class Main {
public static void main(String[] args) {

primo p = new primo();

if (esPrimo(p)){
System.out.println("ES INSTANCIA DE PRIMO");
}
}
public static boolean esPrimo(primo p) {
return (p instanceof primo);
}
}


Lo que realiza este sencillo ejemplo es comprobar si la instancia llamada “p” corresponde a la clase primo, definida anteriormente, con la ayuda del método estático “esPrimo” que verifica con el operador instanceof si la instancia que se traslada por el parámetro es de la clase que se evalúa. El resultado de dicha operación es true o false.

Librerías de Clases

Ahora aprenderemos a crear nuestras propias librerías de clases. Estas nos sirven para tener un conjunto de clases que nos sirven para realizar funciones específicas, creadas por el programador y que podremos importar hacia otras aplicaciones Java e implementar dicha funcionalidad.

Cabe mencionar que debemos tener una gran capacidad de análisis, para lograr abstraer las clases y crear objetos que funcionen de una manera adecuada.

Para crear nuestra librería, debemos crear un nuevo proyecto Java en Netbeans, escogiendo la opción de Java Class Library:



Como pueden leer en la descripción dentro de la imagen, una Class Library no contiene una clase Main para que se pueda correr o implementar las clases que se escriban dentro de la misma. Recuerde que la librería dará insumos a sus aplicaciones para realizar tareas a otras aplicaciones o programas.

Crearemos una librería que nos servirá para encontrar algunas familias o sucesiones de números. Empezaremos con la sucesión de números Fibonacci y los famosos números Primos. Se crearán clases para encontrar dichas sucesiones de números, conocer el Fibonacci que desee el usuario, evaluar si un número es primo o no, entre otras operaciones. Además, la clase para los fibonacci debe de facilitar métodos y atributos para encontrar los fibonacci que a la vez son primos.

A medida que el programador vaya escribiendo y concibiendo sus clases, la librería debe lucir de la siguiente manera:

Para implementar esta librería, basta con construir el proyecto, para generar un Jar que contenga las clases. Luego creamos una nueva aplicación Java que llamaremos ImplementarNumeros:


Ahora, con el proyecto creado, hacemos click derecho sobre el nombre del proyecto en el apartado de proyectos de Netbeans y nos dirigimos a las propiedades del mismo:


Nos dirigimos a la categoría de Libraries. Dentro de ella, agregamos un compilado, que puede ser un proyecto de Netbeans, un folder, una Class Libraryo un Jar. En este caso, agregaremos un Jar, así que presionamos el botón de Add JAR/Folder y buscamos el Jar de nuestra Class Library (Se encuentra en la carpeta dist dentro del folder del proyecto creado por Netbeans).

Al agregarlo, luego dentro del Main del proyecto, importamos las librerías de esta manera:


import numeros.fibonacci;
import numeros.primo;

Y ya podremos utilizar toda la funcionalidad de nuestras clases dentro de un proyecto e implementarlas.

La implementación podría ser muy parecida a esta:

public static void main(String[] args) {

fibonacci f = new fibonacci();
f.encontrarFibos();
int v[]=f.getFibos();

for(int i=0;i<25;i++)
System.out.println(v[i]);
}


Ejercicios:

Alimente su librería de clases con las familias de números:

Números Perfectos: Son números naturales que son iguales a la suma de sus divisores propios positivos sin incluirse a él mismo.

Números Compuestos: Es todo número natural no primo, a excepción de 1, se denomina compuesto, es decir que tiene uno o más divisores distintos a 1 y sí mismo.

Agregar JPanel en un JFrame en Java y Netbeans

19 abril 2009

Muchos compañeros me han pedido ejemplos para agregar o instanciar JFrames o JPanels dentro de otro JFrame. Existe un control Swing llamado Internal Frame que se utiliza para agregar Frames dentro otro. Sin embargo, debemos recordar que un Frame tiene propiedades tales como la barra de títulos, los botones de maximizar, minimizar y cerrar, coloca un nuevo ítem en la barra de tareas en Windows, KDE y Gnome, entre otras propiedades. Cabe destacar que muchas veces estos atributos no serán necesarios y entorpecerían el accionar de la aplicación. Muchas veces necesitamos unicamente un pequeño recuadro e insertarlo en uno u otro JFrame. Así que para esos efectos están los JPanels. Realizaremos un pequeño ejemplo con éstos.

Vamos a realizar una pequeña aplicación, que consiste en realizar dos de las operaciones básicas: sumas y restas. Para realizar cada una de ellas, el JFrame añade entre sus componentes a dos JPanels, uno para cada operación respectivamente.

Antes de mostrar cómo crear los JPanels, debemos de cambiar el layout al JFrame que utilizaremos. El Layout es una propiedad de los contenedores Swing para colocar todos los elementos que se contienen dentro de él. Como Java es multiplataforma, y en cada una de ella se disponen de manera distinta el orden de los elementos o componentes. Por lo tanto, Swing lo realiza con la ayuda de los layouts. En modo diseño del JFrame, hacemos click derecho a la opción Set Layout y le asignamos Null Layout, ya que nosotros colocaremos otro tipo de layout diferente al del diseño libre que nos brinda el editor de diseño de Netbeans. De esta forma:


Ahora sí, creamos dos JPanels desde el navegador de proyectos, uno llamado panelHijoSuma y otro panelHijoResta. Deben quedar de la siguiente manera:



Vean que el último TextBox se encuentra deshabilitado para que sea modificado por el usuario. Este solo presentará el resultado y el usuario jamás lo podrá tocar.

Al JFrame, tal y como lo observaron al inicio de este artículo solo le agregamos una Menu Bar, y un par de ítems para que luzca así:



Ahora, dentro del JFrame, en su constructor, y luego de la inicialización de componentes, vamos a establecer el layout a utilizar. Para este ejercicio, escogí el FlowLayout, que dispone un orden de los elementos horizontal uno tras otro y con cierto espaciado que podemos asignar.
El código dentro del constructor deberá ser el siguiente:

//Constructor
public framePadre() {

//llamo al constructor padre y le mando el nombre del título de la ventana
super("Operaciones Básicas");

//Función de inicialización de componentes. Netbeans la coloca por defecto
initComponents();

//Colocamos el nuevo tipo de layout que queremos que tenga nuestro JFrame
this.setLayout(new FlowLayout());
}

También creamos dos atributos al JFrame, para más facilidad. Serán dos atributos del tipo de datos de cada uno de los JPanel.

private panelHijoSuma hs;
private panelHijoResta hr;

Ahora, en cada una de los ítems de la barra de menú, para mostrar el JPanel deseado, colocamos el siguiente código:

//Nombre evento
private void nSumaActionPerformed(java.awt.event.ActionEvent evt) {

//Si ya está el otro Jpanel añadido al contenedor, entonces se elimina
try{
this.remove(hr);
}
catch(Exception e){
}

//Creamos una nueva instancia de panelHijoSuma
hs = new panelHijoSuma();

//Agregamos la instancia al JFrame, con un layout al centro
this.add(hs, BorderLayout.CENTER);

//Hacemos que el JFrame tenga el tamaño de todos sus elementos
this.pack();
}

Este código debe de ser similar en los restantes ítems de la Menu Bar, siempre con el evento ActionPerformed.

Ahora, la parte final de este artículo. Realizaremos cada una de las operaciones dentro del evento de los TextBox, KeyReleased(). De esta forma:


Ahi agregaremos el siguiente código:

//Nombre del evento. Lo genera Netbeans
private void txtnum1KeyReleased(java.awt.event.KeyEvent evt) {

//Asignamos el texto del textBox a una variable Integer
int num1 = Integer.parseInt(this.txtnum1.getText());

//Si el otro TextBox no esta vacio, entonces se debe realizar la operación
if (!this.txtnum2.getText().equals("")){

int num2 = Integer.parseInt(this.txtnum2.getText());

//Se realiza la operación, y se coloca en el TextBox del resultado
this.txtresultador.setText(String.valueOf(num2+num1));
}
}

La aplicación debe lucir así:


El mismo JFrame con uno y otro JPanel

Espero que les sea útil este código.

Código alojado en el Aula Virtual de la UES-FMO, dentro del curso de Programación II.

Emisión de certificados SSL con Apache Tomcat, Java, JSP y Netbeans

05 abril 2009


Un buen amigo mio necesitaba emitir certificados SSL (Secure Socket Layers) para la admisión de usuarios a sitios con protocolo http seguro (HTTPS) para un proyecto de una materia de la universidad. Como el novato que aun soy, empecé a leer al respecto y encontré una forma de hacerlo. Logré implementarla y traigo para Uds. este pequeño y sencillo tutorial para emitir este tipo de certificados utilizando Apache Tomcat, Java, JSP y Netbeans, todo sobre un sistema operativo Windows Vista.

Las versiones que se tienen instaladas son:

  • JDK 1.6.0_05
  • Netbeans 6.5
  • Apache Tomcat 6.0.18
Ahora, para generar el certificado SSL utilizaremos la herramienta incluida en el Java Development Kit, JDK llamada KeyTool. Para acceder a ella tenemos que acceder al directorio que contiene la versión del JDK. En Windows, es la siguiente ruta:

%JAVA_HOME%\bin\keytool.exe -genkey -alias tomcat -keyalg RSA

Con este comando y sus argumentos, estamos ordenando que generaremos un nuevo certificado o una nueva key, con el alias tomcat. Luego nos pedirá una serie de datos que son los que conformarán el almacén de claves. La clave que viene por defecto con el alias de tomcat es:

changeit


Por el momento si estás aprendiendo conserva esta clave y así no tendrás problemas para crear más certificados. Cuando termines de ingresar toda la información digita OK para que se valide. Para mantener la misma clave (es decir changeit) solo debes de presionar Enter.

Al finalizar este paso el KeyTool genera un archivo que almacena la lleva, es decir un .keystore. Es un poco problemático encontrar en donde lo guarda, sin embargo el keytool lo aloja siempre en la carpeta de usuario, en mi caso en Windows Vista se alojó en:

C:\Users\miNombreUsuario

En Windows XP sería:
C:\Documents and Settings\miNombreUsuario

En Ubuntu sería
/home/miNombreUsuario

Ahora debemos configurar el servidor Tomcat para aceptar y habilitar el puerto SSL, que por defecto es el 8443. Dentro de la carpeta del apache-tomcat-6.0.18 localizamos el archivo server.xml y descomentamos unas líneas que aparecen por defecto con carácter de comentarios y es el conector del puerto 8443. Le quitamos los comentarios unicamente y le agregamos un atributo para indicar cuál sera el keystore, de esta manera:

Iniciamos ahora el servidor Tomcat de esta manera:
C:\Servidorapache-tomcat-6.0.18\bin\startup.bat

Y ahora digitamos en el navegador https://localhost:8443/ y ya accederemos al index de localhost pero con protocolo http seguro, de esta manera:



Se añade la excepción en el certificado y ya se podrá ver como la imagen superior. Aprecien también en la barra de direcciones el protocolo del sitio (HTTPS) y en la barra de estado de Firefox vean que tiene un pequeño candado, denotando que es un sitio seguro.

El tercer y último paso es crear una aplicación web con JSP y Netbeans, utilizando Tomcat como servidor de dicha aplicación. La creamos con Netbeans, y modificamos el archivo web.xml agregando estas etiquetas, todas dentro del cierre de la etiqueta web-app. De esta manera:

<security-constraint>
<web-resource-collection>
<web-resource-name>Entire Application</web-resource-name>
<url-pattern>/*</url-pattern>
</web-resource-collection>
<user-data-constraint>
<transport-guarantee>CONFIDENTIAL</transport-guarantee>
</user-data-constraint>
</security-constraint>
Y es todo! Ahora este sitio se podrá ser accedido desde protocolo HTTPS. La prueba luciría así. Noten el protocolo en la barra de direcciones, así como el pequeño candado:



Muchas gracias a Armando Díaz y su Blog Ubuntu de El Salvador, ya que este tutorial está basado en su artículo.

Utilizando JTextArea y JOptionPane en Netbeans

02 abril 2009

JTextArea es un componente básico del Swing de Java y su función principal es la de capturar texto ingresado desde teclado por el usuario. Sin embargo, entre sus métodos está el de asignarle texto para mostrarlo además. Ahora explicaré un poco su uso con la ayuda de un pequeño ejemplo, el cual sería un pequeño bosquejo de un proyecto llamado Librería, en el cual estará para este ejemplo unicamente la clase Libro.

La construiremos de esta manera: Unicamente con tres atributos básicos, un constructor que los inicialice con valores constantes, y con los respectivos get y set de cada atributo. El código de dicha clase quedaría de la siguiente manera:



package
libreriajtextarea;

// @author Hugol

public class libro {

private String nombre;
private String autor;
private int numPags;

public libro(){
this.nombre="Cómo Programar en C/C++";
this.autor="Joyanes Aguilar";
this.numPags=500;
}

public String getNombre(){
return this.nombre;
}

public void setNombre(String n){
this.nombre=n;
}

public String getAutor(){
return this.autor;
}

public void setAutor(String a){
this.autor=a;
}

public int getNumPags(){
return this.numPags;
}

public void setNumPags(int n){
this.numPags=n;
}
}

Ahora en la clase Main la implementaremos para que podamos utilizar, tanto los JTextArea como los JOptionPane en nuestra introducción al Swing. El código del Main es así:

public class Main {

public static void main(String[] args) {

//se crea un nuevo JTextArea
JTextArea salida = new JTextArea();
String cadSalida = "";

//se crea un nuevo libro
libro book = new libro();

//Se coloca texto al JTextArea
salida.setText("El libro "+ book.getNombre()+ " tiene "+book.getNumPags()+ " paginas");

//Se muestra el texto en un JOptionPane
JOptionPane.showMessageDialog(null, salida, "Libreria", JOptionPane.INFORMATION_MESSAGE);

//Se limpia el JTextArea
salida.setText("");

//Se le asigna un tamaño de ancho y alto al JTextArea
salida.setSize(50, 50);

//Se le pide al usuario que escriba dentro del JTextArea en un JOptionPane
JOptionPane.showMessageDialog(null, salida, "Escribe el Editorial del libro JTextArea", JOptionPane.INFORMATION_MESSAGE);

//Se le asigna el texto escrito en el JTextArea a un String
cadSalida = salida.getText();

//Se imprime el String en un JOptionPane, demostrando q el JTextArea se puede utilizar tanto para recibir información como para mostrarla
JOptionPane.showMessageDialog(null, "Editorial de libro: " + cadSalida, "Libreria", JOptionPane.INFORMATION_MESSAGE);

}

}

Cabe mencionar que ya la clase JOptionPane proporciona un método de entrada de datos, el ya conocido showInputDialog(), sin embargo para fines didácticos se agrega un JTextArea para el ingreso de datos. La aplicación luce así:



Se muestra el JTextArea dentro JOptionPane.



El usuario digita dentro del JTextArea la editorial del libro.



Se muestra la respuesta.