Discussion :

[oneagaindoguys]

Bonjour, j'ai choisi de poster ce sujet ici, mais j'aurais très bien pu le faire ailleurs car il n'est pas propre à Java, ni un autre langage. Cela dit, c'est Java que j'utilise, moi.

Comme expliqué dans le titre, je cherche une stratégie pour afficher un résultat de 200 000 lignes. J'ai une table de ma base de données sous MySQL pas mal indéxée. En fonction de certains critères, je fais une restriction sur un attribut bient précis (le client). Lorsque je travaille sur un gros client, le SQBD peut me renvoyer jusqu'à 200 000 lignes. Il faut les afficher de manière simple et rapide
A l'heure actuelle, j'affiche les données sur une IG swing et plus particulièrement une JTable. La fenêtre s'ouvre en 20-25 secondes et c'est beaucoup trop !!! Je trouve ça honorable, me concernant mais pas du point de vue utilisateur. Parmi les 200 000 lignes très peu seront utiles mais on m'impose de tout afficher. J'avais penser placer un filtre avant l'affichage de la fenêtre mais ce ne serait pas simple à l'utilisation.
J'ai aussi pensé découper les résultats en pages limités en nombre de lignes, mais c'est également pas simple à utiliser.
Et pour couronner le tout, l'ancien programme le faisait en 4 secondes (il affichait d'abord la fenêtre puis remplissait au fur et à mesure la table. Et le remplissage se faisait en fonction de la position de la scroll de la table !

Alors si vous aussi vous avez déjà eu ce problème, comment avez-vous fait ?

[adiGuba]

Salut,


Il faudrait voir comment tu remplit la table ?
Si tu récupères les 200000 lignes pour les mettre dans une JTable cela peut être long en effet...

Maintenant en chargeant les données au fur et à mesure de l'affichage tu peux t'en sortir bien mieux. Ce doit être faisable via un TableModel perso et un Cursor scrollable...


a++

[hwoarang]

Salut,

Je vois au moins 2 solutions :
- Paginer ta table. Comme ca, tu n'affiches que 100 resultats par exemple et c'est rapide.
- Remplir ta table progressivement en ne bloquant pas l'UI. Pour cela, il existe une classe : SwingWorker.

a+

[oneagaindoguys]

Merci pour vos réponses.
Pour afficher les données, j'ai une méthode qui balaye mon résultset et copie les données ans un tableau d'objet qui est donné au TableModel.
"Ce doit être faisable via un TableModel perso et un Cursor scrollable". Quel est le principe ?

Le fait de remplir au fur et à mesure ne va pas prendre plus de temps que ce qui est déjà fait ? Surtout si on fait une MAJ instantanée de l'IG. Par ailleurs, qu'en est-il concernant le rendu ? C'est à dire lors d'une mise à jour de la table, est-ce que la scrollBar peut rester au même endroit plutot que de revenir tout en haut ?

J'avais proposé l'idée de la pagination tout en étant contre et le client l'est aussi, car il faut retrouver l'info dans les pages. Navigation ultra-lourde !

[adiGuba]

Pour afficher les données, j'ai une méthode qui balaye mon résultset et copie les données ans un tableau d'objet qui est donné au TableModel.

Et cela met combien de temps ? Je parie que c'est ce code qui te prend du temps.

De manière générale il faudrait que tu arrives à déterminer l'origine de ces 25 secondes dans ton code...

[QUOTE=oneagaindoguys;5616225]"Ce doit être faisable via un TableModel perso et un Cursor scrollable". Quel est le principe ?[/code]
A créer le Statement comme ceci :

Code :

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

createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);

Du coup lorsque tu fait une requête, le ResultSet est scrollable, c'est à dire que tu peux accéder à n'importe quelle ligne directement (sans forcément tout lire), en utilisant la méthode absolute()

Du coup tu n'as pas besoin de charger toutes les lignes, mais uniquement les lignes qu'il te faut. Il faudra pour cela implémenter ton propre TableModel, et surement gérer correctement les threads EDT/SQL...


a++

[tchize_]

