1 : Tableau (JTable) :
1.Concepts de base :
Table (JTable) est un composant nouvellement ajouté à Swing. Il est principalement utilisé pour afficher des données sous forme de tableau. Il fournit un mécanisme simple pour afficher de gros blocs de données.
2. Méthodes de construction couramment utilisées :
* JTable() : créez une instance de JTable en utilisant le modèle par défaut du système.
* JTable(int numRows, int numColumns) : créez une table vide à l'aide de DefaultTableModel pour spécifier des lignes et des colonnes.
* JTable(Object[ ][ ] rowData,Object[ ][ ] columnNames) : crée un tableau qui affiche des données bidimensionnelles.
Les tableaux peuvent être créés directement à l'aide de tableaux de noms de colonnes et de tableaux de données de tableau.
* JTable (TableModel dm) : créez une instance JTable spécifiant le schéma de données et le schéma de champ par défaut.
Les objets de la classe de modèle de données sont généralement utilisés pour enregistrer des données, et les modèles de table sont créés via des tableaux de noms de colonnes de table et des tableaux de données de table.
3. Méthodes couramment utilisées :
4. Cas complet :
Codage 1 :
Copiez le code comme suit :
la classe publique JTableDemo1 étend JFrame {
//définir la table
Tableau JTable ;
//Définit le panneau de la barre de défilement (pour rendre le tableau défilant)
JScrollPane scrollPane;
//Définir l'objet de la classe du modèle de données (utilisé pour sauvegarder les données),
DefaultTableModel tableModel;
public JTableDemo1() {
super();
setTitle("Modèle de table et table");
scrollPane = new JScrollPane();
//Définit le tableau de noms de colonnes de table
String[] columnNames = { "A", "B", "C" };
//Définir le tableau de données de la table
String[][] tableValues = { { "A1", "B1", "C1" }, { "A2", "B2", "C2" },
{ "A3", "B3", "C3" }, { "A4", "B4", "C4" } } ;
//Créer un objet de la classe de modèle de table spécifiant les noms de colonnes et les données de la table
tableModel = nouveau DefaultTableModel (tableValues, columnNames);
//Créer une table du modèle de table spécifié
table = nouveau JTable(tableModel);
//Set RowSorter (RowSorter est utilisé pour fournir le tri et le filtrage de JTable).
table.setRowSorter(new TableRowSorter<DefaultTableModel>(tableModel));
scrollPane.setViewportView(table);
getContentPane().add(scrollPane, BorderLayout.CENTER);
setBounds(300, 200, 400, 300);
setVisible(vrai);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main(String args[]) {
nouveau JTableDemo1();
}
}
Capture d'écran 1 :
Code 2 :
Copiez le code comme suit :
importer java.awt.* ;
importer javax.swing.* ;
classe publique JTableDemo3 {
Cadre JFrame ;
Panneau JPanel ;
JScrollPane scrollPane1, scrollPane2, scrollPane3 ;
JTable jtable1, jtable2, jtable3 ;
public JTableDemo3() {
frame = new JFrame("JTableDemo");
jtable1 = nouveau JTable(8, 6);
final Object[] columnNames = { "Name", "Gender", "Home Address", // Il est préférable de modifier les noms de colonnes avec final
"Numéro de téléphone", "Anniversaire", "Emploi", "Revenu", "État civil", "Statut relationnel" } ;
Objet[][] rowData = {
{ "ddd", "Homme", "Nanjing, Jiangsu", "1378313210", "24/03/1985", "Étudiant", "Parasite",
"Célibataire", "Pas" },
{ "eee", "femelle", "Nanjing, Jiangsu", "13645181705", "xx/xx/1985", "tuteur", "inconnu",
"Célibataire", "Il semble que non" },
{ "fff", "homme", "Nanjing, Jiangsu", "13585331486", "12/08/1985", "vendeur de voitures",
"Je ne suis pas sûr", "Célibataire", "Oui" },
{ "ggg", "femelle", "Nanjing, Jiangsu", "81513779", "xx/xx/1986", "préposée à l'hôtel",
"Déterminé mais inconnu", "Célibataire", "Oui" },
{ "hhh", "Homme", "Nanjing, Jiangsu", "13651545936", "xx/xx/1985", "Étudiant", "En exil",
"Célibataire", "Pas après de nombreuses ruptures" } };
jtable2 = nouveau JTable(rowData, columnNames);
jtable3 = new JTable(rowData, columnNames);
jtable3.setPreferredScrollableViewportSize(new Dimension(600, 100));//Définir la taille du tableau
jtable3.setRowHeight(30);//Définir la hauteur de chaque ligne sur 20
jtable3.setRowHeight(0, 20);//Définir la hauteur de la ligne 1 à 15
jtable3.setRowMargin(5);//Définir la distance entre deux rangées de cellules adjacentes
jtable3.setRowSelectionAllowed(true); // Définit s'il peut être sélectionné. La valeur par défaut est false.
jtable3.setSelectionBackground(Color.white);//Définir la couleur d'arrière-plan de la ligne sélectionnée
jtable3.setSelectionForeground(Color.red);//Définir la couleur de premier plan de la ligne sélectionnée
jtable3.setGridColor(Color.red);//Définir la couleur des lignes de la grille
jtable3.selectAll();//Sélectionner toutes les lignes
jtable3.setRowSelectionInterval(0, 2);//Définit la ligne de sélection initiale, ici les lignes 1 à 3 sont toutes dans l'état sélectionné
jtable3.clearSelection();//Annuler la sélection
jtable3.setDragEnabled(false); // Je ne comprends pas cela
jtable3.setShowGrid(true); // Afficher ou non les lignes de la grille
jtable3.setShowHorizontalLines(true); // Afficher ou non les lignes de grille horizontales
jtable3.setShowVerticalLines(true); // Afficher ou non les lignes de grille verticales
jtable3.setValueAt("tt", 0, 0);//Définit la valeur d'une certaine cellule, cette valeur est un objet
jtable3.doLayout();
jtable3.setBackground(Color.cyan);
// Il est préférable d'ajouter JTable à JScrollPane pour obtenir un effet de défilement
scrollPane1 = nouveau JScrollPane(jtable1);
scrollPane2 = nouveau JScrollPane(jtable2);
scrollPane3 = nouveau JScrollPane(jtable3);
panneau = nouveau JPanel(nouveau GridLayout(0, 1));
panel.setPreferredSize (nouvelle dimension (600, 400));
panel.setBackground(Color.noir);
panel.add(scrollPane1);
panel.add(scrollPane2);
panel.add(scrollPane3);
frame.setContentPane(panneau);
frame.pack();
frame.setVisible(true);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main (String[] arguments) {
nouveau JTableDemo3();
}
}
Capture d'écran 2 :
Deux : Arbre (JTree) :
1.Concepts de base :
Arbre (JTree) : contrôle qui affiche des ensembles de données hiérarchiques sous forme de contours.
2. Méthodes de construction couramment utilisées :
JTree() : renvoie un JTree avec l'exemple de modèle.
JTree(Object[] value) : renvoie un JTree spécifiant chaque élément du tableau comme nœud enfant du nouveau nœud racine qui n'est pas affiché.
//Seul ce constructeur peut créer plusieurs nœuds racine
JTree(Object[] value) : renvoie un JTree spécifiant chaque élément du tableau comme nœud enfant du nouveau nœud racine qui n'est pas affiché.
JTree (TreeNode root) : renvoie un JTree avec le TreeNode spécifié comme racine, qui affiche le nœud racine.
JTree (racine TreeNode, booléen AsksAllowsChildren) : renvoie un JTree avec le TreeNode spécifié comme racine.
Il affiche le nœud racine d'une manière spécifiée et détermine si le nœud est un nœud feuille. (Définissez true pour ajouter des nœuds enfants, puis ajoutez des nœuds enfants).
3. Démonstration de code :
Exemple 1 :
Copiez le code comme suit :
classe publique JTreeDemo1 {
JFrame f;
Boîte-boîte ;
JArbre jArbre1,jArbre2;
public JTreeDemo1()
{
f = nouveau JFrame(" JTreeDemo1 ");
box = Box.createHorizontalBox(); //Créer un objet de classe Box
jTree1 = nouveau JTree();
jTree2 = nouveau JTree();
//Ajouter des clés/valeurs arbitraires à ce composant
jTree1.putClientProperty("JTree.lineStyle", "Anglé");
//Ajouter un panneau de défilement au conteneur Box
box.add (nouveau JScrollPane (jTree1), BorderLayout.WEST);
box.add (nouveau JScrollPane (jTree2), BorderLayout.EAST);
f.getContentPane().add(box, BorderLayout.CENTER);
f.setSize(300, 240);
//f.pack();
f.setLocation(300, 200);
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main (String[] arguments) {
nouveau JTreeDemo1();
}
}
Capture d'écran 1 :
Exemple 2 :
Copiez le code comme suit :
classe publique JTreeDemo2 {
JFrame f;
JPanel p ;
JTree jTree1, jTree2, jTree3, jTree4, jTree5, jTree6, jTree7 ;
public JTreeDemo2() {
f = nouveau JFrame(" JTreeDemo2 ");
// Constructeur : JTree()
jTree1 = nouveau JTree();
// Constructeur : JTree (valeur Objet[])
Objet[] lettres = { " a ", " b ", " c ", " d ", " e " } ;
jTree2 = nouveau JTree(lettres);
// Constructeur : JTree (racine du TreeNode) (TreeNode vide)
//Créer un arbre avec des nœuds vides
DefaultMutableTreeNode node1 = new DefaultMutableTreeNode(); // Définir les nœuds de l'arborescence
jTree3 = new JTree(node1); // Utiliser ce nœud d'arbre comme paramètre pour appeler le constructeur JTree pour créer un arbre avec un nœud racine
// Constructeur : JTree (racine de TreeNode) (comme ci-dessus, sauf que TreeNode n'est pas vide)
// Crée un arbre avec un nœud racine
DefaultMutableTreeNode node2 = new DefaultMutableTreeNode(" Couleur ");
jTree4 = new JTree(node2); // Les nœuds ne peuvent pas être colorés, la valeur par défaut est blanche avec du texte noir
jTree4.setBackground(Color.lightGray);
// Constructeur : JTree (racine TreeNode, booléen
// AsksAllowsChildren) (comme ci-dessus, mais TreeNode est différent)
// Utilisez la classe DefaultMutableTreeNode pour créer d'abord une arborescence avec un nœud racine, configurez-la pour ajouter des nœuds enfants, puis ajoutez des nœuds enfants.
Couleur DefaultMutableTreeNode = new DefaultMutableTreeNode(" Couleur ",
vrai);
DefaultMutableTreeNode gris = new DefaultMutableTreeNode(" Gris ");
gray.add(new DefaultMutableTreeNode(" Lightgray "));
gray.add(new DefaultMutableTreeNode(" Darkgray "));
color.add(gris);
color.add(new DefaultMutableTreeNode(" Rouge "));
color.add(new DefaultMutableTreeNode(" Vert "));
jTree5 = nouveau JTree(couleur);
// Constructeur : JTree (racine de TreeNode) (comme ci-dessus, sauf que TreeNode n'est pas vide)
// Crée un arbre en ajoutant des nœuds un par un
DefaultMutableTreeNode biologie = new DefaultMutableTreeNode(" Biologie ");
DefaultMutableTreeNode animal = new DefaultMutableTreeNode(" Animal ");
DefaultMutableTreeNode mammifère = new DefaultMutableTreeNode(" Mammifère ");
DefaultMutableTreeNode cheval = new DefaultMutableTreeNode(" Cheval ");
mammifère.ajouter (cheval);
animal.add(mammifère);
biologie.ajouter(animal);
jTree6 = nouveau JTree (biologie);
cheval.isLeaf();
cheval.isRoot();
//Constructeur : JTree (TreeModel nouveauModèle)
// Utilisez la classe DefaultMutableTreeNodel pour définir un nœud puis utilisez ce nœud comme paramètre pour définir un nœud en utilisant DefaultTreeMode
// Créez un modèle d'arbre, puis utilisez le constructeur JTree pour créer un arbre
DefaultMutableTreeNode root = new DefaultMutableTreeNode(" Root1 ");
DefaultMutableTreeNode child1 = new DefaultMutableTreeNode(" Child1 ");
DefaultMutableTreeNode child11 = new DefaultMutableTreeNode(" Child11 ");
DefaultMutableTreeNode child111 = nouveau DefaultMutableTreeNode (
" Enfant111 ");
root.add(enfant1);
enfant1.ajouter(enfant11);
enfant11.ajouter(enfant111);
Modèle DefaultTreeModel = nouveau DefaultTreeModel (racine);
jTree7 = nouveau JTree (modèle) ;
p = nouveau JPanel();
p.setLayout(new BoxLayout(p, BoxLayout.X_AXIS));
p.setPreferredSize(nouvelle Dimension(700, 400));
// JTree doit être placé sur JScrollPane
p.add(nouveau JScrollPane(jTree1));
p.add(nouveau JScrollPane(jTree2));
p.add(nouveau JScrollPane(jTree3));
p.add(nouveau JScrollPane(jTree4));
p.add(nouveau JScrollPane(jTree5));
p.add(nouveau JScrollPane(jTree6));
p.add(nouveau JScrollPane(jTree7));
f.setContentPane(p);
f.pack();
f.setLocation(300, 200);
f.setVisible(true);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public static void main (String[] arguments) {
nouveau JTreeDemo2();
}
}
Capture d'écran 2 :