Gráfica de Usuario (GUI)

¿Cómo agrupar y utilizar botones de opción en una GUI de java?

Si se quieren botones de selección única, los conocidos como botones radio, que tienen la particularidad de que solamente puede haber uno seleccionado, hay que crearse un grupo de botones, añadiendo botones a ese grupo uno a uno. Pero, Swing permite que cualquier AbstractButton pueda ser añadido a un ButtonGroup.La figura siguiente muestra los grupos de botones con la apariencia correspondiente a Swing, según se obtiene la ventana tras la ejecución, que crea varios paneles de botones. Para evitar la repetición del código correspondiente a la incorporación de cada uno de los botones, en el ejemplo se utiliza la reflexión para generar los grupos de diferentes tipos de botones. Esto se puede ver en creaPanelBotones(), que crea un grupo de botones y un JPanel, y para cada String en el array que figura como segundo argumento de creaPanelBotones(), añade un objeto de la clase indicada por el primero de los argumentos. import java.awt.*; import java.awt.event.*; import com.sun.java.swing.*; import com.sun.java.swing.border.*; import java.lang.reflect.*; public class java1406 extends JPanel { static String ids[] = { "Mortadelo","Filemon","Carpanta", "Rompetechos","Pepe Gotera","Otilio", }; static JPanel creaPanelBotones( Class bClass,String ids[] ) { ButtonGroup botones = new ButtonGroup(); JPanel panel = new JPanel(); String titulo = bClass.getName(); titulo = titulo.substring( titulo.lastIndexOf('.')+1 ); panel.setBorder( new TitledBorder( titulo ) ); for( int i=0; i < ids.length; i++ ) { AbstractButton botonAbs = new JButton( "fallo" ); try { // Se utiliza el constructor dinámico al que se pasa // una cadena como argumento Constructor ctor = bClass.getConstructor( new Class[] { String.class } ); // Se crea un nuevo objeto del tipo del botón botonAbs = ( AbstractButton )ctor.newInstance( new Object[]{ ids[i] } ); } catch( Exception e ) { System.out.println( "No puedo crear " + bClass ); } botones.add( botonAbs ); panel.add( botonAbs ); } return( panel ); } public java1406() { add( creaPanelBotones( JButton.class,ids ) ); add( creaPanelBotones( JToggleButton.class,ids ) ); add( creaPanelBotones( JCheckBox.class,ids ) ); add( creaPanelBotones( JRadioButton.class,ids ) ); } public static void main( String args[] ) { JFrame frame = new JFrame( "Tutorial de Java, Swing" ); frame.addWindowListener( new WindowAdapter() { public void windowClosing( WindowEvent evt ) { System.exit( 0 ); } }); frame.getContentPane().add( new java1406(),BorderLayout.CENTER ); frame.setSize( 600,300 ); frame.setVisible( true ); } } El título se coge del nombre de la clase, eliminándole toda la información referente al camino en que se encuentra en disco. El AbstractButton es inicializado a un JButton que tiene la etiqueta "Fallo", para que si se ignora el mensaje de la excepción, todavía se pueda ver en la pantalla que hay problemas. El método getConstructor() genera un objeto Constructor que coge el array de argumentos de tipos en el array Class pasado a getConstructor(). Y ya, todo lo que hay que hacer es llamar a newInstance(), pasarle un array de Object conteniendo los argumentos actuales; en este caso concreto, la cadena obtenida desde el array de ids. Ahora se añade un poco de complejidad a lo que antes era un proceso muy simple, para conseguir que funcione el grupo con un único botón seleccionado. Hay que crear un grupo de botones e indicarle a cada uno de los botones de ese grupo cual es el comportamiento que se desea de él. Cuando se ejecute el programa, se observará que todos los botones, excepto el JButton, disponen de ese comportamiento de exclusividad, marcándose y desmarcándose automáticamente, en función de la pulsación del ratón sobre el botón.

¿Cómo cargar datos a un componente jtable utilizando defaultTableModel?

Ya que en Acceso a Datos trabajamos con la base de datos HR, vamos a reuilizar uno de sus métodos para completar un jTable de nuestro formulario. Para ello debemos añadir en un JFrame un jTable y crearnos un modelo de datos de tipo DefaultTableModel en la clase de nuestro JFrame.

DefaultTableModel dtmModelo;

Además, dentro del método public nombreJPanel () además de llamar al método initComponents; llamaremos también a cargarTabla();

El método cargarTabla será público y no devolverá nada.

En primer lugar deberá definir el modelo DefaultTableModel para que no pueda ser editado por el usuario.

this.dtmModelo = new DefaultTableModel() {

   @Override

      public boolean isCellEditable(int fila, int columna) {

         return false; //Con esto conseguimos que la tabla no se pueda editar

      }

  };

A continuación asignamos dicho modelo a la tabla:

this.tblTabla = new JTable(dtmModelo);

Al modelo le añadimos los nombres de columnas que vamos a necesitar. En este caso, de Regiones tomaremos el ID y el nombre de la región.

this.dtmModelo.addColumn("ID");

this.dtmModelo.addColumn("Region");

Seguidamente realizamos la conexión a la base de datos HR y obtenemos, en este caso, el ArrayList de regiones que se lo asignaremos a una variable de tipo ArrayList.

Hr hr = new Hr();

ArrayList<Region> listaRegiones = hr.listarRegions();

Seguidamente hacemos un bucle para recorrer esta lista de regiones, definiéndonos una fila en la que indicaremos el número de columnas que vamos a utilizar y asignándole a las posiciones de la fila la información extraida del array. Finalmente, en cada pasada del bucle añadirmos la fila al modelo:

for (int i = 0; i < listaRegiones.size(); i++) {

   Object[] fila = new Object[2];

   fila[1]= listaRegiones.get(i).getRegionName();

   fila[0]= listaRegiones.get(i).getRegionId();
   this.dtmModelo.addRow(fila);

}

Para actualizar la información será necesario realizar el método updateUI a la tabla y a continuación ejecutar el método setViewportView del JScrollPane para actualizar la información que contiene.

this.tblTabla.updateUI();

this.scpScrollPane.setViewportView(tblTabla);

¿Qué es un ArrayList y como se utiliza?

La clase ArrayList en Java, es una clase que permite almacenar datos en memoria de forma similar a los Arrays, con la ventaja de que el numero de elementos que almacena, lo hace de forma dinámica, es decir, que no es necesario declarar su tamaño como pasa con los Arrays. Para todos aquellos que hayáis estudiado en alguna asignatura las estructuras de datos de las Pilas, Colas, Listas, Arboles (AVL, B, B+, B*) etc. hay decir que los ArrayList "tiran por tierra" toda la teoria que hay detrás de esas estructuras de datos ya que los ArrayList nos permiten añadir, eliminar y modificar elementos (que pueden ser objetos o elementos atómicos) de forma trasparente para el programador.

Los principales métodos para trabajar con los ArrayList son los siguientes: 

// Declaración de un ArrayList de "String". Puede ser de cualquier otro Elemento u Objeto (float, Boolean, Object, ...)

ArrayList<String> nombreArrayList = new ArrayList<String>();

// Añade el elemento al ArrayList

nombreArrayList.add("Elemento");

// Añade el elemento al ArrayList en la posición 'n'

nombreArrayList.add(n, "Elemento 2");

// Devuelve el numero de elementos del ArrayList

nombreArrayList.size();

// Devuelve el elemento que esta en la posición '2' del ArrayList

nombreArrayList.get(2);

// Comprueba se existe del elemento ('Elemento') que se le pasa como parametro

nombreArrayList.contains("Elemento");

// Devuelve la posición de la primera ocurrencia ('Elemento') en el ArrayList  

nombreArrayList.indexOf("Elemento");

// Devuelve la posición de la última ocurrencia ('Elemento') en el ArrayList   

nombreArrayList.lastIndexOf("Elemento");

// Borra el elemento de la posición '5' del ArrayList   

nombreArrayList.remove(5); 

// Borra la primera ocurrencia del 'Elemento' que se le pasa como parametro.  

nombreArrayList.remove("Elemento");

//Borra todos los elementos de ArrayList   

nombreArrayList.clear();

// Devuelve True si el ArrayList esta vacio. Sino Devuelve False   

nombreArrayList.isEmpty();  

// Copiar un ArrayList 

ArrayList arrayListCopia = (ArrayList) nombreArrayList.clone();  

// Pasa el ArrayList a un Array 

Object[] array = nombreArrayList.toArray();   

Otra cosa muy importante a la hora de trabajar con los ArrayList son los "Iteradores" (Iterator). Los Iteradores sirven para recorrer los ArrayList y poder trabajar con ellos. Los Iteradores solo tienen tres métodos que son el "hasNext()" para comprobar que siguen quedando elementos en el iterador, el "next()"  para que nos de el siguiente elemento del iterador; y el "remove()" que sirve para eliminar el elemento del Iterador.

Agregar Elementos:

Bueno, si esto no te ha quedado muy claro, pasamos a poner el primer ejemplo. En el siguiente fragmento de código, declaramos un ArrayList de Strings y lo rellenamos con 10 Strings (Elemento i). Esto lo hacemos con el método "add()". Después añadimos un nuevo elemento al ArrayList en la posición '2' (con el metodo "add(posición,elemento)") que le llamaremos "Elemento 3" y posteriormente imprimiremos el contenido del ArrayList, recorriendolo con un Iterador. El fragmento de este código es el siguiente:

// Declaración el ArrayList

ArrayList<String> nombreArrayList = new ArrayList<String>();




// Añadimos 10 Elementos en el ArrayList

for (int i=1; i<=10; i++){

 nombreArrayList.add("Elemento "+i); 

}




// Añadimos un nuevo elemento al ArrayList en la posición 2

nombreArrayList.add(2, "Elemento 3");




// Declaramos el Iterador e imprimimos los Elementos del ArrayList

Iterator<String> nombreIterator = nombreArrayList.iterator();

while(nombreIterator.hasNext()){

 String elemento = nombreIterator.next();

 System.out.print(elemento+" / ");

}

Ejecutando esta código obtenemos por pantalla lo siguiente:

Elemento 1 / Elemento 2 / Elemento 3 / Elemento 3 / Elemento 4 / Elemento 5 / Elemento 6 / Elemento 7 / Elemento 8 / Elemento 9 / Elemento 10 /

Eliminar elementos:

Como se observa en el resultado tenemos repetido el elemento "Elemento 3" dos veces y esto lo hemos puesto a proposito para mostrar el siguiente ejemplo. Ahora para seguir trabajando con los ArrayList, lo que vamos ha hacer es mostrar el numero de elementos que tiene el ArrayList y después eliminaremos el primer elemento del ArrayList y los elementos del ArrayList que sean iguales a "Elemento 3", que por eso lo hemos puesto repetido. El "Elemento 3" lo eliminaremos con el metodo "remove()" del iterador. A continuación mostramos el código que realiza lo descrito:

// Recordar que previamente ya hemos declarado el ArrayList y el Iterator de la siguiente forma:

// ArrayList<String> nombreArrayList = new ArrayList<String>();

// Iterator<String> nombreIterator = nombreArrayList.iterator();




// Obtenemos el numero de elementos del ArrayList

int numElementos = nombreArrayList.size();

System.out.println("nnEl ArrayList tiene "+numElementos+" elementos");




// Eliminamos el primer elemento del ArrayList, es decir el que ocupa la posición '0'

System.out.println("n... Eliminamos el primer elemento del ArrayList ("+nombreArrayList.get(0)+")...");

nombreArrayList.remove(0);




// Eliminamos los elementos de ArrayList que sean iguales a "Elemento 3"

System.out.println("n... Eliminamos los elementos de ArrayList que sean iguales a "Elemento 3" ...");

nombreIterator = nombreArrayList.iterator();

while(nombreIterator.hasNext()){

 String elemento = nombreIterator.next();

 if(elemento.equals("Elemento 3"))

  nombreIterator.remove(); // Eliminamos el Elemento que hemos obtenido del Iterator

}




// Imprimimos el ArrayList despues de eliminar los elementos iguales a "Elemento 3"

System.out.println("nImprimimos los elementos del ArrayList tras realizar las eliminaciones: ");

nombreIterator = nombreArrayList.iterator();

while(nombreIterator.hasNext()){

 String elemento = nombreIterator.next();

 System.out.print(elemento+" / ");

}




// Mostramos el numero de elementos que tiene el ArrayList tras las eliminaciones:

numElementos = nombreArrayList.size();

System.out.println("nNumero de elementos del ArrayList tras las eliminaciones = "+numElementos);

Como salida a este código tenemos lo siguiente:

El ArrayList tiene 11 elementos




... Eliminamos el primer elemento del ArrayList (Elemento 1)...




... Eliminamos los elementos de ArrayList que sean iguales a "Elemento 3" ...




Imprimimos los elementos del ArrayList tras realizar las eliminaciones: 

Elemento 2 / Elemento 4 / Elemento 5 / Elemento 6 / Elemento 7 / Elemento 8 / Elemento 9 / Elemento 10 / 




Numero de elementos del ArrayList tras las eliminaciones = 8

Si os fijais, hemos eliminado 3 elementos del ArrayList de dos formas distintas, preguntando por la posición que ocupa un elemento en el ArrayList y preguntando por el contenido de algún elemento del ArrayList. Como se observa es muy importante saber manejar los Iteradores ya que con ellos podemos tratar los elementos del ArrayList.

Bueno todo lo que hemos visto esta muy bien, pero por lo general los ArrayList se suelen utilizar con objetos más que con estructuras atómicas de datos, ya que los ArrayList en Java son estructuras muy potentes y sencillas de maneja

Modificar Elementos:

Un ArrayList contiene una lista de elementos enlazados. Cuando estemos manipulando una lista es posible que necesitemos reeemplazar un elemento del ArrayList. De esta forma sustituiremos el contenido de uno de estos elementos por otro contenido.

Para ilustrar el ejemplo vamos a empezar creando un ArrayList.

ArrayList<String> al = new ArrayList<String>();


 


al.add("Víctor");


al.add("Luis");


al.add("Elena");

Si recorremos y mostramos el contenido del ArrayList por pantalla utilizando un iterador:

Iterator<String> it = al.iterator();


while(it.hasNext())


  System.out.println(it.next());

Veremos que se nos muestra el contenido:

Víctor

Luis

Elena

Ahora vamos a reemplazar un elemento del ArrayList. En concreto vamos a cambiar el valor del elemento "Elena". Para ello necesitamos saber dos cosas, la primera es que el método que nos permite cambiar un valor es el método .set() y la segunda es la posición que ocupa para reemplazar un elemento del ArrayList.

Así ejecutamos el siguiente código:

al.set(2,"Teresa");

Vemos que se indica el valor 2 como parámetro ya que las posiciones del ArrayList empiezan a enumerarse desde el 0.

Si ahora volvemos a mostrar el contenido del ArrayList saldrá por pantalla:

Víctor

Luis

Teresa

Ya hemos visto lo sencillo que es reemplazar un elemento del ArrayList mediante el método .set().