[ Foro de Java ]

operaciones CRUD

12-Dec-2022 00:27
Amado Ramirez
6 Respuestas

Crear la conexión a través de JDBC Driver
package com.connection;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class Conexion {
public static Connection conectar() {
Connection con = null;

String password = "root";
String usuario = "root";
String url = "jdbc:mysql://localhost:3306/ventas?user=" + usuario
+ "&password=" + password;
try {
con = DriverManager.getConnection(url);
if (con != null) {
System.out.println("Conectado");
}
} catch (SQLException e) {
System.out.println("No se pudo conectar a la base de datos");
e.printStackTrace();
}
return con;
}
}


13-Dec-2022 17:51
Invitado (Anonimo)

A
Statement stm = this.conexion.createStatement();
String sql = "";
ResultSet tabla = stm.executeQuery(sql);
while(tabla.next())
       {        
           cantFacturas = tabla.getInt("total_facturas");  
       }
this.cerrarConexionBD();
return cantFacturas;


13-Dec-2022 18:03
Invitado (David)

//Inciso a
   public int obtenerCantFacturasGeneradas() throws SQLException
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();
       //2. Variable para almacenar el total de facturas almacenadas en la base de datos.
       int cantFacturas = 0;
   //------------------- COMPLETAR LA LÓGICA CORRESPONDIENTE ----------------------------------------------------
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
       Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
       String sql = "SELECT count(*) as total_facturas from facturas";
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
           ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
                  while(tabla.next())
       {
           //6.1 En la única iteración, obtener y alamcenar el dato de la cantidad de facturas que arrojó la consulta SQL            
           cantFacturas = tabla.getInt("total_facturas");  
       }
   //----------------------------------------------------------------------------------------------------------------------------------
       //7. Cerrar la conexion a la base de datos    
       this.cerrarConexionBD();
       //8. Retornar el total de carreras que está almancenado en la base de datos
       return cantFacturas;
   }


13-Dec-2022 18:04
Amado Ramirez

//Inciso a
   public int obtenerCantFacturasGeneradas() throws SQLException
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();
       //2. Variable para almacenar el total de facturas almacenadas en la base de datos.
       int cantFacturas = 0;
   //------------------- COMPLETAR LA LÓGICA CORRESPONDIENTE -------------------------------------------------------
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
       Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
       String sql = "SELECT count(*) as total_facturas from facturas";
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
           ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
                  while(tabla.next())
       {
           //6.1 En la única iteración, obtener y alamcenar el dato de la cantidad de facturas que arrojó la consulta SQL            
           cantFacturas = tabla.getInt("total_facturas");  
       }
   //----------------------------------------------------------------------------------------------------------------------------------
       //7. Cerrar la conexion a la base de datos    
       this.cerrarConexionBD();
       //8. Retornar el total de carreras que está almancenado en la base de datos
       return cantFacturas;
   }


13-Dec-2022 18:05
Amado Ramirez

//Inciso b
   public Vector<String> obtenerListadoNombresProductosStock() throws SQLException
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();
       //2. Crear el vector para almacenar la lista de nombres de productos en stock resultante de la consulta SQL a la base de datos.
       Vector<String> listadoNombresProductosStock = new Vector<>();  
   //------------------- COMPLETAR LA LÓGICA CORRESPONDIENTE -------------------------------------------------------
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
         Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
        String sql = "SELECT descripcion as \"Nombre de Producto\" FROM stock_productos";
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
        ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
       while(tabla.next())
       { //En cada iteración:
               //6.1. Obtener el nombre del producto de la fila actual del objeto ResultSet
                   String valorColumna = tabla.getString("Nombre de Producto");
               //6.2. Almacenar en el vector creado en el paso 2. el valor de nombre de producto de la fila actual del objeto ResultSet
               listadoNombresProductosStock.add(valorColumna);
       }
//-----------------------------------------------------------------------------------------------------------------------------------------      
       //7. Cerrar la conexion a la base de datos      
       this.cerrarConexionBD();
       //8. Retornar el objeto vector con la lista de nombres de carreras almacenados en la base de datos
       return listadoNombresProductosStock;
   }


13-Dec-2022 18:06
Amado Ramirez