le but du cursor Scrollable, c'est de ne charger en mémoire que les 50 données visible à l'écran. Il faut savoir qu'un JTable ne dessine QUE les lignes visibles à l'écran. D'ou l'intéret de créer un TableModel (que JTable utilise pour lire les rows) utilisant un cursosr SQL. Tu n'a alors besoin que de charger le 50 lignes à l'écran, c'est beaucoup plus rapide.

JAMAIS tu n'affichera 200.000 "en même temps", ton écran ne fait pas 50m de haut

[oneagaindoguys]

Effectivement, je n'ai que 15 lignes affichées à l'écran. Du coup, ça explose la RAM, mais une fois chargé, c'est niquel.
Ca se passe comment en fait, pour l'utilisation ?

J'appelle le constructeur de ma fenêtre, qui va la dessiner. J'ai une méthode qui travaille la JTable (c'est un objet que j'ai redéfini, et le modèle a aussi été redéfini).
Je passais en paramètre au modèle, ma requête. Je créais une connexion à la base de donnée, créais un Statement, qui me renvoyais un Resultset une fois la requête exécutée. Ensuite, je transformait on ResultSet en un tableau d'objet à deux dimensions pour l'affecter au TableModel. C'est logique que ce soit ici que je perde le plus de temps, j'ai deux boucles imbriquées (2 dimensions). Une dans le sens des lignes et l'autre sur les colonnes. Soit 200 000 lignes * 10 colonnes = 1 200 000 instructions (obj[i][j] = rs.getString(j+1));

J'ai chronométré un peu ce qu'il se passe. mon ResultSet est créé en 7 secondes et le tableau 18 secondes après. 7 secondes, c'est encore un peu trop mais beaucoup mieux.

Comment va fonctionner le lien entre la base de données et la fenêtre ? Je vais devoir mettre un écouteur sur ma scrollBar du JScrollPane (lui aussi redéfini) afin de capter sa position et de positionner mon curseur en fonction d'elle avec absolute ? Si oui, comment faire apparaitre à l'écran les données une fois positionné ?
Il est indispensable de faire ça avec des Threads ?

J'ai encore un autre problème. Sur les fenêtre, à chaque table, il y a un champs qui permet de filtre le contenu directement par une valeur écrite dans le champs. J'ai des nombres triés dans ma 1ere colonne et recherche par dichotomie la valeur saisie dans le champs et efface de la table le contenu de se trouvant avant la valeur saisie. (Pas facile d'expliquer)
Vous me direz que je peux surement déplacer le curseur à cette valeur. Mais il est possible que l'on m'impose de devoir effacer le contenu en question et qu'il faudra le faire réapparaître si on efface le contenu du champs.

Sinon, connaissez-vous des exemples biens fais ou une explication théorique ?

[tchize_]

non, pas touche à la ScrollBar, c'est le JTable qui la gère. Le JTable va te demander les rows à ton TableModel. Et, au lieu de charger 200.000 lignes en mémoire, tu ne charge, au fur et à mesure, que les row qu'il te demande (éventuellement tu les caches pour ne pas les lires plusieurs fois)

A noter aussi que, ce qui bouffe, ce ne sont pas les 2 boucles en elles même, mais le fait que tu instancie d'un coup 1 millions d'objets java.

Donc tu va avoir le schéma suivant:

JTable s'affiche
-> un certain nombre de fois, JTable demande au TableModel le cellule [N,Y]
-> tu scroll ton resultset à la ligne N
-> tu la décompose et la transforme en un beau ROW comme tu le fait déjà
-> Tu retourne l'élément Y du ROW
-> Tu cache le ROW pour les autre appels au même ROW



Pour les 7 secondes, c'est dépendant de la SGDB. La solution autour serait de faire plusieurs requêtes. D'abord une qui fait le count. Ensuite, en fonction des ROW demandés, faire des requêtes SQL avec des limit pour ne lire qu'une "fenêtre" de résultat.

[oneagaindoguys]

JTable s'affiche
-> un certain nombre de fois, JTable demande au TableModel le cellule [N,Y]
Il s'agit de la méthode getValueAt ?

-> tu scroll ton resultset à la ligne N
-> tu la décompose et la transforme en un beau ROW comme tu le fait déjà
Copie des valeurs du resultset dans le tableau d'objet du TableModel ?

-> Tu retourne l'élément Y du ROW
-> Tu cache le ROW pour les autre appels au même ROW



Pour les 7 secondes, c'est dépendant de la SGDB. La solution autour serait de faire plusieurs requêtes. D'abord une qui fait le count. Ensuite, en fonction des ROW demandés, faire des requêtes SQL avec des limit pour ne lire qu'une "fenêtre" de résultat.

[tchize_]

Il s'agit de la méthode getValueAt ?
-> oui

Copie des valeurs du resultset dans le tableau d'objet du TableModel ?
-> voilà, mais seulement un ROW. Et quand on te demandera ce row, faudra regrder 1) si tu l'a déjà, 2) si pas, scroller le resultset


