Discussion :

[Kpakito]

Salut à tous!
J'ai un souci avec un JTable.
Alors, je voudrais avoir un exemple de code qui me permettrait de remplir un JTable, avec des colonnes personnalisées (du style "Nom & Prénoms", "Date de naissance", "Fonction") et des lignes provenant d'un ArrayList.
Pour rappel, le ArrayList provient en fait d'une méthode que récupère des données d'une base de données, en l'occurrence une table agent (nom,prenoms,datenaiss,fonction), qui les range dans un ArrayList et qui le retourne comme valeur de retour de la fonction.
Le problème, c'est comment définir un modèle de table qui créera une table avec les données de ce ArrayList.

NB: je ne veux passer par une conversion du ArrayList en Object[][].

Merci d'avance!

[joel.drigo]

Salut,

sous quelle forme sont les lignes dans la ArrayList ?

Sinon, si tu veux directement utiliser ton ArrayList dans ton modèle de table, il suffit d'implémenter AbstractTableModel, ce qui ne présente aucune difficulté. Il y a trois méthodes à implémenter, dont le code est particulièrement évident, en fonction de ce que tu as dans ton ArrayList :

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
public class MyTableModel extends AbstractTableModel {
 
   private ArrayList list;		
 
   public MyTableModel(ArrayList list) {
       this.list=list;
   }
 
   @Override
   public Object getValueAt(int rowIndex, int columnIndex) {
	// return ...; // la valeur pour la ligne rowIndex et la colonne columnIndex
   }
 
   @Override
   public int getRowCount() {
       return list.size(); // le nombre de lignes
   }
 
   @Override
   public int getColumnCount() {
       return ...; // le nombre de colonnes
   }
 
};

[Kpakito]

Merci pour ta bonne volonté.
Il se trouve que j'ai effectivement essayé d'implémenter le modèle à l'aide de la classe AbstractTableModel comme tu l'avais dis; mais mon arrayList est composé d'une liste d'objets de la classe Agent définie comme suit:

Code :

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

1
2
3
4
5
6
7
private class Agent {
private String nom;
private String  prenoms;
private String Fonction;
. . .
//getters et setters
}

Donc, après récupération des données de la BD, j'obtiens grâce à une méthode particulière un tel ArrayList:

Code :

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

ArrayList<Agent>

Et voilà comment j'ai déjà implémenté le 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
class ModeleTableAgent extends DefaultTableModel {
 
        public ModeleTableAgent(String [] colonnes, ArrayList<Agent> Liste){
            super(null,colonnes);
            this.ListeAgents = Liste;
            addRow(this.ListeAgents);
        }
 
        @Override
        public String getColumnName(int c){
            switch(c){
                case 1: {
                    return "Nom & Prénoms";
                }
                case 2: {
                    return "Fonction";
                }
                case 3: {
                    return "Login";
                }
                default : JOptionPane.showMessageDialog(null, "Erreur!");
            }
            return "";
        }
 
        @Override
        public int getColumnCount() {
            return 3; //Il y a 3 colonnes dans notre tableau
        }
 
        @Override
        public Object getValueAt(int ligne, int colonne) {
            unAgent = ListeAgents.get(ligne);
            return intersectLigneColonne (unAgent, colonne);           
        }
 
        public Object intersectLigneColonne (Agent A, int col) {
            switch (col){
                case 1: {
                    return A.getNom()+" "+A.getPrenoms();
                }
                case 2: {
                    return A.getFonction();
                }
                case 3: {
                    return A.getLogin();
                }
            }
            return null;
        }
 
        public int getRowCount() {
            return ListeAgents.size();
        }
 
        private Agent unAgent;
        private ArrayList<Agent> ListeAgents;
    }

Merci d'avance!

[joel.drigo]

Le principal problème de ton implémentation est que tu traites les index de colonnes de 1 à 3, alors qu'ils vont de 0 à 2.

Ensuite, moins important, inutile de faire le addRow, d'autant plus qu'il est faux : ta liste d'agents n'est pas qu'une ligne, mais plusieurs. C'est inutile de le faire, puisque que de toute manière, tu redéfinis toutes les méthodes. D'ailleurs, comme tu rédéfinis tous le comportement de DefaultTableModel, autant ne pas étendre cette classe.

Tu peux faire comme ça :

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
public class MyTableModel extends AbstractTableModel {
 
	private List<Agent> list;
 