//Inciso c
   public ArrayList obtenerDetallesProductosXFactura(String pCodigoFactura) throws SQLException
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();
       //2. Crear la matriz de datos para almacenar el detalle de los productos de la factura segun la consulta SQL, cada fila es un Vector de String
       ArrayList matrizDetallesProductosFactura = new ArrayList();
   //------------------- COMPLETAR LA LÓGICA CORRESPONDIENTE -------------------------------------------------------
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
               Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
           String sql = "SELECT S.DESCRIPCION as \"DESCRIPCION DE PRODUCTO\", D.cantidad_prod as \"Cantidad Solicitada\", D.precio_total_prod as \"Precio total del Producto\"\n" +
                       "FROM DETALLE_FACTURAS D JOIN stock_productos S ON( S.codigo = D.codigo_producto)\n" +
                       "WHERE D.CODIGO_FACTURA = '"+pCodigoFactura+"'";
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
            ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
               while(tabla.next())
                       {          
           //En cada iteración:
               //6. Crear el Vector fila para almacenar los datos de cada fila según los campos de columnas de la consulta SQL.
                     Vector filaDatos = new Vector <>();
               //6.1 Agregar al vector fila el dato del campo descripcion de la consulta SQL
                     String Descripcion_Producto = tabla.getString("DESCRIPCION DE PRODUCTO");
               //6.2 Agregar al vector fila el dato del campo cantidad_prod de la consulta SQL
                     String Cantidad_Producto = tabla.getString("Cantidad Solicitada");
               //6.3 Agregar al vector fila el dato del campo precio_total_prod de la consulta SQL                
                     String Precio_Producto = tabla.getString("Precio total del Producto");
               //6.4 Agregar el vector fila, con los datos de las tres columnas de la consulta SQL, a la tabla matriz de datos.
                      filaDatos.add(Descripcion_Producto);
                      filaDatos.add(Cantidad_Producto);
                      filaDatos.add(Precio_Producto);
                      matrizDetallesProductosFactura.add(filaDatos);
               }
   //--------------------------------------------------------------------------------------------------------------------------------------                        
       //7. Cerrar la conexion a la base de datos
       this.cerrarConexionBD();
       //8. Retornar la matriz de datos con los resultados de la consulta SQL.
       return matrizDetallesProductosFactura;
   }


19-Dec-2022 00:02
Invitado (intelectual)

OPER CRUD
public int obtenerCantCarreras() throws SQLException //CONSULTA 1, PARTE 1.
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();        
       //2. Variable para almacenar el total de carreras almacenadas en la base de datos.
       int totalCarreras = 0;    
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
       Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
       String sql = "select count(*) as total_carreras from carreras c";        
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
       ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
       while(tabla.next())
       {
           totalCarreras = tabla.getInt("total_carreras");            
       }
       //7. Cerrar la conexion a la base de datos    
       this.cerrarConexionBD();        
       //8. Retornar el total de carreras que está almancenado en la base de datos
       return totalCarreras;
   }