Bien sur tout ça suppose un resultset scrollable dans les deux sens. Voir les doc/tutos jdbc pour ça

[oneagaindoguys]

Concernant le filtre (afficher uniquement les lignes dont la valeur de la 1ere colonne est > à une valeur donnée), il faut faire une recherche dans la ResultSet, ou bien il existe une méthode déjà toute faite ? J'ai fouillé la doc, mais je n'ai rien trouvé

[oneagaindoguys]

J'ai essayé votre méthode, mais le soucis, c'est que getValueAt() est appellé pour toutes les lignes et pas uniquement celle qui sont visibles à l'écran. Pour lui, l'intégralité de la table est visible à l'écran et non scrollée.

Comment je peux limiter les appels de getValueAt ??

[tchize_]

alors le "hic" c'est que JTable va scanner 1 fois tous les rows pour ajuster les tailles des colonnes :/

Il y a moyen de désactiver ce comportement. De mémoire, essayer le setAutoResizeMode(AUTO_RESIZE_OFF), mais je ne suis plus certains que c'est là qu'il faut jouer.

[oneagaindoguys]

Effectivement, c'est un hic, sinon, autant copier directement, ça va plus vite !

setAutoResizeMode(AUTO_RESIZE_OFF) c'est pas pour empêcher de la scroller sur l'horizontale ??

[tchize_]