	public MyTableModel(List<Agent> list) {
		this.list = new ArrayList<>(list);
	}
 
	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		return getData(list.get(rowIndex), columnIndex);
	}
 
	public Object getData(Agent agent, int col) {
		switch (col) {
			case 0: {
				return agent.getNom() + " " + agent.getPrenoms();
			}
			case 1: {
				return agent.getFonction();
			}
			case 2: {
				return agent.getLogin();
			}
		}
		return null;
	}
 
	@Override
	public String getColumnName(int column) {
		switch (column) {
		case 0: {
			return "Nom & Prénoms";
		}
		case 1: {
			return "Fonction";
		}
		case 2: {
			return "Login";
		}
		}
		return "";
	}
 
	@Override
	public int getRowCount() {
		return list.size(); // le nombre de lignes
	}
 
	@Override
	public int getColumnCount() {
		return 3; // le nombre de colonnes
	}
 
}

Attention : ce modèle n'est pas prévu pour pour être mutable (donc pour ajouter, supprimer ou modifier des données dans la table).

[Kpakito]

Merci pour l'aide!

Alors j'ai deux autres questions:

1. Comment utiliser ce modèle dans une JTable afin qu'il affiches les données de la liste
2. Et comment puis-je m'arranger pour que lorsque l'utilisateur sélectionne une ligne, ce ne sont pas les données qui sont dans les cellules qui sont retournées, mais plutôt l'objet qui a permit de fabriquer cette ligne qui sera retourné. en fait, je veux utiliser cet objet dans un cadre qui affichera plus détails que la liste.

Merci d'avance!

[joel.drigo]

Pour utiliser le modèle, il suffit de le passer en paramètre au constructeur lors de l'instanciation de la JTable :

Code :

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

jtable=new JTable(new MyTableModel(listeAgents));

Pour pouvoir récupérer les agents sélectionnés, ajoutes la méthode suivante à la classe MyTableModel :

Code :

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

1
2
3
public Agent getAgent(int rowIndex) {
    return list.get(rowIndex);
}

Tu peux l'utiliser comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {
 
   private Agent getAgent(int rowIndex) {
        return ((MyTableModel)table.getModel()).getAgent(rowIndex);
   }
 
   @Override
   public void valueChanged(ListSelectionEvent e) {
      if ( !e.getValueIsAdjusting() )
         System.out.println(getAgent(e.getFirstIndex()));
      }
});

Si tu en as besoin plusieurs fois, tu peux faire une abstraction.

[Kpakito]

Merci beaucoup!
je pense être sur la bonne voie.
Alors est-ce qu'il est possible d'utiliser le modèle pour implémenter le listerner?
si oui, comment, et comment l'utiliser alors; et sinon comment pourrais-je implémenter ce listerner dans une classe qui sera utilisée par la suite dans d'autres fenêtres.
Merci!

[joel.drigo]

Alors est-ce qu'il est possible d'utiliser le modèle pour implémenter le listerner?
si oui, comment, et comment l'utiliser alors;

On peut implémenter l'interface ListSelectionListener sur le modèle MyTableModel. Mais je ne le conseille pas. Ce serait un peu mélanger des choux et des fers à repasser. Ca n'a aucun intérêt de faire une seule classe, et c'est jamais une bonne idée de faire une classe qui à 2 fonctions différentes. De toute manière, il faudrait enregistrer l'instance de modèle comme listener.
Si le problème c'est de passer un paramètre à une méthode, au lieu de 2 (ce qui n'est pas vraiment un problème en soi), tu peux faire une classe qui contient les 2 éventuellement.

et sinon comment pourrais-je implémenter ce listerner dans une classe qui sera utilisée par la suite dans d'autres fenêtres.
Merci!

L'exemple que je t'ai donné est une classe anonyme, mais tu peux en faire une classe concrète directement. C'est un peu le béaba.

(Par contre, j'avais appelé le modèle MyTableModel pour l'exemple de principe, mais il serait peut être temps de l'appeler AgentTableModel, ce serait plus lisible, et sémantique ; du coup, j'appelle mon listener sur le même principe)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
public class AgentTableSelectionListener implements ListSelectionListener  {

   private Agent getAgent(int rowIndex) {
        return ((AgentTableModel)table.getModel()).getAgent(rowIndex);
   }
 
   @Override
   public void valueChanged(ListSelectionEvent e) {
      if ( !e.getValueIsAdjusting() )
         System.out.println(getAgent(e.getFirstIndex()));
      }
})

Et pour l'utiliser :

Code :

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

table.getSelectionModel().addListSelectionListener(new AgentTableSelectionListener());

Par contre le problème, c'est que tous tes listeners vont réagir de la même manière : ici afficher dans la console le premier agent sélectionné ! Est-ce bien ce que tu veux (faire toujours la même chose) ?
Éventuellement, on peut faire une classe abstraite, ou faire une interface pour gérer l'action à faire à part... je t'indiquerais comment, en fonction de ta réponse.

