Últimas entradas del blog

Parece ser que están dando guerra las tablas xD A continuación les dejo un post con un ejemplo de tabla con cajas seleccionables y otros valores que son en éste caso enteros. Luego tenemos un botón con el que podemos recorrer la tabla (el modelo que representa los valores de la tabla) e ir borrando las filas que tienen la caja seleccionable seleccionada, valga la redundancia… 

package swing;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.border.EmptyBorder;
import javax.swing.table.DefaultTableModel;

public class TablaSeleccionable extends JFrame {

 private static final long serialVersionUID = 1L;
 private JPanel contentPane;
 private JTable table;

 /**
  * Launch the application.
  */
 public static void main(String[] args) {
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     TablaSeleccionable frame = new TablaSeleccionable();
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 /**
  * Create the frame.
  */
 public TablaSeleccionable() {
  setTitle("Tabla seleccionable by jnj");
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  setBounds(100, 100, 604, 347);
  contentPane = new JPanel();
  contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
  setContentPane(contentPane);
  contentPane.setLayout(null);

  JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(10, 11, 560, 227);
  getContentPane().add(scrollPane);

  String[] columnas = { "Los checkbox", "Un dato", "Otro dato" };
  final DefaultTableModel modelo;
  modelo = new DefaultTableModel(null, columnas);

  // hay que programar nuestra propia función getColumnClass para
  // poder poner controles como por ejemplo el checkbox con los datos
  // booleanos
  table = new JTable(modelo) {
   private static final long serialVersionUID = 1L;

   @Override
   public Class getColumnClass(int column) {
    switch (column) {
    case 0:
     return Boolean.class;
    case 1:
     return Integer.class;
    case 2:
     return Integer.class;
    default:
     return Boolean.class;
    }
   }
  };

  table.setBounds(26, 26, 463, 332);
  scrollPane.setViewportView(table);

  // INSERTA UNOS DATOS EN LA TABLA
  for (int i = 0; i < 10; i++) {
   Object[] nuevafila = { false, i, i };
   modelo.addRow(nuevafila);
  }

  // BOTON QUE ELIMINA FILAS,
  // Recorre de atrás hacia adelante las filas eliminando las
  // seleccionadas.
  JButton btnEliminarFilas = new JButton("Eliminar filas");
  btnEliminarFilas.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {
    for (int i = 9; i >= 0; i--) {
     // si la fila i, columna 0 es true, es porque está
     // seleccionado el checkbox, entonces borra
     if (((Boolean) modelo.getValueAt(i, 0)) == true) {
      modelo.removeRow(i);
     }
    }

   }
  });
  btnEliminarFilas.setBounds(10, 249, 201, 23);
  contentPane.add(btnEliminarFilas);

 }
}

Siguiendo los minitutoriales de la serie Swing, he desarrollado éste post sobre tablas para aprender a usar un poco más las tablas. Vamos al grano.

Introducción

Es necesario:

• Entorno de Desarrollo.
• El JDK o JRE, yo he usado el JDK 1.7, pero ya Swing no sigue en desarrollo así que no tiene mucha importancia la versión que uses.

Trato de explicar cómo poner cajas seleccionables (checkbox), listas desplegables (combobox) y cajas de texto formateado, en una tabla. En el ejemplo he puesto una caja que sólo admite un número de 3 dígitos. Más adelante lo vemos.

Para manejar los datos puedes usar directamente el modelo de datos que autogenera un JTable, puedes usar un AbstractTableModel como aparece en muchos de los tutoriales que he encontrado por Internet, o puedes usar una implementación de DefaultTableModel, que internamente usa un vector con el que te permite añadir o borrar filas de forma dinámica. Yo he usado un DefaultTableModel que me ha parecido más interesante porque muchas veces necesitamos añadir o borrar datos de una tabla.

El código fuente

Descargar

package swing;

import java.awt.EventQueue;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;

import javax.swing.DefaultCellEditor;
import javax.swing.JComboBox;
import javax.swing.JFormattedTextField;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellEditor;
import javax.swing.text.MaskFormatter;

public class JavaSwing10JTable2 extends JFrame {

 private static final long serialVersionUID = 1L;
 private JTable tabla;
 private static MiModelo modelo;