je sais qu'on peux empecher la JTable de scanner ses rows à l'initialisation (ça lui sert qu'au layout), mais j'avoue ne plus me souvenir comment, va falloir chercher un peu ^ ^

[oneagaindoguys]

des mots clés ?
jtable getvalueat initialisation

[adiGuba]

alors le "hic" c'est que JTable va scanner 1 fois tous les rows pour ajuster les tailles des colonnes :/

Ce n'est pas le cas chez moi...

Par défaut le getValueAt() n'est effectué que sur les lignes visibles...


a++

[oneagaindoguys]

J'ai mis une trace dans le getValueAt. J'écris dans la console le parm1 qui correspond à la ligne voici comment ça se passe :

A l'ouverture de la fenêtre, il s'arrête là ou l'affichage s'arrête (18) puis repart de 0 pour aller écrit jusqu'à 200 000.
Puis il remonte jusqu'à 0 mais pas de 1 en 1 il le fait en 3 4 fois.
Si je réduit la fenêtre et l'agrandie par la suite, il recommence
Si je déplace le curseur de la scroll bar, dans la console je ne vois que les lignes affichées à l'écran.

Pour voir où getValueAt était invoquée, j'ai levée un exception pour y voir la trace. A l'init ça vient de prepareRenderer de JTable. Il va jusqu'à 18.

Voici le code :

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
 
/**
     * Prepares the renderer by querying the data model for the
     * value and selection state
     * of the cell at <code>row</code>, <code>column</code>.
     * Returns the component (may be a <code>Component</code>
     * or a <code>JComponent</code>) under the event location.
     * <p>
     * During a printing operation, this method will configure the
     * renderer without indicating selection or focus, to prevent
     * them from appearing in the printed output. To do other
     * customizations based on whether or not the table is being
     * printed, you can check the value of
     * {@link javax.swing.JComponent#isPaintingForPrint()}, either here
     * or within custom renderers.
     * <p>
     * <b>Note:</b>
     * Throughout the table package, the internal implementations always
     * use this method to prepare renderers so that this default behavior
     * can be safely overridden by a subclass.
     *
     * @param renderer  the <code>TableCellRenderer</code> to prepare
     * @param row       the row of the cell to render, where 0 is the first row
     * @param column    the column of the cell to render,
     *                  where 0 is the first column
     * @return          the <code>Component</code> under the event location
     */
    public Component prepareRenderer(TableCellRenderer renderer, int row, int column) {
        Object value = getValueAt(row, column);
 
        boolean isSelected = false;
        boolean hasFocus = false;
 
        // Only indicate the selection and focused cell if not printing
        if (!isPaintingForPrint()) {
            isSelected = isCellSelected(row, column);
 
            boolean rowIsLead =
                (selectionModel.getLeadSelectionIndex() == row);
            boolean colIsLead =
                (columnModel.getSelectionModel().getLeadSelectionIndex() == column);
 
            hasFocus = (rowIsLead && colIsLead) && isFocusOwner();
        }
 
	return renderer.getTableCellRendererComponent(this, value,
	                                              isSelected, hasFocus,
	                                              row, column);
    }

Par contre l'appel qui va jusqu'à 200 000 pas moyen de voir. J'ai mis une condition qui est si la ligne était > 18 alors levée une exception, mais elle est géré en amont car le programme s'arrête et pas d'exception dans la console.

[adiGuba]

Pourquoi tu nous donnes le code de prepareRenderer() ??? C'est ton code à toi dont on a besoin !

Perso en créant ma JTable avec un model de 500000 lignes je ne rencontre pas le problème que tu cites :

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
TableModel model = new AbstractTableModel() {
	@Override
	public int getColumnCount() {
		return 5;
	}
 
	@Override
	public int getRowCount() {
		return 500000;
	}
 
	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		System.out.println("getValueAt("+rowIndex+", "+columnIndex+")");
		return rowIndex + columnIndex;
	}
};
JTable table = new JTable(model);
JOptionPane.showMessageDialog(null, new JScrollPane(table));

C'est à dire qu'à l'affichage il ne récupère qu'une vingtaine de ligne (celle visible), puis les autres au fur et à mesure que je scrolle...

a++

[oneagaindoguys]

Voici le code de mon modèle

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
 
public class TableModel2 extends AbstractTableModel {
    private Object[][] data;
    private String [] titles;
    private int minimum, real;
    private boolean webAccess;
    private DataBase dataBase;
    private ResultSet res;
    private String querry, attributes;
 
    public TableModel2 (String querry, String[] titres, int minimum, boolean webAccess, DataBase dataBase) {
        this.minimum = minimum;
        this.querry = querry;
        this.titles = titres;
        this.webAccess = webAccess;
        this.dataBase = dataBase;
        long time = System.currentTimeMillis();
        this.attributes = querry.substring(querry.indexOf("SELECT")+6, querry.indexOf("FROM"));
        String querryCount = querry.replaceAll(attributes, " COUNT(*) ");
        System.out.println("Envoie de la reqûete");
        try {
            ResultSet rs = dataBase.getResult(querryCount);
            rs.next();
            data = new Object[rs.getInt(1)][titres.length];
            this.res = this.dataBase.getResult(querry);
            System.out.println("Resultset est OK  -->  "+(System.currentTimeMillis()-time)+" ms");
            real = data.length;
            System.out.println("taille de la table : "+real);
        } catch (SQLException ex) {ex.printStackTrace();}
    }
   public int getColumnCount() {
        try {return data[0].length;}
        catch(ArrayIndexOutOfBoundsException ex){ex.printStackTrace();return 0;}
   }
 
