tableau croisé dynamique sur JTable

Version imprimable

30/01/2016, 10h26
Hind4Dev

1 pièce(s) jointe(s)

tableau croisé dynamique sur JTable

voilà j'ai besoin d'effectuer des statistiques sur ma base de données alors j'ai besoin d'un tableau croisé dynamique qui se remplira selon le count de l'intitulé de la colonne et celui de la ligne mais mon tableau ne s'affiche pas correctement je ne sais comment envoyer mes résultats nombreux à mes cellules
voilà le résultat:
Pièce jointe 199482
alors que je veux le M "qui veut dire masculin" autant que colonne et le chiffre 3 croisement entre la filière et le genre, et je n'arrive pas a afficher aussi celui des féminins en face

Salut,

Pour faire un tableau croisé, sans parle de JTable, il faut envisager tes données comme une liste d'objets ayant :

une clef (ou un ensemble de clefs, peu importe), correspondant aux colonnes
une clef (ou un ensemble de clefs), correspondant aux lignes
un agrégat (une fonction de calcul) prenant en entrée des valeurs correspondant aux valeurs des 2 clefs, à mettre dans la case correspondant à la ligne et la colonne

Donc, à base, pour simplifier, un tableau à 2 dimensions. Ce qui peut faire de manière évidente la base d'un modèle de JTable (c'est un tableau à 2 dimensions). Au lieu d'utiliser directement la liste d'objets comme données du modèle comme d'habitude, on utilise une autre liste d'objets construites à partir de la liste des données de base.
Ensuite, on peut s'arranger pour que la première colonne du modèle contient les valeurs de la clef en ligne, celle de la clef en colonne servant de headers classiques de la JTable. On peut en utilisant le RowHeader du JScrollPane s'arranger pour que cette colonne reste fixe, et qu'on puisse scroller la partie données indépendemment.

Voici ci-après un petit POC concrêt, avec commentaires d'explication. J'ai simulé une mise à jour dynamique en ajoutant petit à petit des objets (la classe Data) qui correspondent à ce qu'on pourrait obtenir d'une base de données par exemple. L'agrégat est une simple somme. A chaque fois que j'ajoute un objet Data à mon modèle, j'extrais les 2 clefs, détermine à quelle colonne et quelle ligne ça correspond et ajoute à la somme déja calculée (et stocker dans le tableau à 2 dimensions) la valeur stocker dans l'objet.

