Modifica valore celle JTable

[finkgud]

Stavo proprio cercando di creare un table model custom come dici tu. Ti posto il codice:

...
model = new MyTableModel();        model.setDataTable(Query);
        model.addTableModelListener(new TableModelListener() {
            @Override
            public void tableChanged(TableModelEvent e) {
                int col = e.getColumn(); 
                int row = e.getFirstRow();
                String valoreInserito = model.getValueAt(row,col).toString();
                System.out.println(valoreInserito);
                float valore = Float.parseFloat(valoreInserito);
                System.out.println(valore);
                int i = d.TotRow(Query);
                String prova = null;
                for(int k=0;k<i;k++){
                String uno = model.getValueAt(k, col);
                float tre = Float.parseFloat(String.valueOf(uno));
                if(tre != valore){
                    tre += 1;
                    prova = String.valueOf(tre);
                    model.setValueAt(prova, k, col);
                }
                }
            }
        });

//MyTableModel

import DAO.ConnectionDAO;
import java.awt.*;
import java.sql.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.event.*;


import java.util.Vector;


class MyTableModel extends AbstractTableModel {
  // Variabili di istanza
  // -----------------------------------------------------------------------
  private Vector<Vector<String>> data;
  private Vector<String> columnName;
  private PreparedStatement SQLPreparedStatement;
  // -----------------------------------------------------------------------
  
  MyTableModel() {
    data = new Vector<Vector<String>>();
    columnName = new Vector<String>();
  }
  
  public int getColumnCount() {
    if(columnName == null) return -1;
    return columnName.size();
  }
  
  public int getRowCount() {
    return data.size();
  }
  
  public String getColumnName(int col) {
    if(col >= columnName.size()) return null;
    return columnName.elementAt(col);
  }
  
  public Class getColumnClass(int c) {
    return String.class;
  }
  
  // La prima colonna non e' modificabile
  public boolean isCellEditable(int row, int col) {
    if(col == 0) return false;
    else return true;
  }
  
  public String getValueAt(int row, int col) {
    Vector<String> v = data.elementAt(row);
    return v.elementAt(col);
  }
  
  public void setValueAt(Object value, int row, int col) {
    Vector<String> v = data.elementAt(row);
    v.setElementAt((String)value, col);
    fireTableCellUpdated(row,col); 
  }
  
  public void setDataTable(String Query){
      final ConnectionDAO d = new ConnectionDAO();
        Connection cn = null;
          try {
          Class.forName("com.mysql.jdbc.Driver");
          cn = DriverManager.getConnection("jdbc:mysql://localhost:3306/Miscele?user=root&password=m4c3nro3");
          SQLPreparedStatement = cn.prepareStatement(Query);
          ResultSet rsQuery = SQLPreparedStatement.executeQuery();
          ResultSetMetaData rsmt = rsQuery.getMetaData();
          int column = rsmt.getColumnCount();
          for(int i=1;i<=column;i++){
              columnName.add(rsmt.getColumnName(i));
          }
          while(rsQuery.next()){
              Vector row = new Vector(column);
              for(int i=1;i<=column;i++){
                  row.addElement(rsQuery.getObject(i));
              }
              data.add(row);
          }
          cn.close();
          }catch(Exception e){
          }
  }
  
}

Sostanzialmente la mia tabella è di questo tipo:

ingrediente1 | quantità1 | costo1
ingrediente2 | quantità2 | costo2
ingrediente3 | quantità3 | costo3
…
e così via.
Immagina di aver una ricetta e poterne modificare le dosi. Modificando quantità1 mi serve aggiornare quantità2 e quantità3 poiché sono legati in percentuale a quantità1, e di conseguenza vanno aggiornati anche i costi in base alla quantità di ingrediente utilizzato. Purtroppo però proprio come dicevi tu una volta recuperati i valori delle celle e modificati, non riesco ad aggiornare la tabella con i nuovi valori poiché la gestione va in loop.

[andbin]

Stavo proprio cercando di creare un table model custom come dici tu.
Purtroppo però proprio come dicevi tu una volta recuperati i valori delle celle e modificati, non riesco ad aggiornare la tabella con i nuovi valori poiché la gestione va in loop.

Rispondo purtroppo solo ora. Come ho detto prima, la soluzione migliore è fare quella logica nel table model, perché in un TableModelListener puoi appunto avere i problemi che hai già sperimentato e descritto.
Il punto è che quel MyTableModel che hai implementato è molto "generico", ovvero funziona in modo generale per una query arbitraria. Insomma, MyTableModel non "sa" nulla, a priori, di quante/quali sono le colonne. Per fare una logica come quella che hai descritto, invece il table model dovrebbe sapere quali sono le colonne e a quali indici (es, che la quantità è la colonna di indice 1).

Quindi o fai table model distinti/slegati e specializzati, oppure cambi un pochino architettura e realizzi un table model "generico" che può essere esteso da sotto-classi che "sanno" quale è la query, che campi fornisce e in che ordine. E a quel punto puoi realizzare la logica descritta.

E già che ci sono, ti segnalo che il MyTableModel non è nemmeno corretto dal punto di vista della "tipizzazione". Infatti hai un:
Vector<Vector<String>> data

Ma poi nel while sul ResultSet istanzi un Vector non parametrizzato. Quindi innanzitutto hai sicuramente dei warning di unchecked conversion che dovrebbero essere il campanello di allarme del fatto che la tipizzazione è "dubbia" e potrebbe causare problemi.
Ma la cosa più grave è che usi getObject che restituisce un qualunque Object. E puoi metterli nel Vector<Vector<String>> proprio perché hai saltato la parametrizzazione del Vector interno.
Il problema è che quando poi vai a estrarre il dato dal Vector<String>, c'è un cast implicito a String .... e se il getObject aveva fornito es. un Integer .... si schianta!!
Quindi il MyTableModel è comunque da rivedere molto bene in ogni caso sul fronte della tipizzazione.