    public Object getValueAt(int parm1, int parm2) {
        System.out.println(parm1+"    "+parm2);
        if (parm1>18) throw new NullPointerException("HEIN ???");
        try {
             if(data[parm1][parm2]==null) {
                 res.absolute(parm1+1);
                 data[parm1][parm2] = res.getString(parm2+1);
             }
             else if (data[parm1][parm2]==null) return "";
             return data[parm1][parm2];
        }
        catch(ArrayIndexOutOfBoundsException ex) {ex.printStackTrace();return "";}
        catch(NullPointerException npe){npe.printStackTrace();return null;}
        catch(SQLException npe){npe.printStackTrace();return null;}
    }
 
   public int getRowCount() {
       try {return data.length;}
        catch(ArrayIndexOutOfBoundsException ex){ex.printStackTrace();return 0;}
        catch(NullPointerException ex){ex.printStackTrace();return 0;}
   }
 
    public int getReal() {
        return real;
    }
 
   public String getColumnName(int col){
        return titles[col];
   }
 
   public boolean isCellEditable(int rowIndex, int columnIndex) {
        if (columnIndex == 4 && webAccess) return true;
        else return false;
    }
 
    public Object[][] getData() {
        return data;
    }
 
    public void setData(Object[][] newData) throws ArrayIndexOutOfBoundsException {
        this.data=newData;
    }
}

Et ce que je trouve dans la console

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
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
 
