[JTable] Je n'arrive pas à la vider

**rock in the air** · 09/05/2008, 10h08

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
        }
    }
 
/*******************************************************

**ngpub** · 09/05/2008, 10h16

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

**rock in the air** · 09/05/2008, 10h18

Envoyé par ngpub

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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);
        }
    }
 
}

[JTable] Je n'arrive pas à la vider

Composants Java

Vue hybride

Discussions similaires

Partager

Partager