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:
Entradas (Atom)