//inciso 2.
   public Vector<String> obtenerListadoCarreras() throws SQLException //CONSULTA 2
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();        
       //2. Crear el vector para almacenar la lista de nombres de carreras resultante de la consulta SQL a la base de datos.
       Vector<String> listado_carreras = new Vector<>();
       //complete la lógica del bloque de código que resuelve:
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
       Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
       String sql = "select c.nombre as nombres_carreras from carreras c";
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
       ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
       while(tabla.next())
       {
           String nombre_carrera = tabla.getString("nombres_carreras");
           listado_carreras.add(nombre_carrera);
       }
       //7. Cerrar la conexion a la base de datos      
       this.cerrarConexionBD();
       //8. Retornar el objeto vector con la lista de nombres de carreras almacenados en la base de datos
       return listado_carreras;
   }  
   //OK
   public Vector<String> obtenerListaParalelos() throws SQLException
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();
       //2. Crear el vector para almacenar la lista de códgidos de paralelos resultante de la consulta SQL a la base de datos.
       Vector<String> lista_paralelos = new Vector<>();
       
       //complete la lógica del bloque de código que resuelve:
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
       Statement stm = this.conexion.createStatement();            
       //4. Definir el texto String de la consulta SQL.
       String sql = "select p.nombre as PARALELOS from paralelos p";                
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
       ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
       while(tabla.next())
       {                    
           //6.1. Obtener el valor de columna de la fila actual del objeto ResultSet
           String valorColumna = tabla.getString("PARALELOS");                    
           //6.2. Almacenar en el vector creado en el paso 2. el valor de columna de la fila actual del objeto ResultSet
           lista_paralelos.add(valorColumna);
       }  
       //7. Cerrar la conexion a la base de datos
       this.cerrarConexionBD();
       //8. Retornar el objeto vector con la lista de códigos de paralelos almacenados en la base de datos
       return lista_paralelos;        
   }
   //Inciso 3
   public Vector<String> obtenerListaParalelosCarrera(String p_nombre_carrera) throws SQLException
   {
       //1. Conectar a la base de datos
        this.iniciarConexionBD();

       //2. Crear el vector para almacenar la lista de códgidos de paralelos resultante de la consulta SQL a la base de datos.
        Vector<String> lista_codparalelos = new Vector<>();      
       //complete la lógica del bloque de código que resuelve:
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
        Statement stm = this.conexion.createStatement();          
       //4. Definir el texto String de la consulta SQL.
       String sql = "select paralelos.nombre, paralelos.cod_paralelo from paralelos JOIN carreras ON paralelos.cod_carrera = carreras.cod_carrera where carreras.nombre = '"+p_nombre_carrera+"'" ;
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
       ResultSet tabla = stm.executeQuery(sql);
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
      while(tabla.next())
       {                    
           //6.1. Obtener el valor de columna de la fila actual del objeto ResultSet
           String valorColumna = tabla.getString("nombre");                    
           //6.2. Almacenar en el vector creado en el paso 2. el valor de columna de la fila actual del objeto ResultSet
           lista_codparalelos.add(valorColumna);
       }  
       //7. Cerrar la conexion a la base de datos
       this.cerrarConexionBD();
       //8. Retornar el objeto vector con la lista de códigos de paralelos almacenados en la base de datos
       return lista_codparalelos;
   }
   //Inciso 4
   public ArrayList<Vector<String>> obtenerEstudInscritosPorCarrera(String p_nombre_carrera) throws SQLException
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();
       //2. Crear la matriz de datos para almacenar la consulta SQL, cada fila es un Vector de String
        ArrayList<Vector<String>> consulta = new ArrayList<>();
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
       Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
       String sql = "select e.cedula, e.nombres, e.apellidos from inscripciones_estudiantes i \n" +
                       "JOIN estudiantes e ON (i.cedula = e.cedula)\n" +
                       "JOIN carreras c ON (i.cod_carrera = c.cod_carrera) where c.nombre = '"+p_nombre_carrera+"'";
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
       ResultSet tabla = stm.executeQuery(sql);    
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
       while(tabla.next())
       {                    
           Vector dato = new Vector <>();
           String cedula = tabla.getString("cedula");                    
           dato.add(cedula);
           String nombre = tabla.getString("nombres");                    
           dato.add(nombre);
           String apellido = tabla.getString("apellidos");                    
           dato.add(apellido);
           consulta.add(dato);
       }                        
       //7. Cerrar la conexion a la base de datos
       this.cerrarConexionBD();
       //8. Retornar la matriz de datos con los resultados de la consulta SQL.
       return consulta;
   }
   //Inciso 5
   public ArrayList<Vector<String>> obtenerEstudInscritosPorParalelo(String p_codigo_paralelo) throws SQLException
   {
       //1. Conectar a la base de datos
       this.iniciarConexionBD();
       //2. Crear la matriz de datos para almacenar la consulta SQL, cada fila es un Vector de String
       ArrayList<Vector<String>> consulta = new ArrayList<>();
       //3. definir espacio de trabajo para la declaración y ejecución de la consulta sql
       Statement stm = this.conexion.createStatement();
       //4. Definir el texto String de la consulta SQL.
       String sql = "select e.cedula, e.nombres, e.apellidos from inscripciones_estudiantes i \n" +
                   "JOIN estudiantes e ON (i.cedula = e.cedula)\n" +
                   "JOIN paralelos p ON (i.cod_paralelo = p.cod_paralelo ) where p.nombre = '"+p_codigo_paralelo+"'";
       //5. Ejecutar la consulta y amacenar en el objeto ResultSet
       ResultSet tabla = stm.executeQuery(sql);    
       //6. Recorrer el objeto ResultSet mediante un while y para cada iteración resolver:
        while(tabla.next())
       {                    
           Vector dato = new Vector <>();
           String cedula = tabla.getString("cedula");                    
           dato.add(cedula);
           String nombre = tabla.getString("nombres");                    
           dato.add(nombre);
           String apellido = tabla.getString("apellidos");                    
           dato.add(apellido);
           consulta.add(dato);
       }                                              
       //7. Cerrar la conexion a la base de datos
       this.cerrarConexionBD();
       //8. Retornar la matriz de datos con los resultados de la consulta SQL.
       return consulta;
   }
   