[Kpakito]

Merci!
Alors on fait un tout petit retour sur mon problème de départ.
En fait, ce que je veux concrètement, c'est que lorsque l'utilisateur sélectionne une ligne du tableau, j'aie une méthode qui récupère l'objet correspondant dans l'arraylist afin que cet objet soit utilisé à plusieurs fins, comme par exemple affiché dans un cadre à proximité du tableau.
Merci.

[joel.drigo]

Ca, j'ai bien compris que tu veux récupérer l'agent sélectionné : la question est si tu veux toujours en faire la même chose, ou si tu veux pouvoir en faire des choses différentes. On va partir sur ce dernier cas, c'est le plus général.

Pour pouvoir faire des choses différentes, on est obligé de pouvoir avoir un code différent, selon les cas, qui s'exécute lors de la sélection.
On peut faire ça comme suit, à la limite ce sera le plus simple pour toi. Voici une abstraction de listener de sélection dans une table avec AgentTableModel, qui appelle automatiquement la méthode selectionChange(Agent) si un seul agent est sélectionné, et selectionChange(Agent[]) si plusieurs (consécutifs) sont sélectionnés.

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
public abstract class AgentTableSelectionAdapter implements ListSelectionListener  {
 
   private Agent getAgent(int rowIndex) {
        return ((AgentTableModel)table.getModel()).getAgent(rowIndex);
   }
 
   @Override
   public void valueChanged(ListSelectionEvent e) {
      if ( !e.getValueIsAdjusting() )
         int firstIndex = e.getFirstIndex();
         int lastIndex = e.getLastIndex();
         if ( firstIndex==lastIndex ) {
            // un seul agent sélectionné
            selectionChange(getAgent(firstIndex));
         }
         else {
             // plusieurs agent sélectionné
             Agent[] agents = new Agent[lastIndex-firstIndex+1];
             for(int index=0; index<agents.length; index++) {
                 agents[index]=getAgent(firstIndex+index);
             }
         }
      }
   }
 
   /**
     * est appelée pour chaque agent sélectionné
     */
   protected void selectionChange(Agent agent) {
   }
 
   /**
     * est appelée si plusieurs agents consécutifs sont sélectionnés : renvoit l'appel pour chaque agent
     * à selectionChange(Agent). 
     * Tu peux surcharger la méthode pour faire autre chose.
     */
   protected void selectionChange(Agent[] agents) {
      for(Agent agent : agents) {
          selectionChange(agent);
      }
   }
 
}

Maintenant si tu voulais l'utiliser pour afficher l'agent dans la console, sur une table à sélection unique, tu pourrais faire une classe comme suit, pour l'enregistrer comme listener comme indiqué dans le post précédent, avec le AgentTableSelectionListener :

Code :

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

1
2
3
4
5
6
7
public class MyAgentTableSelectionAdapter extends AgentTableSelectionAdapter {

    protected void selectionChange(Agent agent) {
       System.out.println(agent);
    }

}

A la place du code en rouge, tu mets ce que tu veux. Si tu as besoin d’accéder à des variables d'une JFrame, ou autre, tu les passes en arguments d'un constructeur adéquate (le classique java quoi).

[Kpakito]

Merci! Merci! mille Merci!
Le problème est résolu.
Sauf que pour les deriniers codes, j'ai du utiliser

Code :

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

1
2
3
4
5
6
7
public void valueChanged(ListSelectionEvent e) {
        ListSelectionModel lsm = (ListSelectionModel)e.getSource();
        if (!e.getValueIsAdjusting()) {  
            this.angentAffiche = agentSelectionne(lsm.getMinSelectionIndex());
            afficherDetailsAgent(this.angentAffiche);
        }
      }

Car non seulement le tableau que j'ai implémenté est fait pour une sélection unique de ligne uniquement, et aussi parce que getFirstIndex() ne fournissait pas le résultat recherché (des fois, il ne transmettait pas un bon index, j'sais pas pourquoi...). Mais en tout cas j'ai ce que je voulais!
Néanmoins, il y a un autre souci
Dans ma fenetre j'ai un bouton qui permet d'ouvrir un formulaire de création d'un nouvel agent. Je voudrais qu'après la création du nouvel agent, le tableau précédent sous actualisé, c'est a dire que le nouvel agent créé s'affiche en fin de cette table.
Dans le modele de la table, j'avais implémenté la methode suivante:

Code :

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

1
2
3
4
5
 
public void ajoutAgent(Agent A) {
ListeAgents.add(A);
fireTableDataChanged();
}

