Remplir un JTable avec une base de donnée

Version imprimable

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:

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:

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:

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

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:

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:

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:

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:

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:

model.addRow(produit);
Supprimer une ligne

Code:

model.removeRow(int);

ou

Code:

model.removeRow(produit);

ajouter plusieurs produits

Code:

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

remplacer les produits

Code:

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

19/11/2019, 16h50
WiZarD67
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:

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
19/11/2019, 17h15
joel.drigo
Citation:

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.
Citation:
Envoyé par WiZarD67

Mon erreur est ici :

Code:

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 ?

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:

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:

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.

Citation:

Envoyé par WiZarD67

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:

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:

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;
}

20/11/2019, 08h31
WiZarD67

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