Tri de la Jtable selon un argument donnée

**afkiba** · 31/08/2018, 12h24

Bonjour,
je souhaite faire le traitement de ma base de données dans un Jtable mais je rencontre quelques difficultés.
Ce traitement consiste à identifier certaines lignes dans mon Jtable selon un argument de 31 par rapport au cumul progressive des chiffres.
Pour y parvenir, j'ai chargé ma base de donnée par ce 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
	public void chargementBase(){
		SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
		MetierImplTontinier metier=new MetierImplTontinier();
		Date dateDebut=dateD.getDate();
		java.sql.Date SqldateD=new java.sql.Date(dateDebut.getTime());
		Date dateFin=dateF.getDate();
		java.sql.Date SqldateF=new java.sql.Date(dateFin.getTime());
		String numAgent=txtnumAgent.getText();
		String type=cmbType.getSelectedItem().toString();
		// Chargement de la liste de données provenant de la table A
		//List<PassageTontinierCaisse> mouvement1=metier.consulterRetraitEnregistreCaisse(SqldateD, SqldateF, numAgent,type);
		// Chargement de la liste de données provenant de la Table B
		List<Mouvement> mvt=metier.consulterRetrait(SqldateD, SqldateF, numAgent,type);
		model=new DefaultTableModel();
		model.setColumnIdentifiers(new Object[]{"N°","Date","Client","Agent","Compte", "Nbre","Mise","Type","Cumul","Cumul"});
		Object[] rows=new Object[9];
		int a=1;
		//Ajout dans le Jtable des données de la table A
		for (int i = 0; i < mvt.size(); i++) {
   	    	rows[0]=a++;
   	    	rows[1]=sdf.format(mvt.get(i).getDateMouvement());
   	    	rows[2]=mvt.get(i).getCompte().getNumClient();
   	    	rows[3]=mvt.get(i).getNumAgent();
   	    	rows[4]=mvt.get(i).getNumCompte();
   	    	//rows[5]=mvt.get(i).getCompte().getClient().getNom()+' '+mvt.get(i).getCompte().getClient().getPrenom() ;
   	    	rows[5]=mvt.get(i).getNombre();
   	    	rows[6]=mvt.get(i).getCompte().getMontantMise();
   	    	rows[7]=mvt.get(i).getTypeOp();
   	    	rows[8]=mvt.get(i).getNombre()*mvt.get(i).getCompte().getMontantMise();
 
   	    	//rows[6]=mvt.getNumero();
   	    	model.addRow(rows);
 
   	    }/**/
 
   	    table.setModel(model);
   	 setTableModelListener();
   	calculCumul();
 
	}

Puis je modifier mon Jtable en calcul le cumul par ce code ci.

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
private void calculCumul() {
		String numCompte;	
       	int lastRow = model.getRowCount() - 1; // dernière ligne
    	//int lastRowDernier = model.getRowCount() ;
       	int solde=0;
       	String compte;
      //	Collections.sort(List<model.getValueAt(i, 4).toString()>, Comparator<model.getValueAt(i, 4).toString()>);
            	for (int i = 0; i < lastRow; i++) {
 
            			solde+=(int) model.getValueAt(i, 5);
                		model.setValueAt(solde, i, 9);
 
            	}
 
}

Pour permettre à Jtable d'être modifiable

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
private void setTableModelListener() {
 
	    //	int lastRow = model.getRowCount() - 1;
	        tableModelListener = new TableModelListener() {
 
	            public void tableChanged(TableModelEvent e) {
	            	int lastColoum = model.getColumnCount();
 
	            	if (e.getType() == TableModelEvent.UPDATE && e.getFirstRow() 
	            						< lastColoum && e.getLastRow() 
	            						< lastColoum && e.getColumn()==1) {
 
	            		//etatRemboursement();
	            		calculCumul();
	            			}
	            			}
 
	          			};
	          table.getModel().addTableModelListener(tableModelListener);
 
 
	    }