qui est appelée chaqque fois que la requete d'insertion se termine.
Mais je constate qu'elle ne fonctionne pas car en vérifiant dans la base de données, je constate que les données y sont, mais il est nécessaire que je redémarre l'application pour que les données nouvelles s'affichent dans la table.
S'il vous plaît, un dernier coup de pouce. Merci.

[joel.drigo]

...parce que getFirstIndex() ne fournissait pas le résultat recherché (des fois, il ne transmettait pas un bon index, j'sais pas pourquoi...).

Bizarre Tu n'aurais pas mis des tris ou des filtres sur ta JTable ?

Dans ma fenetre j'ai un bouton qui permet d'ouvrir un formulaire de création d'un nouvel agent. Je voudrais qu'après la création du nouvel agent, le tableau précédent sous actualisé, c'est a dire que le nouvel agent créé s'affiche en fin de cette table.

La méthode pour ajouter n'est pas tout à fait comme tu l'as faite : ce n'est pas le bon évenement.

Voici les exemples pour les ajouts et suppressions, et mise à jour (qu'il faut penser à faire en cas de modification des propriétés) :

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
public void addAgent(Agent agent) {
		int rowIndex=list.size();
		list.add(agent);
		fireTableRowsInserted(rowIndex, rowIndex);
	}
 
	public void addAgents(List<Agent> agents) {
		int rowIndex=list.size();
		list.addAll(agents);
		fireTableRowsDeleted(rowIndex, rowIndex+agents.size()-1);
	}
 
	public void removeAgent(Agent agent) {
		int rowIndex=list.indexOf(agent);
		if ( rowIndex>=0 ) {
			list.remove(agent);
			fireTableRowsInserted(rowIndex, rowIndex);
		}
	}
 
	public void removeAgents(List<Agent> agents) {
 
		int rowIndex=0;
		int firstIndex=rowIndex;
 
		while(rowIndex<agents.size()) {
			while ( agents.contains(list.get(rowIndex)) && rowIndex<agents.size() ) {
				rowIndex++;
			}
			if ( rowIndex>firstIndex ) {
			   for(int index=firstIndex; index<rowIndex; index++ ) {
				   agents.remove(rowIndex);
			   }
			   fireTableRowsDeleted(firstIndex, rowIndex);
			}
			while ( !agents.contains(list.get(rowIndex)) && rowIndex<agents.size() ) {
				rowIndex++;
			}
			firstIndex=rowIndex;
		}
 
	}
 
	public void updateAgent(Agent agent, int columnIndex) {
		int rowIndex=list.indexOf(agent);
		while ( rowIndex>=0 ) {
			fireTableCellUpdated(rowIndex, columnIndex);
			rowIndex=list.subList(rowIndex+1, list.size()).indexOf(agent);
		}
	}

[joel.drigo]

Merci! Merci! mille Merci!
Le problème est résolu.
Sauf que pour les deriniers codes, j'ai du utiliser

Code :

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

1
2
3
4
5
6
7
public void valueChanged(ListSelectionEvent e) {
        ListSelectionModel lsm = (ListSelectionModel)e.getSource();
        if (!e.getValueIsAdjusting()) {  
            this.angentAffiche = agentSelectionne(lsm.getMinSelectionIndex());
            afficherDetailsAgent(this.angentAffiche);
        }
      }

Car non seulement le tableau que j'ai implémenté est fait pour une sélection unique de ligne uniquement, et aussi parce que getFirstIndex() ne fournissait pas le résultat recherché (des fois, il ne transmettait pas un bon index, j'sais pas pourquoi...). Mais en tout cas j'ai ce que je voulais!

Au temps pour moi En effet, je me suis planté sur le firstIndex : c'est vrai que c'est plus sioux à gérer que comme je l'avais fait. Il fallait en effet utiliser lsm.getMinSelectedIndex() pour faire plus simple. Ou table.getSelectedRow() éventuellement.

[Kpakito]

Excuses moi, mais ça ne marche pas. est-ce que le modèle ne devrait pas implémenter un listener particulier? si oui, lequel?

[joel.drigo]

Non, pas le modèle en tout cas. La vue est écouteur du modèle : si tu as bien étendu AbstractTableModel, tout le support est déjà implémenté.

J'ai fait un petit POC (j'ai effectivement détecté des bugs dans la méthode exemple removeAgents() que je t'avais donnée) donc voici le résultat : compares avec ton code pour vérifier.

[Kpakito]

Merci infiniment, mon problème est résolu.
Comme j'avis des difficultés à prendre en main l'interface du site, j'avais du mal à retrouver la discussion.
c'est ce qui explique le temps que j'ai mis avant de vous répondre.
encore une fois