Remplir un JTable avec une base de donnée

**WiZarD67** · 18/11/2019, 19h20

Bonjour

Je viens vers vous pour voir de l'aide et pour mieux comprendre comment fonctionne les JTable de swing. En effet j'ai du mal à comprendre leur fonctionnement. Mon problème est que je souhaiterai afficher une table de produit dans une JFrame. Pour cela je pensais utiliser les JTable j'ai regardé comme il fonctionnais et je me suis rendu compte que pour les compléter il me fallait un tableau d'Objet à 2 dimension.
Je possède deux class :

Class BDConnect : Qui dans mon intension me renvoyer toute les valeurs qui concerne ma bdd

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
 
package HomeShop;
 
import java.sql.*;
 
public class BDConnect {
 
	public BDConnect() {
		connect();
	}
 
	public boolean connect() {
		Connection cn = null;
		try {
			cn = DriverManager.getConnection("jdbc:sqlite:./File/HomeShop.db");
			System.out.println("Connexion à la Base de donnée : Reussi !");
			return true;
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			System.out.println("Connexion à la Base de donnée : Impossible");
			return false;
		} finally {
			try {
				cn.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}
	}
 
	public Object[][] readTable(){
		Object[][] product = {};
		Statement st = null;
		Connection cn = null;
		ResultSet rs = null;
		try {
			cn = DriverManager.getConnection("jdbc:sqlite:./File/HomeShop.db");
			st = cn.createStatement();
			rs = st.executeQuery("SELECT * FROM Produit");
			while(rs.next()) {
				//Boucle qui remplie product avec toute les données de la table.
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				cn.close();
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return product;
	}
}

Class FenProduit : qui me permet d'afficher mon 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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
package HomeShop;
 
import java.awt.*;
import java.sql.*;
import javax.swing.*;
 
public class FenProduit extends JFrame {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
 
	String[] entete = {"ID", "Nom", "Description", "Quantité", "Prix"};
	BDConnect connec = new BDConnect();
 
	public FenProduit() {
		setTitle("Produit");
		setPreferredSize(new Dimension(900, 500));
		JPanel panGen = new JPanel(new BorderLayout());
		JTable produit = new JTable(connec.readTable(), entete);
		panGen.add(produit.getTableHeader(), BorderLayout.NORTH);
		panGen.add(produit, BorderLayout.CENTER);
 
		getContentPane().add(panGen);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		pack();
	}
 
	public static void main(String[] arg) {
		FenProduit f1 = new FenProduit();
		f1.setVisible(true);
	}
}

Dans mes recherches sur internet j'ai vue que pour les JTable il fallait l'instancier de ce type :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
Object[][] donnees = {
                {"Johnathan", "Sykes", Color.red.toString(), true, "TENIS"},
                {"Nicolas", "Van de Kampf", Color.black.toString(), true, "FOOTBALL"},
                {"Damien", "Cuthbert", Color.cyan.toString(), true, "RIEN"},
                {"Corinne", "Valance", Color.blue.toString(), false, "NATATION"},
                {"Emilie", "Schrödinger", Color.magenta.toString(), false, "FOOTBALL"},
                {"Delphine", "Duke", Color.yellow.toString(), false, "TENNIS"},
                {"Eric", "Trump", Color.pink.toString(), true, "FOOTBALL"}
        };
 
        String[] entetes = {"Prénom", "Nom", "Couleur favorite", "Homme", "Sport"};
 
        JTable tableau = new JTable(donnees, entetes);

Ma question étant de comment faire une boucle sur les données de ma BDD dans des table d'objets si j'ai tout compris ! Si il y a des solutions plus simple je suis preneurs je suis en apprentissage de java et j'aimerai aussi savoir comment faire au plus pratique.

Bonne soirée

**joel.drigo** · 19/11/2019, 11h34

Salut,

Tu peux remplir la JTable avec des Vector de Vector ce qui te facilitera le remplissage à partir du résultat d'une requête.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
String[] columns = {"Nom","Valeur"};
 
		Vector<Object> rowData = new Vector<>(); // vector de lignes
		while(resultset.next()) { // on parcourt les enregistrements dans le resultat de requête
			Vector<Object> row = new Vector<>(); // on créé un Vector pour l'enregistrement en cours
			row.add(resultset.getString(1)); // on ajoute la première colonne
			row.add(resultset.getInt(2)); // on ajoute la deuxième colonne
			// ... comme ça pour toutes les colonnes qu'on veut
			rowData.add(row); // on ajoute la ligne au vecteur de lignes
		}
 
		// on créé la jtable 
		JTable jtable = new JTable(rowData, Arrays.stream(columns).collect(Collectors.toCollection(Vector::new)));

On peut également implémenter son propre modèle, avec des List par exemple, au lieu de Vector, voire même des List de bean. Par exemple, on peut faire un modèle générique 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
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
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Function;
 
import javax.swing.table.AbstractTableModel;
 
public class ArrayListTableModel<T> extends AbstractTableModel {
 
	private static final long serialVersionUID = 1L;
	private final List<T> rows = new ArrayList<>();
	private final Set<T> modified = new HashSet<>();
	private final Column<T, ?>[] columns;
 
	public ArrayListTableModel(Column<T, ?>... columns) {
		this.columns = Arrays.copyOf(columns, columns.length);
	}
 
	public ArrayListTableModel(List<T> rows, Column<T, ?>... columns) {
		this(columns);
		this.rows.addAll(rows);
	}
 
	@Override
	public int getRowCount() {
		return rows.size();
	}
 
	public boolean isEmpty() {
		return rows.isEmpty();
	}
 
	@Override
	public int getColumnCount() {
		return columns.length;
	}
 
	@Override
	public String getColumnName(int columnIndex) {
		return columns[columnIndex].getName();
	}
 
	@Override
	public Class<?> getColumnClass(int columnIndex) {
		return columns[columnIndex].getDataClass();
	}
 
	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		return columns[columnIndex].getValue(rows.get(rowIndex));
	}
 
	@Override
	public void setValueAt(Object value, int rowIndex, int columnIndex) {
		columns[columnIndex].setValue(rows.get(rowIndex), value);
		modified.add(rows.get(rowIndex));
	}
 
	@Override
	public boolean isCellEditable(int rowIndex, int columnIndex) {
		return columns[columnIndex].isEditable();
	}
 
	public void addRow(T data) {
		insertRow(rows.size(), data);
	}
 
	public void setRow(int row, T data) {
		rows.set(row, data);
		fireTableRowsUpdated(row, row);
	}
 
	public void insertRow(int row, T data) {
		rows.add(row, data);
		fireTableRowsInserted(row, row);
	}
 
	public void removeRow(int row) {
		rows.remove(row);
		fireTableRowsDeleted(row, row);
	}
 
	public void remove(T data) {
		int row = rows.indexOf(data);
		if ( row>=0 ) {
			removeRow(row);
		}
	}
 
	public void addRows(T data, T...dataArray) {
		int first = rows.size();
		rows.add(first, data);
		int last = first;
		for(T d : dataArray) {
			last=rows.size();
			rows.add(last, d);
		}
		fireTableRowsInserted(first, last);
	}
 
        public void addRows(Collection<T> data) {
		if ( !data.isEmpty() ) {
			int first = rows.size();
			int last = first;
			for(T d : data) {
				last=rows.size();
				rows.add(last, d);
			}
			fireTableRowsInserted(first, last);
		}
	}
 
	public void removeRows(int first, int last) {
		last = Math.min(rows.size()-1,last);
		if ( first<=last ) {
			rows.subList(first, last+1).clear();
			fireTableRowsDeleted(first, last);
		}
	}
 
	public void clearRows() {
		if ( !rows.isEmpty() ) {
			int first = 0;
			int last = rows.size()-1;
			rows.clear();
			fireTableRowsDeleted(first, last);
		}
	}
 
	public void setRows(T data, T...dataArray) {
		clearRows();
		int first = rows.size();
		rows.add(first, data);
		int last = first;
		for(T d : dataArray) {
			last=rows.size();
			rows.add(last, d);
		}
		fireTableRowsInserted(first, last);
	}
 
	public void reset() {
		modified.clear();
	}
 
	public Collection<T> getRows() {
		return new ArrayList<>(rows);
	}
 
	public Collection<T> modifiedRows() {
		return new HashSet<>(modified);
	}
 
	public static class Column<T, C> {
 
		private String name;
		private Function<T, C> getter;
		private BiConsumer<T, C> setter;
		private Class<C> dataClass;
 
		public Column(String name, Class<C> dataClass, Function<T, C> getter) {
			this(name, dataClass, getter, null);
		}
 
		public Class<?> getDataClass() {
			return dataClass;
		}
 
		public Column(String name, Class<C> dataClass, Function<T, C> getter, BiConsumer<T, C> setter) {
			this.name = name;
			this.dataClass = dataClass;
			this.getter = getter;
			this.setter = setter;
		}
 
		public boolean isEditable() {
			return setter != null;
		}
 
		public String getName() {
			return name;
		}
 
		public C getValue(T elem) {
			return getter.apply(elem);
		}
 
		public void setValue(T elem, Object value) {
			if (setter != null) {
				setter.accept(elem, dataClass.cast(value));
			}
		}
 
	} 
 
}

Et l'utiliser avec une classe Produit qui représente le type d'objets qu'on veut afficher dans la 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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
	public static class Produit {
		private String name;
		private int stock;
		private float prix;
 
		public String getName() {
			return name;
		}
 
		public void setName(String name) {
			this.name = name;
		}
 
		public int getStock() {
			return stock;
		}
 
		public void setStock(int stock) {
			this.stock = stock;
		}
 
		public float getPrix() {
			return prix;
		}
 
		public void setPrix(float prix) {
			this.prix = prix;
		}
	}

Code :

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

1
2
3
4
5
6
Column<Produit, String> columnNom = new Column<>("Nom",String.class, Produit::getName); // cette colonne n'est pas éditable
Column<Produit, Integer> columnStock = new Column<>("Prix",Integer.class, Produit::getStock,Produit::setStock); // cette colonne est éditable
Column<Produit, Float> columnPrix = new Column<>("Prix",Float.class, Produit::getPrix); // cette colonne n'est pas éditable
 
ArrayListTableModelmodel<Produit> model = new ArrayListTableModel<>(columnNom, columnStock, columnPrix);
JTable table = new JTable(model);

Après on peut :

Ajouter un produit
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
model.addRow(produit);
```
Supprimer une ligne
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
model.removeRow(int);
```
ou
Code : Sélectionner tout - Visualiser dans une fenêtre à part
```
model.removeRow(produit);
```

ajouter plusieurs produits

Code :

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

1
2
3
 
List<Produit> produits = getProduits();
model.addRows(produits);

remplacer les produits

Code :

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

1
2
3
 
List<Produit> produits = getProduits();
model.setRows(produits);

etc

**WiZarD67** · 19/11/2019, 16h50

Salut,

Je viens de tester votre premier méthode qui me plaisait bien mais elle ne fonctionne pas .. je vais essayer la deuxième avec le model

Mon erreur est ici :

Code :

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

1
2
 
JTable produit = new JTable(connec.readTable(), Arrays.stream(entete).collect(Collectors.toCollection(Vector::new)));

Je precise que je j'ai utiliser deux class différentes peut être que cela viens de la le problème

**joel.drigo** · 19/11/2019, 17h15

Envoyé par WiZarD67

Je viens de tester votre premier méthode qui me plaisait bien mais elle ne fonctionne pas ..

Elle fonctionne très bien, si tant est qu'elle soit utilisée dans le contexte adéquat.

Envoyé par WiZarD67

Mon erreur est ici :

Code :

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

1
2
 
JTable produit = new JTable(connec.readTable(), Arrays.stream(entete).collect(Collectors.toCollection(Vector::new)));

Je precise que je j'ai utiliser deux class différentes peut être que cela viens de la le problème

Quel problème ? Le message d'erreur affiché le cas échéant ça sert aussi, en précisant erreur à la compilation ou à l'exécution.

Et difficile de savoir sans avoir plus de code. De quelles (deux) classes (différentes) tu parles ?
C'est quoi connec ou entete ? readTable() ça retourne quel type ? Du Vector n'est-ce pas ?

**WiZarD67** · 19/11/2019, 18h08

Je pense que je ne l'utilise pas correctement.

L'erreur que me retour eclipse est : The constructor JTable(Vector<Object>, Arrays.stream(entete).collect(Collectors.toCollection(Vector::new))) is undefined

Je te donne les deux class concerner :

BDConnect qui me sert de connection à ma base de donner avec la méthode readProduct() qui est censer me retourner un vector pour mon 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
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
 
package HomeShop;
 
import java.sql.*;
import java.util.*;
 
public class BDConnect {
 
	public BDConnect() {
		connect();
	}
 
	public boolean connect() {
		Connection cn = null;
		try {
			cn = DriverManager.getConnection("jdbc:sqlite:./File/HomeShop.db");
			System.out.println("Connexion à la Base de donnée : Reussi !");
			return true;
		} catch (SQLException e) {
			System.out.println(e.getMessage());
			System.out.println("Connexion à la Base de donnée : Impossible");
			return false;
		} finally {
			try {
				cn.close();
			} catch (SQLException e) {
				System.out.println(e.getMessage());
			}
		}
	}
 
	public Vector<Object> readTable(){
		Vector<Object> rowData = new Vector<>();
		Statement st = null;
		Connection cn = null;
		ResultSet rs = null;
		try {
			cn = DriverManager.getConnection("jdbc:sqlite:./File/HomeShop.db");
			st = cn.createStatement();
			rs = st.executeQuery("SELECT * FROM Produit");
			while(rs.next()) {
				Vector<Object> row = new Vector<>();
				row.add(rs.getInt(1));
				row.add(rs.getString(2));
				row.add(rs.getString(3));
				row.add(rs.getInt(4));
				row.add(rs.getFloat(5));
				rowData.add(row);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				cn.close();
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return rowData;
	}
}

Ma deuxième class là où doit s'afficher la 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
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
package HomeShop;
 
import java.awt.*;
import java.sql.*;
import java.util.*;
import java.util.stream.Collectors;
import javax.swing.*;
 
public class FenProduit extends JFrame {
 
	/**
         * 
         */
	private static final long serialVersionUID = 1L;
 
	String[] entete = {"ID", "Nom", "Description", "Quantité", "Prix"};
	BDConnect connec = new BDConnect();
 
	public FenProduit() {
		setTitle("Produit");
		setPreferredSize(new Dimension(900, 500));
		JPanel panGen = new JPanel(new BorderLayout());
		JTable produit = new JTable(connec.readTable(), Arrays.stream(entete).collect(Collectors.toCollection(Vector::new)));
		panGen.add(produit.getTableHeader(), BorderLayout.NORTH);
		panGen.add(produit, BorderLayout.CENTER);
 
		getContentPane().add(panGen);
		setDefaultCloseOperation(EXIT_ON_CLOSE);
		pack();
	}
 
	public static void main(String[] arg) {
		FenProduit f1 = new FenProduit();
		f1.setVisible(true);
	}
}

Je ne sais pas si ce que j'ai fait peut potentiellement marcher je pensais récupérer toute les données dans une méthode dans la class BDConnect et simplement appeler la méthode dans la class FenProduct pour afficher les données.

**joel.drigo** · 20/11/2019, 00h48

Envoyé par WiZarD67

Je pense que je ne l'utilise pas correctement.

L'erreur que me retour eclipse est : The constructor JTable(Vector<Object>, Arrays.stream(entete).collect(Collectors.toCollection(Vector::new))) is undefined

Ah oui, c'est juste que le constructeur de JTable attend du Vector et pas du Vector<Object>.

Soit tu joues sur le type de retour de readData :

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
public Vector readTable(){
		Vector<Object> rowData = new Vector<>();
		Statement st = null;
		Connection cn = null;
		ResultSet rs = null;
		try {
			cn = DriverManager.getConnection("jdbc:sqlite:./File/HomeShop.db");
			st = cn.createStatement();
			rs = st.executeQuery("SELECT * FROM Produit");
			while(rs.next()) {
				Vector<Object> row = new Vector<>();
				row.add(rs.getInt(1));
				row.add(rs.getString(2));
				row.add(rs.getString(3));
				row.add(rs.getInt(4));
				row.add(rs.getFloat(5));
				rowData.add(row);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			try {
				cn.close();
				st.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return rowData;
}

Au passage on peut simplifier

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
public Vector readTable() {
		Vector<Object> rowData = new Vector<>();
		try (Connection cn = DriverManager.getConnection("jdbc:sqlite:./File/HomeShop.db");
		     Statement st = cn.createStatement();
		     ResultSet rs = executeQuery("SELECT * FROM Produit");) {
			while (rs.next()) {
				Vector<Object> row = new Vector<>();
				row.add(rs.getInt(1));
				row.add(rs.getString(2));
				row.add(rs.getString(3));
				row.add(rs.getInt(4));
				row.add(rs.getFloat(5));
				rowData.add(row);
			}
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return rowData;
}

**WiZarD67** · 20/11/2019, 08h31

Effectivement maintenant cela marche comme il faut merci beaucoup je ne savais pas comment on utilise les JTable merci beaucoup

Remplir un JTable avec une base de donnée

Composants Java

Discussions similaires

Partager

Partager