J'utilise 2 JTables avec le même modèle pour avoir des titres de lignes (filière) fixes. J'initialise le modèle en passant la liste de toutes les filières et de tous les genres, pour déterminer d'avance le tableau croisé complet. On pourrait rendre dynamique l'ajout de filières par exemple (il faudra simplement envoyer l'évenement adéquat pour que la JTable se mette à jour). C'est plus compliqué pour ajouter des colonnes, parce que ça joue sur la répartion en RowHeader et Viewport, et sur les 2 JTables.

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
public class CrossTableExample {
 
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		// la liste des valeurs pour les 2 clefs
		String[] filieres = {"F1","F2","F3","F4"}; // determine l'ordre d'affichage des lignes
		Genre[] genres = {Genre.M, Genre.F}; // determine l'ordre d'affichage des colonnes
 
		DataModel model = new DataModel(filieres, genres);
 
		JTable table = new JTable(model); // une table pour les données croisées
		JTable tableColumn = new JTable(model); // une table pour la colonne de titres
		table.removeColumn(table.getColumnModel().getColumn(0)); // je retire la colonne de filières de la table de données
		while( tableColumn.getColumnCount()>1) { // je retire toutes les colonnes sauf la colonne de filières de la table de colonne de titres
			tableColumn.removeColumn(tableColumn.getColumnModel().getColumn(1));
		}
 
 
		// couleurs des titres de ligne (pour que ça ressemble à un header (on pourrait aussi utiliser le renderer du header)
		tableColumn.setForeground(table.getTableHeader().getForeground());
		tableColumn.setBackground(table.getTableHeader().getBackground());
		tableColumn.setFont(table.getTableHeader().getFont());
 
		// pour éviter que la colonne de titre ne prenne trop de largeur 
		tableColumn.setPreferredScrollableViewportSize(tableColumn.getPreferredSize());
 
		/*// si tu veux que la table soit triable par clic sur les titres de colonne
		RowSorter<DataModel> rowSorter = new TableRowSorter<>(model);
		table.setRowSorter(rowSorter);
		tableColumn.setRowSorter(rowSorter);*/
 
		// synchronisation de la sélection
		ListSelectionModel selectionModel = new DefaultListSelectionModel();
		table.setSelectionModel(selectionModel);
		tableColumn.setSelectionModel(selectionModel);
		// au besoin changer le mode de sélection, mais sur les deux tables
		//table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
		//tableColumn.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
 
		JScrollPane scrollPane = new JScrollPane(table);
		scrollPane.setRowHeaderView(tableColumn); // la colonne de titre
		//scrollPane.setColumnHeaderView(table.getTableHeader()); // fait automatiquement
 
		frame.add(scrollPane);
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
		// simulation d'ajout de données (aléatoire)
		final Random random = new Random();
		for(int i=0; i<100; i++) {
 
			final int filiere = random.nextInt(filieres.length);
			final int genre = random.nextInt(Genre.values().length);
 
			final Data data = new Data(filieres[filiere], Genre.values()[genre], random.nextInt(10)+5);
 
			model.addData(data);
			try {
				Thread.sleep(500);
			} catch (InterruptedException e) {
				break;
			}
 
		}
 
	}
 
	// les valeurs de la clef Genre, dans une enum
	public enum Genre {
		M("Homme"), F("Femme");
		private final String label;
		private Genre(String label){
			this.label=label;
		}
		public String getLabel() {
			return label;
		}
	}
 
	// la classe de modèle
	public static class DataModel extends AbstractTableModel {
 
		private final Map<String,Integer> filieres; // sert à retrouver rapidement l'index d'une filière
		private final Map<Genre,Integer> genres; // sert à retrouvr rapidement l'index d'un genre
		private final String[] columnNames; // les noms de colonnes
		private final Object[][] dataTable; // les valeurs de la JTable
		private final int nbColumns;
		private final int nbRows;
 
 
		// filiteres en lignes, genres en colonne
		public DataModel(String[] filieres, Genre[] genres) {
			this.filieres = new HashMap<>();
			this.genres = new HashMap<>();
			nbColumns = genres.length + 1; // on prévoit une colonne de plus pour le titre de ligne (filière)
			columnNames = new String[nbColumns];
 
			// titres des colonnes
			columnNames[0]=""; // la colonne correspondant aux titres de ligne (filières)
			for(int i=0; i<genres.length; i++) {
				columnNames[i+1]=genres[i].getLabel();
				this.genres.put(genres[i], i+1); // index des index de colonnes en fonction de leur valeur
			}
 
			nbRows = filieres.length;
 
			// création du tableau croisé
			dataTable = new Object[nbRows][nbColumns];
 
			// la première colonne contient les titres de ligne (filières)
			for(int i=0; i<filieres.length; i++) {
				dataTable[i][0]=filieres[i];
				this.filieres.put(filieres[i], i); // index des index de lignes en fonction de leur valeur
			}
		}
 
		@Override
		public int getColumnCount() {
			return nbColumns; 
		}
 
		@Override
		public int getRowCount() {
			return nbRows;
		}
 
		@Override
		public String getColumnName(int columnIndex) {
			return columnNames[columnIndex];
		}
 
		@Override
		public Class<?> getColumnClass(int column) {
			if ( column==0 ) {
				// colonne de titres de ligne (filières)
				return String.class;
			}
			return Integer.class;
		}
 
		@Override
		public Object getValueAt(int rowIndex, int columnIndex) {
			return dataTable[rowIndex][columnIndex];
		}
 
		public void addData(Data data) {
			final String filiere = data.getFiliere(); // clef en ligne
			final Genre genre = data.getGenre(); // clef en colonne
			final int row = filieres.get(filiere); // index de ligne dans le tableau 2 dim correspondant à la clef en ligne
			final int column = genres.get(genre); // index de colonnes dans le tableau 2 dim correspondant à la clef en colonne
			Integer currentValue = (Integer)dataTable[row][column]; // la valeur actuelle dans le tableau croisé
			if ( currentValue==null ) {
				// la cellule est vide
				currentValue = data.getValeur();
			}
			else {
				currentValue += data.getValeur(); // on fait la somme des valeurs 
			}
			dataTable[row][column] = currentValue; // on stocke la somme
			fireTableCellUpdated(row, column); // on averti la JTable qu'on a changé la valeur dans le modèle
		}
 
	}
 
	// l'objet de donnée, correspondant à ce qu'on pourrait lire d'une base de données
	public static class Data {
 
		private final String filiere;
		private final Genre genre;
		private final int valeur;
 
		public Data(String filiere, Genre genre, int valeur) {
			this.filiere=filiere;
			this.genre=genre;
			this.valeur=valeur;
		}
 
		public String getFiliere() {
			return filiere;
		}
 
		public Genre getGenre() {
			return genre;
		}
 
		public int getValeur() {
			return valeur;
		}
 
	}
 
}