Actuellement le résultat que j'obtient par rapport au cumul n'est pas celui que je veux. Car ce code me permet de faire le cumul pour tous les comptes, mais je souhaite faire le cumul pour chaque compte.
Mon problème se résume en deux étapes :
1- comment pouvoir faire le cumul progressive par compte;
2- comment pouvoir identifier les lignes qui permettent d'augmenter chaque 31ème unité dans le cumul par compte.

Merci

**joel.drigo** · 03/09/2018, 13h05

Salut,

Envoyé par afkiba

1- comment pouvoir faire le cumul progressive par compte;

2 approches :

Les données sont triées selon le champ de rupture, ici à priori le numéro de compte (donc la colonne d'index 4).
Si les données ne changent pas dans la table après chargement (donc pas de saisie possible dans la table, pas d'insertion ou suppression de colonne), pas besoin d'écouteur. Il suffit après initialisation du modèle avec les données de la table, de parcourir toutes les lignes, et de calculer le cumul, de le remettre à zéro chaque fois qu'on détecte une rupture de valeur (donc la valeur de la colonne 4 change par rapport à celle connue jusque là).

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
double cumul=0; 
String numcompte=null; // une valeur qui n'existe nulle part
for(int i=0; i<nombreDeLignes; i++) {
 
    String numcompteLigne = /*...*/;
    if ( numcompte==null || !numcompte.equals(numcompteLigne) ) {
 
         numcompte = numcompteLigne;
         cumul=0;
    }
 
    cumul+= valeurACumuler(i);
    stockerLaValeurDuCumul(i, numcompte, cumul);    
 
}

S'il y a des changements possibles, il faut écouter les événements, retrier, et recalculer. Soit tout recalculer (même méthode que ci-dessus). Soit optimiser : on détermine le numéro de compte, et on parcourt, à partir de la ligne modifiée, vers le début pour trouver la première ligne ou il y a rupture du numéro de compter, puis on parcourt vers la fin vers jusqu'à la rupture.

Les données ne sont pas triées. Pour le calcul global, on va utiliser une Map<String,Integer> pour stocker les cumuls, par compte (la clef est le numéro de compte, la valeur le cumul), et la remplir en parcourant toutes les lignes. Pour le calcul sur modification, il faudra reparcourir toutes les lignes, ne traiter que les lignes qui correspondent au numéro de compte pour faire le cumul.

On peut réaliser ces deux opérations en utilisant un Stream Java. Dans le premier cas, en utilisant un Collectors.groupingBy(), dans le second, par filtrage. Les deux traitements peuvent être les mêmes au filtrage prêt.

Envoyé par afkiba

Ce traitement consiste à identifier certaines lignes dans mon Jtable selon un argument de 31 par rapport au cumul progressive des chiffres.

Envoyé par afkiba

2- comment pouvoir identifier les lignes qui permettent d'augmenter chaque 31ème unité dans le cumul par compte.

Je ne comprends pas ce que ça veut dire.

Attention, il y a un problème dans ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public void tableChanged(TableModelEvent e) {
	            	int lastColoum = model.getColumnCount();
 
	            	if (e.getType() == TableModelEvent.UPDATE && e.getFirstRow() 
	            						< lastColoum && e.getLastRow() 
	            						< lastColoum && e.getColumn()==1) {
 
	            		//etatRemboursement();
	            		calculCumul();
	            			}
	            			}

lastColoum est un nombre de colonnes. getFirstRow() et getLastRow() sont des numéros de lignes. Ce n'est pas logique de comparer des numéros de lignes et un nombre de colonnes. La détection de changement se fait à priori uniquement sur les premières lignes de ta table, à moins que par hasard tu aies plus de colonnes que de lignes.
Par ailleurs, pourquoi aurais-tu besoin de tester les numéros de lignes ? Des qu'une modification est faite, sur la colonne qui contient la valeur à cumuler, alors il faut recalculer le cumul pour le numéro de compte.
De même, tu fait le traitement sur une modification de la colonne d'index 1, donc une date... il doit y avoir une erreur ici.

Exemples pour le traitement par map ou stream, dans le cas où les données ne sont pas triées :

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
 
// génération des données de démo
String[] accounts = {"A","B","C"};
class Row {
 
	private String account;
	private int value;
 
	public Row(String account, int value) {
		this.account=account;
		this.value=value;
	}
 
	public String getAccount() {
		return account;
	}
 
	public int getValue() {
		return value;
	}
 
	@Override
	public String toString() {
		return "["+account+":"+value+"]";
	}
 
}
List<Row> rows = Stream.generate(()->new Row(accounts[ThreadLocalRandom.current().nextInt(0,accounts.length)], ThreadLocalRandom.current().nextInt(1,10)))
		.limit(10)
		.collect(Collectors.toList());
 
// fin génération des données de démo
 
// affichage données
rows.forEach(System.out::println);
 
// exemple pour un cumul par parcourt :
Map<String, Integer> map = new HashMap<>();
for(Row row : rows) {
	map.compute(row.getAccount(), (account, currentvalue)-> currentvalue==null?row.getValue():currentvalue+row.getValue());
}
System.out.println("Cumul par parcourt (forEach) : " + map);
 
// exemple pour un cumul par stream
Map<String, Integer> result = rows.stream().collect(Collectors.groupingBy(Row::getAccount, Collectors.summingInt(Row::getValue)));
System.out.println("Cumul par stream/groupingby : " + result);
 
// exemple pour un cumul par stream sur un seul compte
Optional<Integer> resultA = rows.stream().filter(row-> "A".equals(row.getAccount()))
		.collect(Collectors.groupingBy(Row::getAccount, Collectors.summingInt(Row::getValue)))
		.values().stream().findFirst();
if ( resultA.isPresent() ) {
	System.out.println("Cumul par stream pour A : " + resultA.get());
}
else {
	System.out.println("Cumul par stream pour A : aucun");			
}

**afkiba** · 03/09/2018, 17h36

Merci pour réponse très explicite.
J'ai utilisé la première option (celui des données triées) et le calcul de cumul progressive à bien fonction.
Pour ce qui concerne

Attention, il y a un problème dans ce code :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public void tableChanged(TableModelEvent e) {
	            	int lastColoum = model.getColumnCount();
 
	            	if (e.getType() == TableModelEvent.UPDATE && e.getFirstRow() 
	            						< lastColoum && e.getLastRow() 
	            						< lastColoum && e.getColumn()==1) {
 
	            		//etatRemboursement();
	            		calculCumul();
	            			}
	            			}

je l'ai utilisé pour pouvoir modifier la dernière colonne du Jtable afin d'affiche le cumul.

Par rapport à mon traitement, je veux identifier dans mon cumul par compte, les lignes dans lesquelles j'ai les multiples de 31 afin de les stockées (lignes) dans la base. Voici l'image après usage du code que vous m'aviez donnée

Nom : Image.PNG
Affichages : 181
Taille : 36,7 Ko

Nom : Image.PNG
Affichages : 181
Taille : 36,7 Ko

Il s'agit des lignes sélectionnées que cherches à identifier et stocké.

Merci pour tous.

**joel.drigo** · 03/09/2018, 18h19

Envoyé par afkiba

J'ai utilisé la première option (celui des données triées) et le calcul de cumul progressive à bien fonction.
Pour ce qui concerne

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
public void tableChanged(TableModelEvent e) {
	            	int lastColoum = model.getColumnCount();
 
	            	if (e.getType() == TableModelEvent.UPDATE && e.getFirstRow() 
	            						< lastColoum && e.getLastRow() 
	            						< lastColoum && e.getColumn()==1) {
 
	            		//etatRemboursement();
	            		calculCumul();
	            			}
	            			}

je l'ai utilisé pour pouvoir modifier la dernière colonne du Jtable afin d'affiche le cumul.

D'accord, mais pourquoi ne réagir qu'à des modifications du champ date ?

Envoyé par afkiba

Par rapport à mon traitement, je veux identifier dans mon cumul par compte, les lignes dans lesquelles j'ai les multiples de 31 afin de les stockées (lignes) dans la base. Voici l'image après usage du code que vous m'aviez donnée

Donc, si je comprends bien tu cherches à ne stocker que les lignes dont le cumul est multiple de 31 ? Dans ton image, la ligne 29 et la 36 sont sélectionnées, alors qu'elles ne sont ni l'une ni l'autre multiple de 31... c'est normal ?

Soit, après recalcul du cumul, il te faut reparcourir toutes les lignes, lire la valeur du cumul (par getValueAt()), tester si elle est multiple de 31 ( valeur%31==0 ), et stocker le cas échéant. Soit le faire uniquement pour les cumuls recalculés si tu as optimisé. La question est de savoir si :

c'est un stockage unique : chaque ligne ayant un cumul multiple de 31 est stockée une et une seule fois. Dans ce cas, si tu dois reparcourir tout, il faudra savoir détecter celle qui sont déjà stockées pour ne pas les créer à nouveau (avec une foreign key sur "la ligne d'origine", c'est faisable facilement), mais simplement faire un update.
Éventuellement, il faut prévoir de supprimer celle qui était multiple de 31 et qui ne le sont plus... ce qui oblige à traiter l'ensemble des lignes pour tester s'il n'existe pas un stockage pour cette ligne.

A mon avis, il faudrait étudier la raison de pourquoi stocker ce cumul à part. Sachant qu'on peut faire des requêtes qui testent si une valeur n'est pas multiple de 31 et qu'on peut calculer un cumul avec rupture, tout ça en SQL, ce serait bien plus simple à gérer, et probablement plus rapide à traiter.
c'est un stockage du type journal : à chaque fois qu'il y a modification, on stocke l'ensemble des lignes validant la condition. Dans ce cas, on fait la même chose que pour le stockage unique, sans optimisation (on parcourt toutes les lignes, même celles qui ne sont pas concernées par la modification dans la JTable), sauf qu'on crée systématiquement.

**afkiba** · 03/09/2018, 19h38

D'accord, mais pourquoi ne réagir qu'à des modifications du champ date ?

J'ai copié ce code dans l'une de notre discussion "Calcul total colonne en bas du Jtable" que j'ai légèrement modifier.
En réalité la Jtable ne doit pas être modifiable par saisie.

Pour le traitement de données, je me suis mal exprimé dans mon dernier message.

Je m'explique dans le contexte de mon projet.
Initialement je n'avais pas prévu une table pour les commissions (je le calcul) dans ma base de donnée.
Mais avec le développement de cette base (environ 78Mo), le calcul des commissions me prend plusieurs heures.
Pour pallier à ce problème j'ai donc décidé de créer une table uniquement pour les commissions,
traité tous les commissions existantes par compte et par client et les stockées.

Une commission est égale à une mise que le client doit payé au début de chaque tranche.
Une tranche est constituée de 31 mises. Il arrive que les clients donnent plusieurs (par fois plus de 31 en une seule opération).
Il y a aussi des compte qui ne compte que 31 mise. C'est à dire une seule tranche. Là seule la première mise est recherchée.
Pour les comptes qui ont plus d'une tranche (plus de 31 mises), on cherche la 1ère mise pour chaque tranche.

Ou autrement dit, je cherche la première ligne d'une tranche modulé de 31 soit (1, 31+1, 62+1, 93+1, ..., (31*X+1)).

Voici mon problème que je cherche à résoudre.
Merci pour votre aide.

**joel.drigo** · 04/09/2018, 10h28

Envoyé par afkiba

J'ai copié ce code dans l'une de notre discussion "Calcul total colonne en bas du Jtable" que j'ai légèrement modifier.
En réalité la Jtable ne doit pas être modifiable par saisie.

Donc le TableModelListener ne sert à rien. Autant le supprimer.

Pour le traitement de données, je me suis mal exprimé dans mon dernier message.

Je m'explique dans le contexte de mon projet.

Envoyé par afkiba

Initialement je n'avais pas prévu une table pour les commissions (je le calcul) dans ma base de donnée.
Mais avec le développement de cette base (environ 78Mo), le calcul des commissions me prend plusieurs heures.

Il n'y pas de raison que ça prenne autant de temps, en utilisation normal, avec un SGBD bien configuré, à priori. Même pour un calcul complexe. Il faudrait déjà chercher à comprendre pourquoi ça prend autant de temps.

Envoyé par afkiba

Pour pallier à ce problème j'ai donc décidé de créer une table uniquement pour les commissions,
traité tous les commissions existantes par compte et par client et les stockées.

Si je comprends bien, il s'agit de faire une procédure à usage unique pour convertir des données... premièrement, une JTable est à priori inutile dans ce cas, tout le traitement pouvant être fait en tâche de fond, en une passe. D'autre part, une procédure stockée pourrait également être une solution.

Envoyé par afkiba

Une commission est égale à une mise que le client doit payé au début de chaque tranche.
Une tranche est constituée de 31 mises. Il arrive que les clients donnent plusieurs (par fois plus de 31 en une seule opération).
Il y a aussi des compte qui ne compte que 31 mise. C'est à dire une seule tranche. Là seule la première mise est recherchée.
Pour les comptes qui ont plus d'une tranche (plus de 31 mises), on cherche la 1ère mise pour chaque tranche.

Ou autrement dit, je cherche la première ligne d'une tranche modulé de 31 soit (1, 31+1, 62+1, 93+1, ..., (31*X+1)).

Voici mon problème que je cherche à résoudre.
Merci pour votre aide.

Une ligne est égale à une mise, c'est ça ? Ou est passé la notion de cumul ?

Donc, en résumé, l'algo ce serait, tout simplement :

Code pseudo :

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

1
2
3
4
5
6
7
8
 
pour tous les comptes
    pour toutes les mises du compte
        si index de mise est multiple de 31 (sachant que les index vont de 0 à n-1) alors
              traitement de la première mise d'une tranche du compte
        fin si
    fin pour toutes les mises du compte
fin pour tous les comptes

Donc en traitant un resultset trié (sans JTable) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
int index=0;
String compte=null;
while( resultset.next() ) {
      if ( compte==null || !compte.equals( resultset.getString("compte") ) {
         // changement de compte (rupture)
         index = 0;
         compte = resultset.getString("compte");
      }
      if ( index%31==0 ) {
           ecrire( resultset ); // écrit ce qu'on veut écrire (ou cumuler, ou je ne sais quel traitement à faire sur chaque première ligne de chaque tranche de 31 mises = ligne
      }
      index++;
}

**afkiba** · 04/09/2018, 13h37

Bonjour,

Une ligne est égale à une mise, c'est ça ?

Pas dans tous les cas. Une ligne peut contenir plusieurs mises.

Code :

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

Ou est passé la notion de cumul ?

J'ai faire le cumul pour identifier la fin d'une tranche.
Pour le code pseudo

pour tous les comptes
pour toutes les mises du compte
si index de mise est multiple de 31 (sachant que les index vont de 0 à n-1) alors
traitement de la première mise d'une tranche du compte
fin si
fin pour toutes les mises du compte
fin pour tous les comptes

Voila le code que j'ai écrit

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
public void commission() {
	int nombreDeLignes = model.getRowCount(); 
	double cumul=0; 
   	String numcompte=null; // une valeur qui n'existe nulle part
   	for(int i=0; i<nombreDeLignes; i++) {
 
   	    cumul = (double)model.getValueAt(i, 9);
 
   		for (double j = 0; j < cumul; j++) {
 
   			if(cumul % 31 == 0 || (cumul==1 ) ){
	 			 model.setValueAt(true, i, 10);
 
	 		}
   		}
 
 
   	}

Mais ça ne me donne le résultat voulu.
J'ai du mal à traduire le pseudo en code java.

**joel.drigo** · 04/09/2018, 14h16

Envoyé par afkiba

Pas dans tous les cas. Une ligne peut contenir plusieurs mises.
[...]
J'ai faire le cumul pour identifier la fin d'une tranche.

Sans une description claire de tout le modèle, je vais avoir du mal à t'aider.

Pour moi, ce qui suit n'a aucun sens :

Code :

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

1
2
 
   		for (double j = 0; j < cumul; j++) {

Donc, je ne vois pas en quoi le cumul pourrait être une borne pour boucler (c'est la somme de valeurs de lignes), surtout à partir de 0. Et j devrait de toute manière être un int.

Code :

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

1
2
3
4
5
6
7
8
 
   		for (double j = 0; j < cumul; j++) {
 
   			if(cumul % 31 == 0 || (cumul==1 ) ){
	 			 model.setValueAt(true, i, 10);
 
	 		}
   		}

"j" n'intervient nulle part dans le code qui est dans le bloc du for, donc on fait plusieurs fois la même chose, ce qui n'a aucun intérêt.

Si une ligne peut contenir plusieurs mises, peut-être qu'un ligne contient un champ dont la valeur est un nombre de mises, et que par cumul, tu parles de cumuler les nombres de mises, pour savoir quand obtient-on un nombre de mises multiple de 31. Au quel cas, un modulo comparé à 0 ne fonctionne pas, parce que qu'en on passe de 29 mises à 33 mises sur une ligne, on doit traiter la ligne, et que 33%31 donne 2, pas 0. Et si on passe de 29 à 64, on passe deux tranches d'un coup.

Dans ce cas, l'algo (sans jtable, pas besoin de faire une colonne pour faire un cumul) :

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
 
int cumul=0;
String compte=null;
while( resultset.next() ) {
      if ( compte==null || !compte.equals( resultset.getString("compte") ) {
         // changement de compte (rupture)
         cumul= 0;
         compte = resultset.getString("compte");
      }
      cumul += resultset.getInt("nombre de mises"); // on calcule le cumul
      if ( cumul >= 31 ) { // on atteint au moins 31 mises (mais peut-être 63, donc 2 tranches ici)
           ecrire( resultset ); // écrit ce qu'on veut écrire pour cette ligne
           cumul = cumul%31;
      }
 
}

si tu dois pouvoir écrire plusieurs lignes pour chaque "tranche" atteinte, il te suffit d'utiliser cumul / 31 pour connaître le nombre de tranche.

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
 
int cumul=0;
String compte=null;
while( resultset.next() ) {
      if ( compte==null || !compte.equals( resultset.getString("compte") ) {
         // changement de compte (rupture)
         cumul= 0;
         compte = resultset.getString("compte");
      }
      cumul += resultset.getInt("nombre de mises");
      if ( cumul >= 31 ) { // on atteint au moins 31 mises (mais peut-être 63, donc 2 tranches ici)
           ecrire( resultset, cumul/31 ); // écrit ce qu'on veut écrire pour cette ligne (le second argument est le nombre de "31" atteints
           cumul = cumul%31;
      }
 
}

**afkiba** · 05/09/2018, 11h53

J'ai enfin trouver la solution. Je me suis inspiré de votre question

Une ligne est égale à une mise, c'est ça ?

pour transformer une mise en une ligne dans la base.
En calculant le cumul progressive j'ai exactement les multiples de 31.
Voici mon code final pour le test et identifier les lignes concernées.

Code :

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

1
2
3
4
5
6
7
8
9
for(int i=0; i<nombreDeLignes; i++) {
 
   	    cumul = (double)model.getValueAt(i, 9);
   	    	  	 if ( (cumul-1)%31==0 ) { 
			         model.setValueAt(true, i, 10);
			    }
 
 
   	}

Grand merci pour tous ce que vous faites pour nous.

Tri de la Jtable selon un argument donnée

Composants Java

Discussions similaires

Partager

Partager