BUTTON

private void jButton_mostrarTotalCarrerasActionPerformed(java.awt.event.ActionEvent evt) {                                                            
       // TODO add your handling code here:
       //1. Obtener la instancia única objeto de la clase OperacionesCRUD
       OperacionesCRUD obj_CRUD = OperacionesCRUD.getInstance();
       try
       {
           //2. Obtener la cantidad de carreras del método (obtenerCantCarreras) que consulta a la BD y que implementa el objeto obj_BD (OperacionesCRUD)
           int totalCarreras = obj_CRUD.obtenerCantCarreras();
           String value = String.valueOf(totalCarreras);
           //3. Mostrar en el componente visual total_carreras_jTextField el valor de cantidad de carreras obtenido en el paso 2.
           total_carreras_jTextField.setText(value);
       }
       catch(SQLException err)
       {
           System.out.println(err.getMessage());
       }        

private void jButton_mostrarTotalCarrerasActionPerformed(java.awt.event.ActionEvent evt) {                                                            
       // TODO add your handling code here:
       //1. Obtener la instancia única objeto de la clase OperacionesCRUD
       OperacionesCRUD obj_CRUD = OperacionesCRUD.getInstance();
       try
       {
           //2. Obtener la cantidad de carreras del método (obtenerCantCarreras) que consulta a la BD y que implementa el objeto obj_BD (OperacionesCRUD)
           int totalCarreras = obj_CRUD.obtenerCantCarreras();
           String value = String.valueOf(totalCarreras);
           //3. Mostrar en el componente visual total_carreras_jTextField el valor de cantidad de carreras obtenido en el paso 2.
           total_carreras_jTextField.setText(value);
       }
       catch(SQLException err)
       {
           System.out.println(err.getMessage());
       }        
   }                                                            
   //OK
   private void jButton_mostrarCarrerasActionPerformed(java.awt.event.ActionEvent evt) {                                                        
       // TODO add your handling code here:
       //1. Obtener la instancia única objeto de la clase OperacionesCRUD
       OperacionesCRUD obj_CRUD = OperacionesCRUD.getInstance();
       try
       {            
           //2. Obtener el vector lista de carreras del método (obtenerListadoCarreras) que consulta a la BD y que implementa el objeto obj_BD (OperacionesCRUD)
           Vector<String> listado_carreras = obj_CRUD.obtenerListadoCarreras();
           //3. Crear el objeto DefaultTableModel del jTable_ListaCarreras que debe mostrar el vector lista de carreras
           DefaultTableModel tablaVisual = (DefaultTableModel) jTable_ListaCarreras.getModel();
           //4. Setear el componente jTable_ListaCarreras con cero filas y columna de datos a mostrar.
           tablaVisual.setRowCount(0);
           tablaVisual.setColumnCount(0);
           //5. Agregar la columna de datos con cabecera "Listado de Paralelos del ITB" y vector lista de datos.
           tablaVisual.addColumn("Listado de nombres de Carreras", listado_carreras);
       }
       catch(SQLException err)
       {
           err.printStackTrace();
       }

private void jButton_mostrarEstudiantesCarreraActionPerformed(java.awt.event.ActionEvent evt) {                                                                  
       // TODO add your handling code here:
       //1. Obtener la instancia única objeto de la clase OperacionesCRUD
       OperacionesCRUD obj_BD = OperacionesCRUD.getInstance();
       //2. Obtener la lista de valores del modelo del combobox de lista de carreras.
       DefaultComboBoxModel<String> recordList_Carr_Est = (DefaultComboBoxModel)jComboBox_Listado_Carreras_Est.getModel();
       //3. Obtener la carrera seleccionado desde el combobox jComboBox_Listado_Carreras_Est
       String carrera = (String) recordList_Carr_Est.getSelectedItem();
       try
       {
           //4. Obtener la matriz de datos que devuelve el método (obtenerEstudInscritosPorCarrera) que consulta a la BD y que implementa el objeto obj_BD (OperacionesCRUD)
            ArrayList<Vector<String>> consulta = obj_BD.obtenerEstudInscritosPorCarrera(carrera);
           //5. Crear el objeto DefaultTableModel del jTable que debe mostrar la matriz de datos de los estudiantes que están inscritos en una carrera en particular
           DefaultTableModel tablaVisual = (DefaultTableModel) jTable_ListaEstudiantes.getModel();
           //6. Setear el componente jTable_ListaEstudiantes con cero filas a mostrar.
           tablaVisual.setRowCount(0);
           //7. Obtener la cantidad de filas que arroja la consulta a la base de datos almacenada en la matriz de datos.
           int totalFilas = consulta.size();
           //8. Recorrer cada fila de la matriz de datos de los estudiantes inscritos en una carrera en particular y para cada iteración resolver:
           for (int i =0; i<totalFilas; i++){
               Vector filaDatos =(Vector) consulta.get(i);
               tablaVisual.addRow(filaDatos);
               
           }
       }
       catch(SQLException err)
       {

private void jButton_mostrarParalelosCarreraActionPerformed(java.awt.event.ActionEvent evt) {                                                                
       // TODO add your handling code here:
       //1. Obtener la instancia única objeto de la clase OperacionesCRUD
       OperacionesCRUD obj_BD = OperacionesCRUD.getInstance();
       //2. Obtener la lista de valores del modelo del combobox de lista de carreras.
       DefaultComboBoxModel<String> recordList_Carr_Paralelos = (DefaultComboBoxModel)jComboBox_Listado_Carreras_Paralelos.getModel();
       //3. Obtener la carrera seleccionada desde el combobox jComboBox_Listado_Carreras_Paralelos
       String carrera = (String) recordList_Carr_Paralelos.getSelectedItem();
       try
       {            
           //4. Obtener el vector lista de paralelos del método (obtenerListaParalelosCarrera) que consulta a la BD y que implementa el objeto obj_BD (OperacionesCRUD)
          Vector<String> lista_codparalelos = obj_BD.obtenerListaParalelosCarrera(carrera);
           //5. Crear el objeto DefaultTableModel del jTable que debe mostrar el vector lista de paralelos
           DefaultTableModel tablaVisual = (DefaultTableModel) jTable_ListaParalelos.getModel();
           //6. Setear el componente jTable_ListaParalelos con cero filas y columna de datos a mostrar.
           tablaVisual.setRowCount(0);
           tablaVisual.setColumnCount(0);
           //7. Agregar la columna de datos con cabecera "Listado de Paralelos del ITB" y vector lista de datos "lista_paralelos".
          tablaVisual.addColumn("Listado de nombres de Paralelos", lista_codparalelos);            
       }
       catch(SQLException err)
       {
           err.printStackTrace()

private void jButton_mostrarEstudiantesParaleloActionPerformed(java.awt.event.ActionEvent evt) {                                                                  
       // TODO add your handling code here:
       //1. Obtener la instancia única objeto de la clase OperacionesCRUD
       OperacionesCRUD obj_BD = OperacionesCRUD.getInstance();
       //2. Obtener la lista de valores del modelo del combobox de lista de paralelos.
       DefaultComboBoxModel<String> recordList_Paralelos_Est = (DefaultComboBoxModel)jComboBox_Listado_Paralelos_Est.getModel();
       //3. Obtener el paralelo seleccionado desde el combobox jComboBox_Listado_Paralelos_Est
       String paralelo = (String) recordList_Paralelos_Est.getSelectedItem();  
       try
       {  
           //4. Obtener la matriz de datos que devuelve el método (obtenerEstudInscritosPorParalelo) que consulta a la BD y que implementa el objeto obj_BD (OperacionesCRUD)
           ArrayList<Vector<String>> consulta = obj_BD.obtenerEstudInscritosPorParalelo(paralelo);
           //5. Crear el objeto DefaultTableModel del jTable que debe mostrar la matriz de datos de los estudiantes que están inscritos en un paralelo en particular
           DefaultTableModel tablaVisual = (DefaultTableModel) jTable_ListaEstudiantes.getModel();
           //6. Setear el componente jTable_ListaEstudiantes con cero filas a mostrar.
           tablaVisual.setRowCount(0);
           //7. Obtener la cantidad de filas que arroja la consulta a la base de datos almacenada en la matriz de datos.
           int totalFilas = consulta.size();
           //8. Recorrer cada fila de la matriz de datos de los estudiantes inscritos en un paralelo en particular y para cada iteración resolver:
           for (int i =0; i<totalFilas; i++){
               Vector filaDatos =(Vector) consulta.get(i);
               tablaVisual.addRow(filaDatos);
               
           }






Si ya eres usuario del sistema, puedes contestar desde tu cuenta y así ganar prestigio.

Si sólo eres un visitante, puedes optar por...