03/02/2016, 08h33
Hind4Dev

merci le problème est résolu
02/10/2017, 19h18
aristideman

1 pièce(s) jointe(s)

Bonsoir @joel.drigo,
Merci pour ta réponse sur les tableaux dynamiques croisés en utilisant un JTable.

J'ai deux questions (et si possible une implémentation pour que j'ai une idée serai la bienvenue)

1. Est-ce qu'on peut générer automatiquement les colonnes et fixé les lignes pour un tableaux dynamique croisé ?
Ex. 12 Eleves x N evalutions (N matières)

2. Est-ce possible d'avoir une JTable personnalisée sous la forme suivante ?

Pièce jointe 316319

J'ai une map. Map<Evaluation, List<Devoir>> qui stock les évaluations (code, matière, élève, moyenne) comme "CLE" et List<Devoir> (liste des devoirs de l’élève pour cette matière)
comme "VALEUR" de la map.

Je voudrais utiliser cette map comme modèle de données de ma classe ModelJTable héritant de AbstractTableModel.

Comment personnalisé un JTable et utiliser un Map puis AbstractTableModel, pour avoir le schéma ci-dessous ?

Merci pour votre aide.

Bonsoir,

Citation:

Envoyé par aristideman

1. Est-ce qu'on peut générer automatiquement les colonnes et fixé les lignes pour un tableaux dynamique croisé ?
Ex. 12 Eleves x N evalutions (N matières)

Oui. Dans mon exemple, les colonnes et les lignes sont fixées dans la déclaration, mais on peut tout à fait générer les tableaux dynamiquement, comme n'improte quel tableau. En complexifiant le modèle, on peut même le rendre dynamique et permettre l'ajout de colonnes ou lignes.

Citation:

Envoyé par aristideman

2. Est-ce possible d'avoir une JTable personnalisée sous la forme suivante ?

Pour l'affichage, on pourrait utiliser un TableCellRender qui affiche une JTable. On doit même pouvoir , rendre éditable en faisant de même avec TableCellEditor sous forme de JTable, à priori.

Exemple de principe (sans édition) :

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
public class JTableExemple {
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		Map<String, List<Integer>> data = new LinkedHashMap<>();
 
		data.put("Math", Arrays.asList(12,16,11));
		data.put("Français", Arrays.asList(18,15));
		data.put("Physique", Arrays.asList(7));
 
		TableModel model = new AbstractTableModel() {
 
			String[] columns = {"nom","valeurs"};
			String[] matieres = data.keySet().toArray(new String[data.keySet().size()]);
 
			@Override
			public Object getValueAt(int rowIndex, int columnIndex) {
				switch(columnIndex) {
				case 0:
					return matieres[rowIndex];
				case 1:
					return data.get(matieres[rowIndex]);
				default:
					return null;
				}
 
			}
 
			@Override
			public boolean isCellEditable(int rowIndex, int columnIndex) {
				return false;
			}
 
			@Override
			public int getRowCount() {
				return matieres.length;
			}
 
			@Override
			public int getColumnCount() {
				return columns.length;
			}
 
		};
 
		JTable table = new JTable(model);
 
		table.getColumnModel().getColumn(1).setCellRenderer(new ListCellRender());
 
		JScrollPane scrollPane = new JScrollPane(table);
		frame.add(scrollPane);
 