Envoie de la reqûete
start
Envoie de la reqûete
Resultset est OK  -->  16 ms
taille de la table : 623
16
prepared renderer  0
0    0
prepared renderer  0
0    1
prepared renderer  0
0    2
prepared renderer  0
0    3
prepared renderer  0
0    4
prepared renderer  0
0    5
prepared renderer  0
0    6
prepared renderer  0
0    7
prepared renderer  0
0    8
prepared renderer  0
0    9
prepared renderer  1
1    0
prepared renderer  1
1    1
prepared renderer  1
1    2
prepared renderer  1
1    3
prepared renderer  1
1    4
prepared renderer  1
1    5
prepared renderer  1
1    6
prepared renderer  1
1    7
prepared renderer  1
1    8
prepared renderer  1
1    9
prepared renderer  2
2    0
prepared renderer  2
2    1
prepared renderer  2
2    2
prepared renderer  2
2    3
prepared renderer  2
2    4
prepared renderer  2
2    5
prepared renderer  2
2    6
prepared renderer  2
2    7
prepared renderer  2
2    8
prepared renderer  2
2    9
prepared renderer  3
3    0
prepared renderer  3
3    1
prepared renderer  3
3    2
prepared renderer  3
3    3
prepared renderer  3
3    4
prepared renderer  3
3    5
prepared renderer  3
3    6
prepared renderer  3
3    7
prepared renderer  3
3    8
prepared renderer  3
3    9
prepared renderer  4
4    0
prepared renderer  4
4    1
prepared renderer  4
4    2
prepared renderer  4
4    3
prepared renderer  4
4    4
prepared renderer  4
4    5
prepared renderer  4
4    6
prepared renderer  4
4    7
prepared renderer  4
4    8
prepared renderer  4
4    9
prepared renderer  5
5    0
prepared renderer  5
5    1
prepared renderer  5
5    2
prepared renderer  5
5    3
prepared renderer  5
5    4
prepared renderer  5
5    5
prepared renderer  5
5    6
prepared renderer  5
5    7
prepared renderer  5
5    8
prepared renderer  5
5    9
prepared renderer  6
6    0
prepared renderer  6
6    1
prepared renderer  6
6    2
prepared renderer  6
6    3
prepared renderer  6
6    4
prepared renderer  6
6    5
prepared renderer  6
6    6
prepared renderer  6
6    7
prepared renderer  6
6    8
prepared renderer  6
6    9
prepared renderer  7
7    0
prepared renderer  7
7    1
prepared renderer  7
7    2
prepared renderer  7
7    3
prepared renderer  7
7    4
prepared renderer  7
7    5
prepared renderer  7
7    6
prepared renderer  7
7    7
prepared renderer  7
7    8
prepared renderer  7
7    9
prepared renderer  8
8    0
prepared renderer  8
8    1
prepared renderer  8
8    2
prepared renderer  8
8    3
prepared renderer  8
8    4
prepared renderer  8
8    5
prepared renderer  8
8    6
prepared renderer  8
8    7
prepared renderer  8
8    8
prepared renderer  8
8    9
prepared renderer  9
9    0
prepared renderer  9
9    1
prepared renderer  9
9    2
prepared renderer  9
9    3
prepared renderer  9
9    4
prepared renderer  9
9    5
prepared renderer  9
9    6
prepared renderer  9
9    7
prepared renderer  9
9    8
prepared renderer  9
9    9
prepared renderer  10
10    0
prepared renderer  10
10    1
prepared renderer  10
10    2
prepared renderer  10
10    3
prepared renderer  10
10    4
prepared renderer  10
10    5
prepared renderer  10
10    6
prepared renderer  10
10    7
prepared renderer  10
10    8
prepared renderer  10
10    9
prepared renderer  11
11    0
prepared renderer  11
11    1
prepared renderer  11
11    2
prepared renderer  11
11    3
prepared renderer  11
11    4
prepared renderer  11
11    5
prepared renderer  11
11    6
prepared renderer  11
11    7
prepared renderer  11
11    8
prepared renderer  11
11    9
prepared renderer  12
12    0
prepared renderer  12
12    1
prepared renderer  12
12    2
prepared renderer  12
12    3
prepared renderer  12
12    4
prepared renderer  12
12    5
prepared renderer  12
12    6
prepared renderer  12
12    7
prepared renderer  12
12    8
prepared renderer  12
12    9
prepared renderer  13
13    0
prepared renderer  13
13    1
prepared renderer  13
13    2
prepared renderer  13
13    3
prepared renderer  13
13    4
prepared renderer  13
13    5
prepared renderer  13
13    6
prepared renderer  13
13    7
prepared renderer  13
13    8
prepared renderer  13
13    9
prepared renderer  14
14    0
prepared renderer  14
14    1
prepared renderer  14
14    2
prepared renderer  14
14    3
prepared renderer  14
14    4
prepared renderer  14
14    5
prepared renderer  14
14    6
prepared renderer  14
14    7
prepared renderer  14
14    8
prepared renderer  14
14    9
prepared renderer  15
15    0
prepared renderer  15
15    1
prepared renderer  15
15    2
prepared renderer  15
15    3
prepared renderer  15
15    4
prepared renderer  15
15    5
prepared renderer  15
15    6
prepared renderer  15
15    7
prepared renderer  15
15    8
prepared renderer  15
15    9
prepared renderer  16
16    0
prepared renderer  16
16    1
prepared renderer  16
16    2
prepared renderer  16
16    3
prepared renderer  16
16    4
prepared renderer  16
16    5
prepared renderer  16
16    6
prepared renderer  16
16    7
prepared renderer  16
16    8
prepared renderer  16
16    9
prepared renderer  17
17    0
prepared renderer  17
17    1
prepared renderer  17
17    2
prepared renderer  17
17    3
prepared renderer  17
17    4
prepared renderer  17
17    5
prepared renderer  17
17    6
prepared renderer  17
17    7
prepared renderer  17
17    8
prepared renderer  17
17    9
prepared renderer  18
prepared renderer  18
prepared renderer  18
prepared renderer  18
prepared renderer  18
prepared renderer  18
prepared renderer  18
prepared renderer  18
prepared renderer  18
prepared renderer  18
0    0
1    0
1    0
2    0
2    0
3    0
4    0
5    0
5    0
6    0
6    0
7    0
7    0
8    0
3    0
4    0
9    0
10    0
10    0
11    0
11    0
12    0
12    0
13    0
14    0
15    0
15    0
16    0
16    0
17    0
17    0
18    0
13    0
14    0
8    0
9    0
19    0

Avec ça si je déplace le curseur, les lignes en dessous sont vides mais ce que nous cherchons à savoir c'est qui appel de getvalueAt avec en param des rows sous celles qui sont cachées.