Java + Swing 019. Modo diseño en NetBeans. Utilizando la clase Comparator con Collections.sort() para ordenar “List”.

Ejercicio: Realizar una pequeña aplicación que permita ordenar una lista de elementos utilizando la clase Comparator.
Diseñamos el formulario utilizando un JFrame. El nombre para el jFrame es a criterio de cada uno, lo importante es el diseño de la misma. En la imagen podemos ver el diseño y los nombres de variables de cada objeto (etiquetas en rojo para los nombres de variable), esto es muy importante ya que cada método utiliza el nombre de variable correspondiente para referenciar al objeto en específico. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. Para el “jComboBox” debemos de modificar la propiedad “model” agregando (Masculino, Femenino), que serán los datos desplegados.
Se puede descargar el formulario en el siguiente enlace:--> Archivos: *.FORM y *.JAVA
Observación: Tomar en cuenta que hay que utilizar las importaciones “import”, básico para utilizar ciertos métodos y objetos. El “setLocationRelativeTo(null)” sirve para centrar el formulario. Los métodos llamados en el constructor de la clase se inician al ejecutar el formulario. En este caso particular llamamos al método “arranque()” desde el constructor del jFrame, (comprobar imagen más abajo) es de vital importancia ya que configura los campos y especifica valores para cada una de las tablas. Las variables de clase se pueden llamar desde cualquier método, por tanto se utiliza para objetos que se necesitan utilizar en varias ubicaciones.

Lista de importaciones necesarias.
Código Java
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
Antes de crear los métodos que utilizaremos, debemos de crear la clase “PersonaC”. Esta clase servirá para trabajar con “List” y poder realizar los procesos de ordenamiento. Si utilizamos paquetes, esta clase debe ir en la misma que nuestro jFrame. Esta quedará de la siguiente forma.
Código Java
/**
*
* @author Ariel
*/

