S?bado, 20 de junio de 2015

Resuelto en java con POO en Netbeans.

Estando  en clases de Optativa II, se nos puso un reto el cual consistía en resolver una matriz representada de dimensiones iguales, esto al ser un reto que nunca había realizado decidimos mi equipo y yo empezar a imaginar cómo hacerlo, empezando con una buena práctica de resolver el problema en el cuaderno.

¿Cómo se llegó al resultado?

La idea empezó como saber cuál era el punto inicial resolviéndolo de la siguiente manera.

posicionInicial = (tamañoMatriz/2) - 1.

Esto da saber dónde comenzará el primer ciclo, siguiendo dedujimos saber que cuantas columnas y filas se recorrerían, por lo cual se resolvió de la siguiente manera.

totalFilas = tamañoMatris/2.

totalColumnas = totalFilas.

Esto último se dedujo ya que la matriz utilizada sería cuadrada por eso el número de filas tendría que ser idénticamente al número de columnas ya sea 2x2, 4x4, 6x6, y así consecutivamente.

En seguida se planteó el cómo recorrer la matriz parte por parte.

Como ejemplo del recorrido se expresa con la siguiente imagen.

Esto da como idea lo que se realizó, siendo 4 ciclos los utilizados, el primero que es el que hace el recorrido de la parte azul, después el morado, el verde y el amarrillo, teniendo esto en cuenta se pasó a la forma más veloz utilizando recursividad, lo cual ayudó a recorrer todos los lados que podrán existir.


¿Cómo se realizó en NetBeans?

Se requirió para la práctica los siguientes objetos.

  1. JTable sin columnas y filas.
  2. JButton indicando el Enabled en false.
  3. Un jSpinner con el paso de 2 comenzando en 0.

Primero se requirió representar la matriz y la mejor manera para hacerse con POO fue utilizando un JTable perteneciente a la librería Swing.

Para comenzar se realizó lo siguiente:

  1. Se implementó un TableModelListener en la clase, esta se explicara el uso en los siguientes pasos.

 

En seguida la tabla tenía que ser modificada constantemente según el gusto del usuario, por lo cual se usó un JSpinner.

Este realiza el cambio constantemente de 2 en 2 para irle dando tamaño a la tabla siendo esto usado junto al evento StateChanged el cual iba modificando la tabla constante mente con el siguiente código.

private void jSpinner1StateChanged(javax.swing.event.ChangeEvent evt) {
       

       total = new Integer(jSpinner1.getValue().toString()); //Obtiene el número total del jSpinner
       DefaultTableModel dtm = new DefaultTableModel(total, total); //Se creó un modelo para la tabla del mismo tamaño de filas (rows) y de columnas (columns).
       jTable1.setModel(dtm); //Se asigna el nuevo modelo a la tabla.
       jTable1.getModel().addTableModelListener(this); //Se obtiene el modelo anteriormente colocado para asignarle un Listener el cual fue implementado anteriormente.
       jButton1.setEnabled(false); //Se desactiva el uso del jButton.

}

En el TableModelListener se implementó el siguiente código.

@Override
public void tableChanged(TableModelEvent e) { //

Mediante este método se verifica que no existan celdas vacías para poder iniciar la extracción en espiral.

       if (e.getType() == TableModelEvent.UPDATE){ //

Se verifica que el evento realizado, para saber que el usuario está agregando en todas las celdas y que en cada celda no se encuentre vacía de algún dato.

              boolean pass = false; //Se crea una variable del tipo boolean (false, true) iniciada como false.
              for (int row = 0; row < jTable1.getRowCount(); row++){ //Ciclo que recorrerá las filas.
                     for (int col = 0; col < jTable1.getColumnCount(); col++){ //Ciclo que recorrera las columnas
                            if (jTable1.getValueAt(row, col) == null || jTable1.getValueAt(row, col).toString().isEmpty()){ //Se verifica que no exista una celda vacía o nula si sí se indica que es false y se detiene el ciclo, si no se cambia a true.

                                   pass = false;
                                   break;
                            }else{
                                   pass = true;
                            }
                     }
                     if (!pass){ //Se verifica que el boolean no este como false si es así, se detiene el primer ciclo.
                            break;
                     }
              }

              //Si se detectó que no existe ninguna celda vacía el jButton1 cambia a disponible o no según la variable pass.

              jButton1.setEnabled(pass);
       }

}

Para terminar se necesitaba algo que hiciera la ejecución y extracción de manera espiral lo cual se hizo con un JButton con un evento actionPerformed el cual realizará el llamado al método extraerTodo  sin tipo (void) de la siguiente manera.

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {

       extrarTodo( (new Integer(jSpinner1.getValue().toString()) / 2) - 1, new Integer(jSpinner1.getValue().toString()) / 2, new Integer(jSpinner1.getValue().toString()) / 2); //Llamado al evento extrarTodo el cual recibe la fila inicial (rT), total de columnas (cT) y el total de filas (rT).
}


public void extrarTodo(int rI, int cT, int rT) {
       if (rI >= 0) { //Verifica que el inicio de las filas no sea fuera del index de la tabla correspondiente a <= -1.
              for (int c = rI; c <= cT; c++) { //Recorre de izquierda a derecha las columnas de la sección de arriba (Azul).
                     System.out.print(jTable1.getValueAt(rI, c) + ",");
              }

              for (int r = rI + 1; r <= rT; r++) { //Recorre de arriba a abajo las filas de la sección derecha (Morado).
                     System.out.print(jTable1.getValueAt(r, cT) + ",");
              }

              for (int c = cT - 1; c >= rI; c--) { //Recorre de derecha a izquierda las columnas de la sección de abajo (Verde).
                     System.out.print(jTable1.getValueAt(rT, c) + ",");
              }

              for (int r = rT - 1; r > rI; r--) { //Recorre de abajo a arriba las filas de la sección izquierda (Amarilla).

                     System.out.print(jTable1.getValueAt(r, rI) + ",");
              }


              extrarTodo(rI - 1, cT + 1, rT + 1); //Vuelve a llamar el método con decremento el en rI e incremento el en cT y el rT de uno.


       }
}


Por último agrego imágenes de como quedaran las pantallas e implementación del proyecto.

Para cualquier duda o aclaración o contacto se pueden comunicar conmigo, Daniel de Jesús Marín Ruvalcaba a mi correo [email protected].


Tags: Problema, Espiral, Netbeans, Java, POO, Arreglo, Ciclos

Publicado por danielmarinr @ 15:37  | Java SE8
Comentarios (0)  | Enviar
Comentarios