[JTable] Je n'arrive pas à la vider

Version imprimable

Bonjour,

Voilà je suis en train de développer une application pour mon stage. Je fais une interface qui permet de consulter des données d'une base Oracle 10g et je stocke le résultat des requêtes dans une JTable.

Le problème c'est que : quand je change de valeurs pour la requête j'arrive pas a vider la table qui c'était affiché avant (et qui contient le resultat de la req précédente), le résultat s'ajoute en bas du tableau...et ce n'est pas cohérant.

J'ai donc essayé de créer une fonction "clearTable()" dont le code est ci-dessous qui vide le modèle mais ca ne marche pas.

Est ce que vous pouvez m'aider? Est ce un problème d'algo ??

Merci de m'aider.

PS: ci dessous le code de la fonction qui affiche le tableau.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
 
//**********************************************************
 
public void afficherTableauIndicTpsSejour()
{ 
    //on nettoie le panel, et on enlève le graphe..
    JSP.removeAll();
    pnlPreview.remove(JSP);
    pnlPreview.setVisible(false);
 
 
    modell=new TableauNavigateurModel();
    table = new JTable(modell);
    modell.clearTable();
 
//  Initialisation
    JSP=new JScrollPane(table);
 
  //Ajout des colonnes précédemment déclarées
 
 
			modell.addColumn("N° Prog", liste1.toArray());
			modell.addColumn("Date \nenfournement", liste2.toArray());
			modell.addColumn("Programme", liste3.toArray());
		    modell.addColumn("Cumul", liste4.toArray());
		    modell.addColumn("Programme", liste9.toArray());
		    modell.addColumn("Cumul",liste5.toArray());
		    modell.addColumn("Pourcentage",liste6.toArray());
		    modell.addColumn("Programe", liste10.toArray());
		    modell.addColumn("Cumul",liste7.toArray());
		    modell.addColumn("Pourcentage",liste8.toArray());
 
		    //on force la taille du tableau
			table.getColumnModel().getColumn(0).setPreferredWidth(95);
		    table.getColumnModel().getColumn(1).setPreferredWidth(95);
		    table.getColumnModel().getColumn(2).setPreferredWidth(95);
		    table.getColumnModel().getColumn(3).setPreferredWidth(95);
		    table.getColumnModel().getColumn(4).setPreferredWidth(130);
		    table.getColumnModel().getColumn(5).setPreferredWidth(130);
		    table.getColumnModel().getColumn(6).setPreferredWidth(130);
		    table.getColumnModel().getColumn(7).setPreferredWidth(130);
		    table.getColumnModel().getColumn(8).setPreferredWidth(130);
		    table.getColumnModel().getColumn(9).setPreferredWidth(130);
 
 
    //on informe l'utilisateur que la table est non éditable quand il essaie de modifier une donnée
    table.addMouseListener(new MouseListener() {
        public void mouseClicked(MouseEvent e) {
        if (e.getClickCount() == 2) {
            JOptionPane.showMessageDialog(null, "Information: Vous ne pouvez pas éditer les données!","Information",JOptionPane.INFORMATION_MESSAGE);
        }
        }
 
        public void mouseEntered(MouseEvent e) {}
        public void mouseExited(MouseEvent e) {}
        public void mousePressed(MouseEvent e) {}
        public void mouseReleased(MouseEvent e) {}
        });
 
 
    table.getTableHeader().setFont(table.getFont().deriveFont(Font.BOLD));
    table.setFont(table.getFont().deriveFont(Font.NORMAL));
 
 
    //l'utilisateur ne peut pas déplacer les colonnes
    table.getTableHeader().setReorderingAllowed(false);
 
    //On déclare deux renderer un par défaut et l'autre personnalisé
    TabCellRenderer renderer1 = new TabCellRenderer();
    TabCellRenderer renderer = new TabCellRenderer();
    renderer1.setForeground(Color.black);
    renderer1.setBackground(Color.lightGray);
    int columnNumber= table.getColumnCount();
    for(int j=0; j<columnNumber; j+=2){
      table.getColumnModel().getColumn(j).setCellRenderer(renderer1);  
    }
    table.setDefaultRenderer(Object.class, renderer);
 
 
 
    //Classe qui sert a fractionner les cellules et les regrouper dans une autre	
    TableColumnModel col = table.getColumnModel();
 
    ColumnGroup nbBloc = new ColumnGroup("Nombre de blocs");
    nbBloc.add(col.getColumn(2));
    nbBloc.add(col.getColumn(3));
 
    ColumnGroup billetesMini= new ColumnGroup("% Billettes < tps séjour Mini-1/4h");
    billetesMini.add(col.getColumn(4));
    billetesMini.add(col.getColumn(5));
    billetesMini.add(col.getColumn(6));
 
    ColumnGroup billetesMaxi= new ColumnGroup("% Billettes > tps séjour Maxi");
    billetesMaxi.add(col.getColumn(7));
    billetesMaxi.add(col.getColumn(8));
    billetesMaxi.add(col.getColumn(9));
 
 
    GroupableTableHeader header = new GroupableTableHeader(col);
    header.addColumnGroup(nbBloc);
    header.addColumnGroup(billetesMini);
    header.addColumnGroup(billetesMaxi);
    table.setTableHeader(header);
 
    MultiLineHeaderRenderer renderer2 = new MultiLineHeaderRenderer();
	Enumeration enum = table.getColumnModel().getColumns();
	  while (enum.hasMoreElements()) {
	    ((TableColumn)enum.nextElement()).setHeaderRenderer(renderer2);
	  }    
 
 
    JSP.setHorizontalScrollBarPolicy(JScrollPane.HORIZONTAL_SCROLLBAR_ALWAYS);
    JSP.setVerticalScrollBarPolicy(JScrollPane.VERTICAL_SCROLLBAR_ALWAYS);
 
    JSP.setSize(pnlPreview.getSize());
    //JSP.setPreferredSize(new Dimension(pnlPreview.getSize().width, (pnlPreview.getSize().height)-10));
 
    JSP.setLocation(5,40);
    JSP.setVisible(true);
    add(JSP);
} 
 
 
/********************************************************
 
 public void clearTable(){
        
        for(int a = 0; a < getRowCount(); a++)
        {
            removeRow(a);
        }
    }
 
/*******************************************************

09/05/2008, 10h16
ngpub

Elle est où ta classe TableauNavigateurModel ? (entre balises code si possible)

Citation:

Envoyé par ngpub

Elle est où ta classe TableauNavigateurModel ? (entre balises code si possible)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
public class TableauNavigateurModel extends AbstractTableModel {
 
 
    protected Vector   dataVector;
    protected Vector   columnIdentifiers;
 
 
    public TableauNavigateurModel() {
        this(0, 0);
    }
 
    private static Vector newVector(int size) { 
		Vector v = new Vector(size); 
		v.setSize(size); 
		return v; 
    }
 
    public boolean setReorderingAllowed(int column){
        return false;
    }
 
    public TableauNavigateurModel(int rowCount, int columnCount) {
        this(newVector(columnCount), rowCount); 
    }
 
 
    public TableauNavigateurModel(Vector columnNames, int rowCount) {
        setDataVector(newVector(rowCount), columnNames);
    }
 
    public TableauNavigateurModel(Object[] columnNames, int rowCount) {
        this(convertToVector(columnNames), rowCount);
    }
 
 
 
    public TableauNavigateurModel(Vector data, Vector columnNames) {
        setDataVector(data, columnNames);
    }
 
 
    public TableauNavigateurModel(Object[][] data, Object[] columnNames) {
        setDataVector(data, columnNames);
    }
 
 
    public Vector getDataVector() {
        return dataVector;
    }
 
    private static Vector nonNullVector(Vector v) { 
	return (v != null) ? v : new Vector(); 
    } 
 
 
    public void setDataVector(Vector dataVector, Vector columnIdentifiers) {
        this.dataVector = nonNullVector(dataVector);
        this.columnIdentifiers = nonNullVector(columnIdentifiers); 
	justifyRows(0, getRowCount()); 
        fireTableStructureChanged();
    }
 
 
    public void setDataVector(Object[][] dataVector, Object[] columnIdentifiers) {
        setDataVector(convertToVector(dataVector), convertToVector(columnIdentifiers));
    }
 
 
    public void newDataAvailable(TableModelEvent event) {
        fireTableChanged(event);
    }
 
//
// Manipulating rows
// 
 
    private void justifyRows(int from, int to) { 
	// Sometimes the TableauNavigateurModel is subclassed 
	// instead of the AbstractTableModel by mistake. 
	// Set the number of rows for the case when getRowCount 
	// is overridden. 
	dataVector.setSize(getRowCount()); 
 
        for (int i = from; i < to; i++) { 
	    if (dataVector.elementAt(i) == null) { 
		dataVector.setElementAt(new Vector(), i); 
	    }
	    ((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
	}
    }
 
 
    public void newRowsAdded(TableModelEvent e) {
        justifyRows(e.getFirstRow(), e.getLastRow() + 1); 
        fireTableChanged(e);
    }
 
 
    public void rowsRemoved(TableModelEvent event) {
        fireTableChanged(event);
    }
 
 
    public void setNumRows(int rowCount) { 
        int old = getRowCount();
	if (old == rowCount) { 
	    return; 
	}
	dataVector.setSize(rowCount);
        if (rowCount <= old) {
            fireTableRowsDeleted(rowCount, old-1);
        }
        else {
	    justifyRows(old, rowCount); 
            fireTableRowsInserted(old, rowCount-1);
        }
    }
 
    public void setRowCount(int rowCount) { 
	setNumRows(rowCount); 
    } 
 
 
    public void addRow(Vector rowData) {
        insertRow(getRowCount(), rowData);
    }
 
 
    public void addRow(Object[] rowData) {
        addRow(convertToVector(rowData));
    }
 
    public void insertRow(int row, Vector rowData) {
	dataVector.insertElementAt(rowData, row); 
	justifyRows(row, row+1); 
        fireTableRowsInserted(row, row);
    }
 
    public void insertRow(int row, Object[] rowData) {
        insertRow(row, convertToVector(rowData));
    }
 
    private static int gcd(int i, int j) {
	return (j == 0) ? i : gcd(j, i%j); 
    }
 
    private static void rotate(Vector v, int a, int b, int shift) {
	int size = b - a; 
	int r = size - shift;
	int g = gcd(size, r); 
	for(int i = 0; i < g; i++) {
	    int to = i; 
	    Object tmp = v.elementAt(a + to); 
	    for(int from = (to + r) % size; from != i; from = (to + r) % size) {
		v.setElementAt(v.elementAt(a + from), a + to); 
		to = from; 
	    }
	    v.setElementAt(tmp, a + to); 
	}
    }
 
 
    public void moveRow(int start, int end, int to) { 
	int shift = to - start; 
	int first, last; 
	if (shift < 0) { 
	    first = to; 
	    last = end; 
	}
	else { 
	    first = start; 
	    last = to + end - start;  
	}
        rotate(dataVector, first, last + 1, shift); 
 
        fireTableRowsUpdated(first, last);
    }
 
 
    public void removeRow(int row) {
        dataVector.removeElementAt(row);
        fireTableRowsDeleted(row, row);
    }
 
 
    public void setColumnIdentifiers(Vector columnIdentifiers) {
	setDataVector(dataVector, columnIdentifiers); 
    }
 
 
    public void setColumnIdentifiers(Object[] newIdentifiers) {
        setColumnIdentifiers(convertToVector(newIdentifiers));
 
    }
 
 
    public void setColumnCount(int columnCount) { 
	columnIdentifiers.setSize(columnCount); 
	justifyRows(0, getRowCount()); 
	fireTableStructureChanged();
    } 
 
 
    public void addColumn(Object columnName) {
        addColumn(columnName, (Vector)null);
    }
 
 
    public void addColumn(Object columnName, Vector columnData) {
        columnIdentifiers.addElement(columnName); 
	if (columnData != null) { 
            int columnSize = columnData.size(); 
            if (columnSize > getRowCount()) { 
	        dataVector.setSize(columnSize);
            }
	    justifyRows(0, getRowCount()); 
	    int newColumn = getColumnCount() - 1; 
	    for(int i = 0; i < columnSize; i++) { 
		  Vector row = (Vector)dataVector.elementAt(i);
		  row.setElementAt(columnData.elementAt(i), newColumn); 
	    }
	} 
        else { 
	    justifyRows(0, getRowCount()); 
        }
 
        fireTableStructureChanged();
    }
 
 
    public void addColumn(Object columnName, Object[] columnData) {
        addColumn(columnName, convertToVector(columnData));
    }
 
 
    public int getRowCount() {
        return dataVector.size();
    }
 
 
    public int getColumnCount() {
        return columnIdentifiers.size();
    }
 
 
    public String getColumnName(int column) {
        Object id = null; 
	// This test is to cover the case when 
	// getColumnCount has been subclassed by mistake ... 
	if (column < columnIdentifiers.size()) {  
	    id = columnIdentifiers.elementAt(column); 
	}
        return (id == null) ? super.getColumnName(column) 
                            : id.toString();
    }
 
    public boolean isCellEditable(int row, int column) {
        return false;
    }
 
 
    public Object getValueAt(int row, int column) {
        Vector rowVector = (Vector)dataVector.elementAt(row);
        return rowVector.elementAt(column);
    }
 
    public void setValueAt(Object aValue, int row, int column) {
        Vector rowVector = (Vector)dataVector.elementAt(row);
        rowVector.setElementAt(aValue, column);
        fireTableCellUpdated(row, column);
    }
 
 
 
 
    protected static Vector convertToVector(Object[] anArray) {
        if (anArray == null) { 
            return null;
	}
        Vector v = new Vector(anArray.length);
        for (int i=0; i < anArray.length; i++) {
            v.addElement(anArray[i]);
        }
        return v;
    }
 
 
    protected static Vector convertToVector(Object[][] anArray) {
        if (anArray == null) {
            return null;
	}
        Vector v = new Vector(anArray.length);
        for (int i=0; i < anArray.length; i++) {
            v.addElement(convertToVector(anArray[i]));
        }
        return v;
    }
 
    public void clearTable(){
 
        for(int a = 0; a < getRowCount(); a++)
        {
            removeRow(a);
        }
    }
 
}

09/05/2008, 11h41
ngpub
Je pense que c'est un problème d'événements, mais Il y a beaucoup de code, difficile de faire une réponse rapide et précise.
Donc voici juste des idées :

Pourquoi des événements arrivent-ils de l'extérieur de l'objet ?
Quel forme ont-ils ?
Code:

1 2 3 4 public void newDataAvailable(TableModelEvent) public void newRowsAdded(TableModelEvent) public void rowsRemoved(TableModelEvent)
Pourquoi c'est deux méthodes ?
Code:

1 2 3 public void rowsRemoved(TableModelEvent) public void clearTable()
Pourquoi pas juste ?
Code:

1 2 3 4 5 public void clearTable() { dataVector.clear(); fireTableDataChanged(); }
09/05/2008, 13h48
rock in the air
Citation:
Envoyé par ngpub

Je pense que c'est un problème d'événements, mais Il y a beaucoup de code, difficile de faire une réponse rapide et précise.
Donc voici juste des idées :

Pourquoi des événements arrivent-ils de l'extérieur de l'objet ?
Quel forme ont-ils ?

Code:

1 2 3 4 public void newDataAvailable(TableModelEvent) public void newRowsAdded(TableModelEvent) public void rowsRemoved(TableModelEvent)

Pourquoi c'est deux méthodes ?

Code:

1 2 3 public void rowsRemoved(TableModelEvent) public void clearTable()

Pourquoi pas juste ?

Code:

1 2 3 4 5 public void clearTable() { dataVector.clear(); fireTableDataChanged(); }
les 5 premières méthodes me servent pour un autre tableau.

Sinon la solution de cleartable() n'a pas marché!!:?
09/05/2008, 13h58
ngpub

Tu peux essayer de surcharger toutes les méthodes fire de ton modèle pour afficher tous les événements qu'il envoie, et ainsi voir s'ils sont cohérents avec les actions.
09/05/2008, 14h04
rock in the air

j'avais déjà essayé ca mais ca ne marche ca ne vide pas la table mais rajoute les lignes tout en bas
09/05/2008, 14h16
ngpub

L'idée de mon post précédent n'est pas de corriger l'erreur mais juste de comprendre ce qui ce passe. Il n'y a pas de secret le modèle communique uniquement par événements avec le table et normalement cela fonction très bien. Donc je pense que tu as des événements qui ne sont pas cohérents avec la mise à jour de ton modèle. Trouve les et tu auras résolu ton problème.
11/05/2008, 20h17
ngpub
Citation:
Pourquoi pas juste ?

Code:

1 2 3 4 5 public void clearTable() { dataVector.clear(); fireTableDataChanged(); }
Je me suis trompé c'est fireTableStructureChanged() qu'il faut utiliser.

J'ai essayé ca ne marche toujours pas....
Code:

1 2 3 4 5 6 7 table = new JTable(modell); //TableauNavigateurModel modell = new TableauNavigateurModel(); modell= (TableauNavigateurModel) table.getModel(); modell= new TableauNavigateurModel(); modell.clearTable(); modell.fireTableStructureChanged(); table.setModel(modell);
Je me demande si ca ne vient pas du model puisque j'utilise un DefaultTableModel mais ce que j'ajoute comme données dans la table c des listes de type List...
le modèle ne se vide pas...pourquoi???????????

12/05/2008, 14h41
ngpub

Pour un problème proche du tien, j'ai fait un bout de code (exemple de TableModel) qui pourra peut-être t'aider, il est ici.
12/05/2008, 14h50
rock in the air

J'arrive pas a voir ou est le problème, pourtant je fais ce qu'il faut mais rien ne se passe!

car normalement je remplit mon tableau a partir d'une requete avec saisie des paramètres au clavier.

Ensuite j'appuie sur un bouton qui affiche le tableau...tout en vidant avant mais dès que je fais une autre requete le model ne se vide pas et ajoute les lignes après ce qui était affiché avant....:(
12/05/2008, 14h59
ngpub

Citation:

car normalement je remplit mon tableau...

Il faut être sûr !

Une solution est de tracer toutes les modifications avec la méthode System.out.println(String).
12/05/2008, 15h08
rock in the air

bah mon tableau se remplit , voici un screen shot:
Screen Shot Tableau