public class PersonaC {
private int id;
private String nomApe;
private String ciudad;
private int edad;
private String sexo;

public PersonaC(int id, String nomApe, String ciudad, int edad, String sexo) {
this.id = id;
this.nomApe = nomApe;
this.ciudad = ciudad;
this.edad = edad;
this.sexo = sexo;
}

public String getCiudad() {
return ciudad;
}

public void setCiudad(String ciudad) {
this.ciudad = ciudad;
}

public int getEdad() {
return edad;
}

public void setEdad(int edad) {
this.edad = edad;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public String getNomApe() {
return nomApe;
}

public void setNomApe(String nomApe) {
this.nomApe = nomApe;
}

public String getSexo() {
return sexo;
}

public void setSexo(String sexo) {
this.sexo = sexo;
}

}
Creamos los métodos siguientes en el apartado “Fuente”. Normalmente estos métodos los podemos agregar debajo del constructor del jFrame o al final de la declaración de variables. Estos métodos utilizan conversiones de tipos de datos, controles de excepciones y demás para controlar lo mejor posible el resultado. Se agregan comentarios para tratar de facilitar el entendimiento del funcionamiento de cada código.
Código Java
private void modelTable1(){
//Configuramos la primera tabla utilizando el DefaultTableModel,
//La tabla posee cinco columnas, el índice inicia de "0" cero.
jTableUno.getColumnModel().getColumn(0).setPreferredWidth(10);
jTableUno.getColumnModel().getColumn(1).setPreferredWidth(200);
jTableUno.getColumnModel().getColumn(2).setPreferredWidth(100);
jTableUno.getColumnModel().getColumn(3).setPreferredWidth(40);
jTableUno.getColumnModel().getColumn(4).setPreferredWidth(60);
//La variable "modelT1" es de tipo "DefaultTableModel", declarado más arriba
modelT1 = (DefaultTableModel)jTableUno.getModel();
//setNumRows(0) indica el número de filas que tendra la tabla de inicio.
modelT1.setNumRows(0);
}
private void modelTable2(){
//Configuramos la segunda tabla, el procedimiento es igual a la anterior.
jTableDos.getColumnModel().getColumn(0).setPreferredWidth(10);
jTableDos.getColumnModel().getColumn(1).setPreferredWidth(200);
jTableDos.getColumnModel().getColumn(2).setPreferredWidth(100);
jTableDos.getColumnModel().getColumn(3).setPreferredWidth(40);
jTableDos.getColumnModel().getColumn(4).setPreferredWidth(60);
//En este caso la variable es "modelT2"
modelT2 = (DefaultTableModel)jTableDos.getModel();
modelT2.setNumRows(0);
}
private void arranque(){
//Limpiamos campos y llamamos a los dos métodos creados más arriba para configurar las tablas.
modelTable1();
modelTable2();
nom.setText(null);
ciudad.setText(null);
edad.setText(null);
sexo.setSelectedIndex(-1);
}
private void limpiarCampos(){
//Utilizado para limpiar campos después de agregar datos a la tabla uno.
nom.setText(null);
ciudad.setText(null);
edad.setText(null);
sexo.setSelectedIndex(-1);
}
private void agregar(){
//Antes de agregar datos a la table comprobamos que los campos no esten vacios. Si almenos una de ellas esta vacia, dara una mensaje al usuario.
if(nom.getText().isEmpty() || ciudad.getText().isEmpty() || edad.getText().isEmpty() || sexo.getSelectedIndex() == -1){
JOptionPane.showMessageDialog(null, "Es necesario rellenar todos los campos.");
}
else{
//Si los campos estan correctos, se agrega el dato a la tabla uno utilizando la variable "modelT1".
int id = jTableUno.getRowCount() + 1;
modelT1.addRow(new Object[]{
id,nom.getText(),ciudad.getText(),edad.getText(),sexo.getSelectedItem().toString()
});
}
}
private void eliminar(){
//Método para eliminar datos de la tabla.
if(jTableUno.getRowCount() > 0){
try {
int sel = jTableUno.getSelectedRow();
modelT1.removeRow(sel);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Seleccione una fila.");
}
}

}
private void cargarLista(){
//Método para llenar la variable "lista" tipo List que creamos más arriba.
//La lista se llenará con los datos de la tabla uno utilizando la clase "PersonaC" que creamos.
if(jTableUno.getRowCount() > 0){
//Inicializamos la variable como ArrayList(), esto es esencial.
lista = new ArrayList();
//Utilizamos "try" para controlar la excepciones.
//La misma se puede dar si no se llena de forma correcta cada campo.
try {
//Recorremos cada fila de la tabla utilizando "for"
for (int i = 0; i < jTableUno.getRowCount(); i++) {
int d = Integer.parseInt(modelT1.getValueAt(i, 0).toString());
int ed = Integer.parseInt(modelT1.getValueAt(i, 3).toString());
//Utilizamos "add" y la clase "PersonaC" para llenar la lista.
lista.add(new PersonaC(d, modelT1.getValueAt(i, 1).toString(), modelT1.getValueAt(i, 2).toString(), ed, modelT1.getValueAt(i, 4).toString()));
}
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error llenando lista, verificar tipo de datos.");
}
}
}
private void ordenarNombre(){
//Método que nos permitirá llamar a nuestra lista y ordenarla según ciertos parámetros especificados.
//Utilizamos "Comparator" para ordenar la lista.
//Hay que castear como "PersonaC" para poder aplicarla a la lista que creamos más arriba.
Comparator<PersonaC> ordenarNombre = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
//Para dato String se utiliza "compareTo", compara el mismo campos de dos instancias de la misma clase.
return pc1.getNomApe().compareTo(pc2.getNomApe());
}
};
//Llenamos nuestra lista.
cargarLista();
//Solo ejecutamos el método Collections.sort si la lista no esta vacía.
if(!lista.isEmpty()){
//Los parámetros que le pasamos son la lista en si y la clase Comparator que creamos más arriba.
Collections.sort(lista, ordenarNombre);
modelT2.setNumRows(0);
//Utilizamos un "for" para recorrer la lista y llenar la segunda tabla con los datos ya ordenados.
//Para lista los mejor es utlizar Iterator.
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
private void ordenarCiudad(){
//El procedimiento para este método es igual a la anterior.
//La diferencia es que utilizamos el campo "ciudad" de la clase "PersonaC" para ordenar la lista.
Comparator<PersonaC> ordenar = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
return pc1.getCiudad().compareTo(pc2.getCiudad());
}
};
cargarLista();
if(!lista.isEmpty()){
Collections.sort(lista, ordenar);
modelT2.setNumRows(0);
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
private void ordenarEdad(){
//Este método se diferencia de las anteriores en que utilizamos un campos con dato "int" para ordenar los datos de la lista.
//Específicamente ordenará por edad.
Comparator<PersonaC> ordenar = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
//El procedimiento no utiliza el compareTo, solo el signo "-" menos.
return pc1.getEdad()- pc2.getEdad();
}
};
cargarLista();
if(!lista.isEmpty()){
Collections.sort(lista, ordenar);
modelT2.setNumRows(0);
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
private void ordenarSexo(){
//Este método también ordena la lista utilizando un campo "String".
Comparator<PersonaC> ordenar = new Comparator<PersonaC>() {
@Override
public int compare(PersonaC o1, PersonaC o2) {
PersonaC pc1 = (PersonaC)o1;
PersonaC pc2 = (PersonaC)o2;
return pc1.getSexo().compareTo(pc2.getSexo());
}
};
cargarLista();
if(!lista.isEmpty()){
Collections.sort(lista, ordenar);
modelT2.setNumRows(0);
for (Iterator<PersonaC> it = lista.iterator(); it.hasNext();) {
PersonaC ob = it.next();
modelT2.addRow(new Object[]{
ob.getId(),ob.getNomApe(),ob.getCiudad(),ob.getEdad(),ob.getSexo()
});
}
}
}
Utilizamos el evento “ActionPerformed” para llamar los métodos desde los botones. Se utiliza el evento “MouseClicked” para el jTable. Para utilizar un “Evento” hacemos clic derecho sobre el objeto y seleccionamos “Eventos” de la lista utilizamos la que podamos aplicar al objeto. En la mayoría de los casos se utiliza el “ActionPerformed”. Se agregan comentarios para tratar de facilitar el entendimiento.
Código Java
    private void agregarActionPerformed(java.awt.event.ActionEvent evt) {                                        
agregar();
limpiarCampos();
}

private void eliminarActionPerformed(java.awt.event.ActionEvent evt) {
eliminar();
}

private void ordNombreActionPerformed(java.awt.event.ActionEvent evt) {
ordenarNombre();
}

private void ordCiudadActionPerformed(java.awt.event.ActionEvent evt) {
ordenarCiudad();
}

private void ordEdadActionPerformed(java.awt.event.ActionEvent evt) {
ordenarEdad();
}

private void ordSexoActionPerformed(java.awt.event.ActionEvent evt) {
ordenarSexo();
}

private void limpiarActionPerformed(java.awt.event.ActionEvent evt) {
arranque();
}
Por último tenemos el formulario en ejecución.

No hay comentarios :

Publicar un comentario en la entrada