¿Cómo agrupar y utilizar botones de opción en una GUI de java?
Para nuestro ejemplo crearemos una clase tipo jFrame Form, sobre esta colocaremos un Panel lo vamos a llamar panel.
Ahora, sobre el panel colocaremos tres botones tipo radio (radio button), que indicaran los colores: "verde, amarillo, rojo".
Colocamos un botón, lo llamaremos jBtnAceptar. Ademas colocaremos tres paneles llamados: panel1, panel2, panel3.
Al presionar el botón se verifica la selección y dependiendo de eso se continuara a pintar los colores sobre los paneles colocados sobre el panel principal.
Nuestra ventana se mostrara así:
Continuaremos agregando un botón tipo Button Group, el mismo que no lo veremos en el panel, sino e la pestaña Navigator en la parte superior izquierda de Netbeans. El botón de grupo permite agregar ciertos botones tipo radio a un grupo, para que solo se permita seleccionar solo un radio button a la vez.
Empezamos seleccionando todos los botones tipo radio y haremos clic derecho y entramos a propiedades, no dirigimos a la fila llamada buttonGroup y escogemos group1:
En el constructor inicial izamos el color de los paneles como blanco.
Por el hecho de haber creado el Button Group y haber añadido los tres radio button, el programa permitirá solamente seleccionar un botón tipo radio a la vez, por lo tanto se pintara un solo color a la vez sobre los paneles.
También se puede agregar solo dos radio button al button group en vez de los tres, de esta manera podrá hacerse algunas combinaciones, pero no se permitirá que esos dos radio button estén marcados al mismo tiempo.
En el caso de no utilizarse un Button group, el programa permitirá que se presione dos o tres radio button a la vez y el programa se ejecutara normalmente :
Quedando de la siguiente manera:
¿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 reutilizar 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 extraída del array. Finalmente, en cada pasada del bucle añadimos la fila al modelo:
for (int i = 0; i < listaRegiones.size(); i++) {
Object[] fila = new Object[2];
fila[0]= listaRegiones.get(i).getRegionId();
fila[1]= listaRegiones.get(i).getRegionName();
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);
¡No olvides implementar el try-catch correspondiente! De lo contrario te dará error.
¿Qué es un ArrayList y como se utiliza?
o Agregar elementos
o Eliminar elementos
o Modificar elementos
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.
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 /
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
Como se observa es muy importante saber manejar los Iteradores ya que con ellos podemos tratar los elementos del ArrayList.
No hay comentarios.:
Publicar un comentario