En el código de a continuación tenemos dos métodos que nos servirán para agregar o quitar elementos de un ComboBox
public DefaultComboBoxModel quitarElementoCombo(JComboBox jc){
//Obtenemos el modelo del combobox
DefaultComboBoxModel modelo = (DefaultComboBoxModel) jc.getModel();
//Obtenemos el objeto seleccionado para su eliminación
int indice = jc.getSelectedIndex();
//Removemos el elemento "indice"
modelo.removeElementAt(indice);
//Devolvemos el modelo ya con el elemento quitado
return modelo;
}
public DefaultComboBoxModel añadirElementocombo(JComboBox jc, String elemento){
//Recogemos el modelo del combobox
DefaultComboBoxModel modelo = (DefaultComboBoxModel) jc.getModel();
//Añadimos el elemento recibido desde el método
modelo.addElement(elemento);
//Devolvemos el modelo ya con el elemento agregado
return modelo;
}
En este ejemplo, que dividiremos en parte, se hará una web de 0 para mostrar resultados usando AJAX consultando una base de datos MySQL.
Comencemos con la plantilla básica de la web :
En la próxima parte crearemos la base de datos y el php para consultar.Ejemplo Web Ajax
You think water moves fast? You should see ice. It moves like it has a mind. Like it knows it killed the world once and got a taste for murder. After the avalanche, it took us a week to climb out. Now, I don't know exactly when we turned on each other, but I know that seven of us survived the slide... and only five made it out. Now we took an oath, that I'm breaking now. We said we'd say it was the snow that killed the other two, but it wasn't. Nature is lethal but it doesn't hold a candle to man.
En algunos casos, o por estética, necesitaremos insertar un jcombobox dentro de una celda de una jtable. El proceso aunque pueda parecer largo y tedioso, es bastante simple, el código esta a continuación.
//Creamos un combo box sin modelo
JComboBox< Object > jc = new JComboBox<>();
//Creamos un modelo de combobox y le añadimos 3 elementos
DefaultComboBoxModel modelo = new DefaultComboBoxModel();
modelo.addElement("Primero");
modelo.addElement("Segundo");
modelo.addElement("Tercero");
//Asignamos el modelo al combobox
jc.setModel(modelo);
//Ahora vamos a recoger una columna que será donde insertemos el combobox
TableColumn columna = jTable1.getColumnModel().getColumn(0);
//Creamos un nuevo editor de celda. Tambien puede insertarse checkboxs y textfields
TableCellEditor editor = new DefaultCellEditor(jc);
//Le asignamos a la columna el editor creado
columna.setCellEditor(editor);
Con el método de a continuación podemos recoger los datos de cualquier JTable y nos devolverá un array bidimensional con los datos
public String[][] recogerJtable(JTable tabla){
//Recogemos las filas y columnas para saber las dimensiones del array bidimensional
int filas = tabla.getRowCount();
int columnas =tabla.getColumnCount();
String[][] datos = new String[filas][columnas];
//Con este for recorremos las filas
for (int i = 0; i < filas; i++) {
//Con este for recorremos las columnas de i fila
for (int j = 0; j < columnas; j++) {
datos[i][j] = (String) tabla.getValueAt(i, j);
}
}
return datos;
}
En el ejemplo siguiente tenemos un botón simple que tiene una transición de "padding". Con el atributo css transition le decimos que los cambios en el padding tengan una transición de 1 segundo, y con el modificador hover le cambiamos el padding (también funcionaría si usáramos javascript para el cambio). El código es el siguiente :
Y aquí el resultado :
En este ejemplo veremos como descargar un archivo y en una barra de progreso ver el estado de la descarga. Comencemos por la interfaz:
package modelo;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.URLConnection;
import java.util.logging.Level;
import java.util.logging.Logger;
import vista.principal;
/**
*
* @author pablo
*/
public class hiloDescargar implements Runnable{
principal p;
String ar;
public hiloDescargar(principal p, String ar){
this.p = p;
this.ar = ar;
}
@Override
public void run() {
try {
//Creamos una URL usando el String recibido del campo de texto
URL url = new URL(ar);
URLConnection urlCon = url.openConnection();
//Creamos un archivo para la descarga igual que el archivo remoto
File file2 = new File(url.toString());
File file = new File(file2.getName());
//Abrimos streamers y creamos un array de bytes para ir almacenando hay
//los datos de descarga y enviarlos al archivo
try (FileOutputStream fos = new FileOutputStream(file)) {
InputStream is = urlCon.getInputStream();
byte [] array = new byte[1000];
int leido = is.read(array);
//Aplicando valores a la barra de progreso
int maximo = urlCon.getContentLength();
p.barra.setMinimum(0);
p.barra.setMaximum(maximo);
p.barra.setValue(0);
int actual = 0;
while (leido > 0) {
fos.write(array,0,leido);
leido=is.read(array);
p.barra.setValue(actual);
actual += leido;
p.barra.setString("Descargando "+actual+"/"+maximo+" bytes");
}
fos.close();
}
} catch (MalformedURLException ex) {
Logger.getLogger(hiloDescargar.class.getName()).log(Level.SEVERE, null, ex);
} catch (IOException ex) {
Logger.getLogger(hiloDescargar.class.getName()).log(Level.SEVERE, null, ex);
}
}
}
Ahora tan solo nos queda crear un objeto hiloDescargar e introducirlo dentro de un hilo. Usaremos un ActionPerformed sobre el botón de descargar para ello.
this.p.btnDescargar.setActionCommand("btnDescargar");
this.p.btnDescargar.addActionListener((ActionEvent ae) -> {
hiloDescargar h = new hiloDescargar(p, p.txtDireccion.getText());
Thread t = new Thread(h);
t.start();
});
Con esto estaría terminada la aplicación.
Ejemplo de método para comprobar si un valor es un String:
public static boolean validarString(String a){
boolean res=true;
//utilizamos un for para recorrer todos los caracteres del String introducido.
for(int i=0;i < a.length();i++){
//Con este if comprobamos que el carácter seleccionado(i) no sea un dígito
if(Character.isDigit(a.charAt(i))){
//si el caracter es un dígito, asignamos false al booleano que devolvemos y mostramos un mensaje de error
res=false;
JOptionPane.showMessageDialog(null, "Solo puedes introducir letras en el nombre");
//si tenemos un dígito este break nos permite salir del método validarString(String a)
break;
}
}
//con este if comprobamos que la cadena no esté vacía
if(a.length()==0){
JOptionPane.showMessageDialog(null, "Introduzca un nombre.");
res=false;
}
//devolvemos el booleano:
return res;
}
Como este, se pueden crear muchos métodos más, por ejemplo para comprobar si el valor insertado es un DNI válido o un número de teléfono.
Si hemos creado muchos modelos de JTable estaremos al tanto del tiempo que se nos va en crear las columnas y recoger los registros de la base de datos. Afortunadamente existe la posibilidad de crear un método que nos cree el modelo de un JTable tan solo enviándole un ResultSet. El método esta a continuación :
public DefaultTableModel modeloConColumnasBaseDeDatos(ResultSet rs) throws SQLException{
//Creamos un modelo vacío
DefaultTableModel modelo = new DefaultTableModel();
//Recogemos los metadatos del ResultSet, esto lo usaremos para obtener el nombre de las columnas de la base de datos
ResultSetMetaData rsmd = rs.getMetaData();
//Obtenemos el número de columnas de la consulta
int columnas = rsmd.getColumnCount();
//Recorremos las columnas obteniendo los labels de la base de datos para usarlos en la cabecera de las columnas
for (int i = 0; i < columnas; i++) {
modelo.addColumn(rsmd.getColumnLabel(i+1));
}
//Creamos un array de string para las filas que insertemos
String[] fila = new String[columnas];
//Se repite mientras haya un registro en el ResultSet
while (rs.next() == true){
//Recorremos el registro y con un for rellenamos el array de string
for (int i = 0; i <= columnas; i++) {
fila[i-1] = rs.getString(i);
}
//Agregamos la fila
modelo.addRow(fila);
}
//Devolvemos el modelo
return modelo;
}
En estos ejemplos veremos como manipular las filas de una JTable. Comencemos con obtener la fila seleccionada, este método lo podemos reusar siempre que queramos.
public int filaSeleccionada(JTable tabla){
int fila;
//A fila se le asigna el numero de la fila seleccionada del JTable
fila = tabla.getSelectedRow();
return fila;
}
Ahora pasemos a borrar una fila.
public DefaultTableModel borrarFila(JTable tabla, int fila){
//Obtenemos el modelo de la tabla, JTable
DefaultTableModel modelo = (DefaultTableModel) tabla.getModel();
//Eliminamos la fila seleccionada usando el método anterior
modelo.removeRow(filaSeleccionada(tabla));
return modelo;
}
Ahora añadamos una fila en blanco
public DefaultTableModel añadirFila(JTable tabla) {
//Obtenemos el modelo de la tabla, JTable
DefaultTableModel modelo = (DefaultTableModel) tabla.getModel();
//Recogemos el número de columnas
int columnas = tabla.getColumnCount();
//Creamos un array de string con el tamaño del número de columnas
String[] fila = new String[columnas];
//Recorremos el array con un for para rellenar todas sus posiciones
for (int i = 0; i < columnas; i++) {
fila[i] = "";
}
//Agregamos la fila al modelo
modelo.addRow(fila);
//Devolvemos el modelo
return modelo;
}
En estos ejemplos veremos como añadir y quitar elementos de un JList. Comencemos con el método de añadir elementos :
public DefaultListModel añadirElemento(JList lista, String elemento){
//Recogemos el modelo de la lista
DefaultListModel modelo = (DefaultListModel) lista.getModel();
//Añadimos el elemento al modelo
modelo.addElement(elemento);
//Devolvemos el modelo
return modelo;
}
Ahora vamos con quitar un elemento :
public DefaultListModel quitarElemento(JList lista){
//Obtenemos el modelo de la lista
DefaultListModel modelo = (DefaultListModel) lista.getModel();
//Quitamos el elemento seleccionado
modelo.remove(lista.getSelectedIndex());
//Devolvemos el modelo
return modelo;
}
En este ejemplo veremos como crear un modelo para un JTree a partir de un directorio.
//Primero creamos un archivo que sera el directorio actual donde estamos
File directorio = new File(".");
//Creamos el nodo raíz y el DefaultTreeModel
DefaultMutableTreeNode principal = new DefaultMutableTreeNode("Archivos");
DefaultTreeModel modelo;
//Este nodo lo usaremos para ir agregando archivos al nodo principal
DefaultMutableTreeNode nodo;
//Creamos un array de archivos a partir de los archivos del directorio
File[] listaArchivos = directorio.listFiles();
//Este for recorrerá "listaArchivos" mientras haya un archivo siguiente
for (File listaArchivo : listaArchivos) {
//Creamos un nodo con el nombre del archivo en el que estamos y se lo agregamos al nodo raíz
nodo = new DefaultMutableTreeNode(listaArchivo.getName());
principal.add(nodo);
}
//Creamos el modelo y se lo asignamos al jTree
modelo = new DefaultTreeModel(principal, true);
jTree.setModel(modelo);
En este ejemplo veremos como crear un hilo sencillo que nos hará una cuenta atrás. Comenzaremos creando la clase main que será la que nos pedirá el número de segundos para la cuenta atrás.
public static void main(String[] args) {
//Creamos un Scanner para leer lo que el usuario meta por teclado
Scanner s = new Scanner(System.in);
System.out.println("Inserte tiempo, en segundos : ");
int tiempo = s.nextInt();
//Leemos lo introducido por teclado
Una vez tenemos esto debemos crear nuestra clase "cuentaAtras" o como queramos llamarla, la cual hará todo el proceso de contar hacia atrás en un hilo que crearemos posteriormente.
//Implementamos la interfaz Runnable y sobreescribimos el metodo run();
public class cuenta implements Runnable{
public int total;
//El constructor recibe como parámetro el entero que recogeremos desde el main
public cuenta(int total){
this.total = total;
}
@Override
public void run() {
while(total > 0){
total--;
try {
//Haremos que el Thread (Hilo) espere 1 segundo antes de restar 1
Thread.sleep(1000);
} catch (InterruptedException ex) {
Logger.getLogger(cuenta.class.getName()).log(Level.SEVERE, null, ex);
}
System.out.println(total);
}
}
}
Solo nos quedaría crear un objeto cronómetro e introducirlo en un Thread.
cuenta c = new cuenta(tiempo);
Thread t = new Thread(c);
//Ejecuta el Thread
t.start();
System.out.println("Cronómetro Iniciado");
En este ejemplo veremos como recoger datos de una base de datos mysql y mostrarlos en una tabla.
Comenzaremos inicializando la conexión con la base de datos.
DriverManager.registerDriver(new com.mysql.jdbc.Driver());
Connection conexion = DriverManager.getConnection(
"jdbc:mysql://111.111.111.111:3306/basededatos", "usuario", "contraseña");
Con esto tendremos la conexión establecida a una base de datos.
A continuación ejecutaremos una consulta sql y la guardaremos en un ResultSet el cual contendrá todos los datos devueltos por la consulta.
PreparedStatement s =
conexion.prepareStatement("SELECT * FROM clientes");
ResultSet rs = s.executeQuery();
Con esto tendremos un ResultSet con todos los datos de la tabla clientes. Nuestro próximo paso será crear un modelo de tabla a partir de los datos del ResultSet.
DefaultTableModel modelo = new DefaultTableModel();
modelo.addColumn("Nombre");
modelo.addColumn("Apellidos");
String[] fila = new String[2];
while(rs.next()==true){
fila[0] = rs.getString("nombre");
fila[1] = rs.getString("apellidos");
modelo.addRow(fila);
}
tabla.setModel(modelo);
El código anterior comienza creando un modelo de jtable por defecto y le añade dos columnas, una llamada nombre y otra apellidos. Posteriormente crearemos un array de String, el tamaño a de ser el número de columnas de la tabla, para almacenar los datos que recogeremos del ResultSet y añadirlos a la tabla en una nueva fila.
Con el while recorremos el ResultSet mientras tenga un registro (rs.next()) y recogemos los String de las columnas "nombre" y "apellidos" de la base de datos mysql.
Finalmente añadimos la fila al modelo. Este proceso se repetirá mientras haya registros en el ResultSet.
No debemos olvidar de cerrar tanto el ResultSet como la conexión.
rs.close();
conexion.close();
Suscribirse a:
Comentarios (Atom)