 // el main...
 public static void main(String[] args) {
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     JavaSwing10JTable2 frame = new JavaSwing10JTable2();
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 // constructor de la ventana, aquí hace todo
 public JavaSwing10JTable2() {

  setTitle("Java Swing 9 El JTable 2");
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  setBounds(100, 100, 846, 331);

  getContentPane().setLayout(null);
  JScrollPane scrollPane = new JScrollPane();
  scrollPane.setBounds(10, 11, 810, 271);

  getContentPane().add(scrollPane);

  // usa mi modelo de datos
  modelo = new MiModelo();
  // crea la tabla con mi modelo
  tabla = new JTable(modelo);

  //
  scrollPane.setViewportView(tabla);

  // EDITORES PERSONALIZADOS EN LA TABLA
  // la caja seleccionable, el checkbox lo pone sólo
  // con la función getColumnClass
  TableCellEditor editor;

  // configura el combo
  JComboBox comboBox = new JComboBox();
  comboBox.addItem("Opción A");
  comboBox.addItem("Opción B");
  comboBox.addItem("Opción C");

  // configura el campo de texto
  JFormattedTextField campoTexto = null;
  try {
   // sólo admite 3 números
   campoTexto = new JFormattedTextField(new MaskFormatter("###"));
  } catch (Exception e) {
   System.out.println(e.getMessage());
  }

  // combo a la columna 3
  editor = new DefaultCellEditor(comboBox);
  tabla.getColumnModel().getColumn(3).setCellEditor(editor);

  editor = new DefaultCellEditor(campoTexto);
  tabla.getColumnModel().getColumn(4).setCellEditor(editor);

  // capturador de eventos del ratón en la tabla 
  // autogenerado con Eclipse
  tabla.addMouseListener(new MouseListener() {

   @Override
   public void mouseReleased(MouseEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void mousePressed(MouseEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void mouseExited(MouseEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void mouseEntered(MouseEvent e) {
    // TODO Auto-generated method stub

   }

   @Override
   public void mouseClicked(MouseEvent e) {
    // TODO Auto-generated method stub
    
    int fila = tabla.rowAtPoint(e.getPoint());
    int columna = tabla.columnAtPoint(e.getPoint());

    JOptionPane.showMessageDialog(null, "Valor de la celda: "
      + tabla.getValueAt(fila, columna).toString());
   }
  });

 }

 // modelo de datos, usa DefaultTableModel que internamente
 // tiene un vector que nos permite por ejemplo añadir una fila
 // fácilmente con addRow...
 private static class MiModelo extends DefaultTableModel {

  private static final long serialVersionUID = 1L;

  private static final String[] nombresColumna = { "ID", "Un decimal",
    "Caja seleccionable", "Lista desplegable",
    "Campo texto formateado" };

  Class[] tiposColumna = { Integer.class, Double.class, Boolean.class,
    JComboBox.class, JFormattedTextField.class };

  // constructor de la clase, simplemente pone unos datos en el vector de
  // datos.
  public MiModelo() {
   super(nombresColumna, 0);

   // carga unos datos iniciales...
   for (int i = 0; i < 10; i++) {

    Object[] aux = { i, Math.random(), i % 2 == 0, "Opción A",
      "123" };

    addRow(aux);

   }
  }

  @Override
  public Class getColumnClass(int columnIndex) {
   // necesario para que dibuje la tabla con los tipos de columna
   return tiposColumna[columnIndex];
  }

 }

}

También he añadido la captura de eventos del ratón. Al escribir tabla.addMouseListener(new Mouse… podemos usar la combinación de teclas Ctrl + espacio y Eclipse nos intentará autogenerar el código. Ésto mismo se puede usar en cualquier momento, si Eclipse detecta que estás escribiendo algo que conoce te lo pone en un listado o si sabe seguro lo que vas a escribir lo autogenera. Es un comportamiento muy útil.

Explicaciones

He usado un DefaultTableModel que internamente tiene un vector de filas, para poder usar la función addRow() y así simplificar todo un poco que para eso está la clase DefaultTableModel.

La historia de configurar la tabla está en la clase MiModelo, espero haber dejado lo bastante comentado el código como para no explicar de nuevo aquí lo que hace. De todas formas si queda duda, mensaje aquí abajo que lo contesto en cuanto pueda.

Podemos obtener el vector de datos de la forma:

Vector data = modelo.getDataVector();

Hay muchas funciones interesantes que nos permitirán hacer lo que necesitemos. Para hacerse una idea, en mi Eclipse pongo modelo. y se me despliega el listado de funciones que tengo disponibles:

Tenemos la que ya he dicho addRow para añadir una fila, getRowCount que devuelve el número de filas, y muchas más. Algunas funciones necesitan un post entero para explicarlas así que lo dejaré aquí.

Donde pone tabla.addMouseListener(… está todo lo relacionado con el ratón. Podemos programar acciones para cuando se hace click, cuando se aprieta el botón, cuando se libera, etcétera…

Sobre los editores personalizados en una tabla hay que decir que admite cajas chequeables, listas desplegables y campos de texto. Además se pueden crear nuevos editores, como por ejemplo el que cita en la documentación oficial de un editor de celda que nos permite elegir entre una tabla de colores.

Más información

Me remito como siempre a la documentación oficial:

De todas formas hay muy buena información en otras páginas web, espero que si has leido éste tutorial por lo menos te haya aclarado algo, o te sirva el código fuente.

No dudes en dejar un mensaje.

Saludos.

Siguiendo con los minitutoriales de Swing, ha llegado la madre del cordero del manejo de datos. Tarde o temprano necesitamos visualizar, modificar, borrar o guardar datos. Podemos hacer formularios, recorrer tablas guardadas en variables ocultas, usar listas, al final la manera más simple de mostrar muchos de éstos datos es una tabla, que en Swing se llama JTable.

Para seguir éste tutorial hace falta, un entorno de desarrollo (por ejemplo Eclipse), el JDK o el JRE, y un poco de paciencia xD

Si eres un máquina entonces descárgate directamente el código y no te olvides de visitarme de vez en cuando, a ver si aumentan las visitas =)

A saber

Antes de empezar hay que saber que un JTable es un componente Swing, que va a visualizar unos datos que se almacenan internamente en una variable de tipo TableModel. No se recomienda usar directamente pero si no lo necesitamos para qué vamos a complicarnos más la vida en usar otros métodos. Lo he usado para no complicar el ejemplo.

En el ejemplo se va a usar un DefaultTableModel el cual va a guardar referencia del TableModel que tiene la tabla. Entonces cuando se modifica, en éste caso añadiendo más filas, automáticamente la tabla se redibuja y muestra los datos actualizados. Se recomienda usar un AbstractTableModel para manejar los datos pero eso es otro tema.

Comenzando

Gran parte del código se puede generar con Eclipse. Así que los pasos a seguir para emepezar son:

1. Crear un nuevo proyecto Java.
2. Añadir un JFrame que genere todo el esqueleto de la ventana.
3. En el Swing Designer en vista de diseño poner un Absolute Layer que nos permitirá posicionar los elementos donde queramos.
4. Poner un JScrollPane y dentro de él el JTable, de esta manera si la tabla crece más que lo que vemos apareceran barras de scroll como las de la imagen anterior.
5. El botón de abajo que meterá contenido en la tabla.

Hecho ésto hago doble click en el botón y me muestra todo el código recién generado listo para seguir implementando.

El código

A continuación el código lo más legible que he podido poner:

package swing;

import java.awt.EventQueue;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

public class JavaSwing9JTable extends JFrame {

 // versión
 private static final long serialVersionUID = 1L;

 // la tabla
 private JTable table;

 // el modelo de tabla, aquí van a estar los datos.
 private DefaultTableModel model;

 // función principal
 public static void main(String[] args) {
  EventQueue.invokeLater(new Runnable() {
   public void run() {
    try {
     JavaSwing9JTable frame = new JavaSwing9JTable();
     frame.setVisible(true);
    } catch (Exception e) {
     e.printStackTrace();
    }
   }
  });
 }

 // constructor del frame que contruye toda la ventana...
 public JavaSwing9JTable() {
  //título
  setTitle("Java Swing 9 El JTable");
  // cuando cerramos la ventana se cierra la aplicación por completo
  setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  // dimensiones y posición
  setBounds(100, 100, 596, 331);
  // establece una capa absoluta para posicionar los elementos donde queramos
  getContentPane().setLayout(null);

  // el panel con barras de scroll automáticas
  JScrollPane scrollPane = new JScrollPane();
  // dimensiones y posición del panel de scroll
  scrollPane.setBounds(10, 11, 560, 227);
  
  // se añade el panel de scroll a la ventana 
  getContentPane().add(scrollPane);

  // nombre de las columnas 
  String[] columnNames = { "ID", "Un dato", "Otro dato" };

  // creo un modelo de datos, sin datos por eso 'null' y establezco los
  // nombres de columna
  model = new DefaultTableModel(null, columnNames);
  // creo la tabla con el modelo de datos creado
  table = new JTable(model);
  
  // se pone la tabla en el scroll
  scrollPane.setViewportView(table);

  // código del botón
  JButton btnAadirLnea = new JButton("Meter contenido");
  btnAadirLnea.addActionListener(new ActionListener() {
   public void actionPerformed(ActionEvent arg0) {

    // aquí se añaden datos a la tabla
    for (int i = 0; i < 100; i++) {
     
     // creo un vector con una fila
     Object[] aux = { i, i * 34, Math.random() };
     
     // añado la fila al modelo
     model.addRow(aux);
     
    }

   }
  });
  // dimensiones y posición del botón
  btnAadirLnea.setBounds(10, 249, 267, 23);
  // pongo el botón en la ventana
  getContentPane().add(btnAadirLnea);

 }
}

Descarga del código aquí.

Aclaraciones

Ésta es la forma más simple que he encontrado de usar una tabla de Swing. El paso siguiente es usar un AbstractTableModel, crearnos una clase que la implemente, con la que podemos entonces hacer cosas como meter cajas seleccionables o cuadros desplegables en las filas.

Más información

Hay mucha información en Internet, me remito primero a la documentación oficial, está en inglés y es muy extensa:

Espero que sirva. En próximos posts espero ver cómo controlar los clicks del ratón, esos temas que citaba de la clase AbstractTableModel, formularios maestro-detalle, etcétera…

Saludos!

http://es.wikipedia.org/wiki/Tipo_de_dato_abstracto
Búsqueda en Google sobre TADs árboles

Construyendo el escenario

Creando el árbol

nodoroot
– nodo1 (indice 0)
— nodo1.1 (indice 0)
— nodo1.2 (indice 1)
– nodo2 (indice 1)
— nodo2.1 (indice 0)
—  nodo2.2 (indice 1)

DefaultMutableTreeNode nodoroot, nodo1, nodo11, nodo12, nodo2, nodo21, nodo22;
nodoroot = new DefaultMutableTreeNode("Éste es el nodo principal.");
nodo1 = new DefaultMutableTreeNode("nodo1");
nodo11 = new DefaultMutableTreeNode("nodo11");
nodo12 = new DefaultMutableTreeNode("nodo12");
nodo2 = new DefaultMutableTreeNode("nodo2");
nodo21 = new DefaultMutableTreeNode("nodo21");
nodo22 = new DefaultMutableTreeNode("nodo22");
arbol.setRoot(nodoroot);
arbol.insertNodeInto(nodo1, nodoroot, 0);
arbol.insertNodeInto(nodo2, nodoroot, 1);
arbol.insertNodeInto(nodo11, nodo1, 0);
arbol.insertNodeInto(nodo12, nodo1, 1);
arbol.insertNodeInto(nodo21, nodo2, 0);
arbol.insertNodeInto(nodo22, nodo2, 1); 

btnCargarrbolDe.addActionListener(new ActionListener() {
	public void actionPerformed(ActionEvent arg0) {

		DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
		DefaultMutableTreeNode nroot = new DefaultMutableTreeNode("Árbol de directorios");

		arbol.setRoot(nroot);

		CargaEstructuraDirectorios(arbol, nroot, "/");
	}
});

private void CargaEstructuraDirectorios(DefaultTreeModel arbol, DefaultMutableTreeNode padre, String ruta) {
	DefaultMutableTreeNode aux = null;

	File archivo = new File(ruta);
	File[] archivos = archivo.listFiles();

	if (archivos != null) {
		for (int i = 0; i < archivos.length; i++) {

			aux = new DefaultMutableTreeNode(archivos[i].getName());
			arbol.insertNodeInto(aux, padre, i);

			if (archivos[i].isDirectory()) {
				try {
					CargaEstructuraDirectorios(arbol, aux, archivos[i].getAbsolutePath() + "/");
				} catch (Exception e) {
					System.out.println(e.getMessage());
				}
			}

		}

	}
}

Borrar un nodo

Click, empieza el juego

final JTree tree = new JTree();
tree.addTreeSelectionListener(new TreeSelectionListener() {
	public void valueChanged(TreeSelectionEvent e) {
		DefaultMutableTreeNode nseleccionado = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
		JOptionPane.showMessageDialog(frame, nseleccionado.getPath());
	}
});

Códigos del ejemplo

import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.EventQueue;

import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import javax.swing.event.TreeModelListener;
import javax.swing.JButton;
import javax.swing.JTree;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.MutableTreeNode;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;

import java.awt.event.ActionListener;
import java.awt.event.ActionEvent;
import java.io.File;
import javax.swing.JScrollPane;
import javax.swing.event.TreeSelectionListener;
import javax.swing.event.TreeSelectionEvent;

// La clase principal
public class Principal extends JFrame {

	// el panel contenedor
	private JPanel contentPane;
	// el JFrame
	static Principal frame;

	/**
	 * esta es la función que primero se ejecuta creando el JFRame y visualizándolo
	 */
	public static void main(String[] args) {
		EventQueue.invokeLater(new Runnable() {
			public void run() {
				try {
					frame = new Principal();
					frame.setVisible(true);
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		});
	}

	/**
	 * la creación del JFrame principal donde está programado todo lo de éste ejemplo
	 */
	public Principal() {
		// título de ventana
		setTitle("Java Swing 8 El JTree by Jnj");
		// operación al cerra el JFrame
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		// dimensiones y posición en el escritorio
		setBounds(100, 100, 450, 306);
		// se crea el panel
		contentPane = new JPanel();
		// los bordes
		contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
		// se establece
		setContentPane(contentPane);
		contentPane.setLayout(null);

		// se pone el botón en la ventana
		JButton btnCargarrbolDe = new JButton(
				"Cargar u00E1rbol de directorios");
		btnCargarrbolDe.setBounds(10, 11, 200, 23);
		contentPane.add(btnCargarrbolDe);

		// las barras de escroll para el JTree
		JScrollPane scrollPane = new JScrollPane();
		scrollPane.setBounds(10, 45, 414, 206);
		contentPane.add(scrollPane);

		// el JTree
		final JTree tree = new JTree();
		// que captura el evento click
		tree.addTreeSelectionListener(new TreeSelectionListener() {
			public void valueChanged(TreeSelectionEvent e) {
				// se obtiene el nodo seleccionado
				DefaultMutableTreeNode nseleccionado = (DefaultMutableTreeNode) tree.getLastSelectedPathComponent();
				// visualiza el path del nodo
				JOptionPane.showMessageDialog(frame, nseleccionado.getPath());
			}
		});
		// se pone el árbol en el panel de las barras de scroll
		scrollPane.setViewportView(tree);

		// aquí el botón que borra el último elemento de los primeros hijos
		// es decir, desde el nodo root, borra sólo el último hijo
		JButton btnBorrarltimoNodo = new JButton("Borrar u00FAltimo nodo");
		btnBorrarltimoNodo.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {

				DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
				DefaultMutableTreeNode padre = (DefaultMutableTreeNode) arbol.getRoot();
				int numeroDeHijos = arbol.getChildCount(padre);

				// borra el último hijo del padre
				arbol.removeNodeFromParent((MutableTreeNode) arbol.getChild(
						padre, numeroDeHijos - 1));
			}
		});
		btnBorrarltimoNodo.setBounds(220, 11, 204, 23);
		contentPane.add(btnBorrarltimoNodo);

		// evento click del botón de carga del árbol
		// simplemente añade el nodo root y llama a la función de carga
		// para añadir todos los nodos hijos al nodo root
		btnCargarrbolDe.addActionListener(new ActionListener() {
			public void actionPerformed(ActionEvent arg0) {

				DefaultTreeModel arbol = (DefaultTreeModel) tree.getModel();
				DefaultMutableTreeNode nroot = new DefaultMutableTreeNode(
						"Árbol de directorios");

				arbol.setRoot(nroot);

				CargaEstructuraDirectorios(arbol, nroot, "/");

			}
		});
		
	
	}

	// función recursiva que lista todos los directorios y subdirectorios
	// a partir de una ruta, añadiéndolos a la estructura en árbol
	private void CargaEstructuraDirectorios(DefaultTreeModel arbol,
			DefaultMutableTreeNode padre, String ruta) {
		DefaultMutableTreeNode aux = null;

		File archivo = new File(ruta); // puntero al directorio de la ruta
		File[] archivos = archivo.listFiles(); // lista todos los archivos de la ruta

		// recorre lo que hay en la ruta
		if (archivos != null) {
			for (int i = 0; i < archivos.length; i++) {

				// creando un nodo con cada cosa del directorio
				aux = new DefaultMutableTreeNode(archivos[i].getName());
				// inserta el nodo hijo 
				arbol.insertNodeInto(aux, padre, i);

				// si encontramos un directorio volvemos a hacer lo mismo con sus hijos
				if (archivos[i].isDirectory()) {
					try {
						
						// llamando recursivamente de nuevo a ésta misma función
						CargaEstructuraDirectorios(arbol, aux,
								archivos[i].getAbsolutePath() + "/");
						
					} catch (Exception e) {
						System.out.println(e.getMessage()); // por si acaso le he puesto un try xD
					}
				}

			}

		}
	}
	
	// termina la creación del frame
}

// fin de la clase

Un saludo.