		frame.pack();
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	public static class ListCellRender extends JPanel implements TableCellRenderer {
 
		private JTable table = new JTable();
        private UIDefaults uidefaults = UIManager.getDefaults();
 
	    private static final Border SAFE_NO_FOCUS_BORDER = new EmptyBorder(1, 1, 1, 1);
	    private static final Border DEFAULT_NO_FOCUS_BORDER = new EmptyBorder(1, 1, 1, 1);
	    protected static Border noFocusBorder = DEFAULT_NO_FOCUS_BORDER;
 
	    private Color unselectedForeground;
	    private Color unselectedBackground;
 
		public ListCellRender() {
			super(new BorderLayout());
		    setOpaque(true);
	        setBorder(getNoFocusBorder());
	        setName("Table.cellRenderer");
			add(table);
			setForeground(unselectedForeground);
			setBackground(unselectedBackground);
		}
 
	    private Border getNoFocusBorder() {
	        Border border = uidefaults.getBorder("Table.cellNoFocusBorder");
	        if (System.getSecurityManager() != null) {
	            if (border != null) return border;
	            return SAFE_NO_FOCUS_BORDER;
	        } else if (border != null) {
	            if (noFocusBorder == null || noFocusBorder == DEFAULT_NO_FOCUS_BORDER) {
	                return border;
	            }
	        }
	        return noFocusBorder;
	    }
 
	    public void setForeground(Color c) {
	    	if ( table!=null ) {
	    		table.setForeground(c);
	    	}
	        unselectedForeground = c;
	    }
 
	    public void setBackground(Color c) {
	    	if ( table!=null ) {
	    		table.setBackground(c);
	    	}
	        unselectedBackground = c;
	    }
 
	    public void updateUI() {
	        super.updateUI();
	        setForeground(null);
	        setBackground(null);
	    }
 
 
		@Override
		public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus,
				int row, int column) {
 
	        Color fg = null;
	        Color bg = null;
 
 
	        JTable.DropLocation dropLocation = table.getDropLocation();
	        if (dropLocation != null
	                && !dropLocation.isInsertRow()
	                && !dropLocation.isInsertColumn()
	                && dropLocation.getRow() == row
	                && dropLocation.getColumn() == column) {
 
	            fg = uidefaults.getColor("Table.dropCellForeground");
	            bg = uidefaults.getColor("Table.dropCellBackground");
 
	            isSelected = true;
	        }
 
	        if (isSelected) {
	            super.setForeground(fg == null ? table.getSelectionForeground()
	                                           : fg);
	            super.setBackground(bg == null ? table.getSelectionBackground()
	                                           : bg);
	        } else {
	            Color background = unselectedBackground != null
	                                    ? unselectedBackground
	                                    : table.getBackground();
	            if (background == null || background instanceof javax.swing.plaf.UIResource) {
	                Color alternateColor = uidefaults.getColor("Table.alternateRowColor");
	                if (alternateColor != null && row % 2 != 0) {
	                    background = alternateColor;
	                }
	            }
	            super.setForeground(unselectedForeground != null
	                                    ? unselectedForeground
	                                    : table.getForeground());
	            super.setBackground(background);
	        }
 
	        setFont(table.getFont());
 
	        if (hasFocus) {
	            Border border = null;
	            if (isSelected) {
	                border = uidefaults.getBorder("Table.focusSelectedCellHighlightBorder");
	            }
	            if (border == null) {
	                border = uidefaults.getBorder("Table.focusCellHighlightBorder");
	            }
	            setBorder(border);
 
	            if (!isSelected && table.isCellEditable(row, column)) {
	                Color col;
	                col = uidefaults.getColor("Table.focusCellForeground");
	                if (col != null) {
	                    super.setForeground(col);
	                }
	                col = uidefaults.getColor("Table.focusCellBackground");
	                if (col != null) {
	                    super.setBackground(col);
	                }
	            }
	        } else {
	            setBorder(getNoFocusBorder());
	        }
 
 
			List<Integer> list = (List<Integer>)value;
			Object[][] data = new Object[list.size()][1];
			for(int i=0; i<list.size(); i++) {
				data[i][0]=list.get(i);
			}
 
			this.table.setModel(new DefaultTableModel(data, new String[1]));
			int height=(int)this.table.getPreferredSize().getHeight();
			table.setRowHeight(row,height);
			return this;
		}
 
	}
 
}