Comment créer une table Java à l'aide de JTable

Java fournit une classe utile appelée JTable qui vous permet de créer des tables lors du développement d'interfaces utilisateur graphiques à l'aide des composants de l'API Swing de Java. Vous pouvez permettre aux utilisateurs de modifier les données ou simplement de visualiser les données. Notez que le tableau ne contient pas réellement de données – il s’agit simplement d’un mécanisme d’affichage.

Remarque : comme pour toute interface graphique Swing, vous devez créer un conteneur pour afficher la JTable .

Utiliser des tableaux pour stocker les données d'une table

Un moyen simple de fournir des données à la classe JTable consiste à utiliser deux tableaux. Le premier enregistre les noms de colonnes dans un tableau String :

String[] columnNames = {"First Name", "Surname", "Country"
, "Event", "Place", "Time", "World Record" };

Le deuxième tableau est un tableau d'objets bidimensionnel qui contient les données de la table. Par exemple, ce tableau comprend six nageurs olympiques :

Object[][] data = {
{"César Cielo", "Filho", "Brazil", "50m freestyle",1 , "21.30", false },
{"Amaury", "Leveaux", "France", "50m freestyle", 2, "21.45", false },
{"Eamon", "Sullivan", "Australia", "100m freestyle", 2, "47.32", false },
{"Michael", "Phelps", "USA", "200m freestyle", 1, "1:42.96", false },
{"Ryan", "Lochte", "USA", "200m backstroke", 1, "1:53.94", true },
{"Hugues", "Duboscq", "France", "100m breaststroke", 3, "59.37", false }
};

La clé ici est de s'assurer que les deux tableaux ont le même nombre de colonnes.

Construire une JTable

Une fois que vous avez vos données, créer une table est une tâche simple. Appelez simplement le constructeur JTable et transmettez-lui deux tableaux :

JTable table = new JTable(data, columnNames);

Vous souhaiterez peut-être ajouter des barres de défilement pour garantir que l'utilisateur peut voir toutes les données. Pour ce faire, placez sa JTable dans un JScrollPane :

JScrollPane tableScrollPane = new JScrollPane(table);

Désormais, lorsque la table est affichée, vous verrez les colonnes et les lignes de données et pourrez faire défiler de haut en bas.

L'objet JTable fournit un tableau interactif. Si vous double-cliquez sur une cellule, vous pourrez en modifier le contenu, bien que toute modification n'affecte que l'interface graphique, pas les données sous-jacentes. (Un écouteur d'événements doit être implémenté pour gérer les modifications apportées aux données.).

Pour modifier la largeur d'une colonne, passez la souris sur le bord de l'en-tête de la colonne et faites-le glisser d'avant en arrière. Pour modifier l'ordre des colonnes, cliquez et maintenez sur l'en-tête de la colonne, puis faites-le glisser vers un nouvel emplacement.

Trier les colonnes

Pour ajouter la possibilité de trier les lignes, appelez la méthode setAutoCreateRowSorter :

table.setAutoCreateRowSorter(true);

Lorsque cette méthode est définie sur When true , vous pouvez cliquer sur un en-tête de colonne pour trier les lignes en fonction du contenu des cellules situées sous cette colonne.

Changer l'apparence du tableau

Pour contrôler la visibilité des lignes de la grille, utilisez la méthode setShowGrid suivante :

table.setShowGrid(true);

Pour complètement changer le tableau Pour les couleurs, veuillez utiliser les méthodes setBackground et setGridColor :

table.setGridColor(Color.YELLOW);
table.setBackground(Color.CYAN);

Par défaut, les largeurs de colonnes du tableau sont égales. Si le conteneur dans lequel se trouve la table est redimensionnable, la largeur des colonnes augmentera et diminuera, et le conteneur deviendra plus grand ou plus petit. Si l'utilisateur redimensionne la colonne, la largeur de la colonne de droite changera pour s'adapter à la nouvelle taille de colonne.

La largeur initiale de la colonne peut être définie à l'aide de la méthode ou de la colonne setPreferredWidth. Utilisez la classe TableColumn pour obtenir d'abord une référence à la colonne, puis définissez la taille à l'aide de la méthode setPreferredWidth :

TableColumn eventColumn = table.getColumnModel().getColumn(3);
eventColumn.setPreferredWidth(150);
TableColumn placeColumn = table.getColumnModel().getColumn(4);
placeColumn.setPreferredWidth(5);

Sélectionnez les lignes

Par défaut, l'utilisateur peut transmettre les trois éléments suivants. L'une des façons de sélectionner une ligne d'un tableau :

Pour sélectionner une seule ligne, cliquez sur une cellule du tableau dans cette ligne.

Pour sélectionner plusieurs lignes consécutives, faites glisser votre souris sur plusieurs lignes ou cliquez sur une cellule du tableau en appuyant sur Shift Cell.

Pour sélectionner plusieurs lignes non contiguës, maintenez la touche Contrôle enfoncée (touche Commande sur Mac) tout en cliquant sur une cellule du tableau.

Utiliser le modèle de table

Si vous souhaitez un tableau simple basé sur des chaînes qui peut être modifié, utiliser quelques tableaux comme données du tableau peut être utile . Si vous regardez le tableau de données que nous avons créé, les autres types de données qu'il contient sont des chaînes : la colonne Place contient des entiers et la colonne World Record contient des booléens. Cependant, les deux colonnes sont affichées sous forme de chaînes. Pour modifier ce comportement, créez un modèle de table.

Les modèles de tableaux gèrent les données à afficher dans les tableaux. Pour implémenter un modèle de table, vous créez une classe qui étend la classe AbstractTableModel :

public abstract class AbstractTableModel extends Object implements TableModel, Serializable{
public int getRowCount();
public int getColumnCount();
public Object getValueAt(int row, int column);
public String getColumnName(int column;
public boolean isCellEditable(int rowIndex, int columnIndex);
public Class getColumnClass(int columnIndex);
}

Les six méthodes ci-dessus sont celles utilisées dans ce guide étape par étape, mais la classe AbstractTableModel définit de nombreuses autres méthodes. qui peut être utilisé pour manipuler des données dans des objets JTable. Lors de l'extension d'une classe pour utiliser AbstractTableModel, il vous suffit d'implémenter les méthodes getRowCount, getColumnCount et getValueAt.

Créez une nouvelle classe qui implémente les cinq méthodes ci-dessus :

class ExampleTableModel extends AbstractTableModel{
String[] columnNames = {"First Name", "Surname", "Country"
, "Event", "Place", "Time", "World Record" };
Object[][] data = {
{"César Cielo", "Filho", "Brazil", "50m freestyle",1 , "21.30", false },
{"Amaury", "Leveaux", "France", "50m freestyle", 2, "21.45", false },
{"Eamon", "Sullivan", "Australia", "100m freestyle", 2, "47.32", false },
{"Michael", "Phelps", "USA", "200m freestyle", 1, "1:42.96", false },
{"Larsen", "Jensen", "USA", "400m freestyle", 3, "3:42.78", false },
};
@Override
public int getRowCount()
{
return data.length;
}
@Override
public int getColumnCount()
{
return columnNames.length;
}
@Override
public Object getValueAt(int row, int column)
{
return data[row][column];
}
@Override
public String getColumnName(int column) {
return columnNames[column];
}@Override
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}@Override
public boolean isCellEditable(int row, int column)
{
if (column == 1 || column == 2)
{
return false;
}
else
{
return true;
}
}
}

Dans cet exemple, la classe SampleTableModel contient deux chaînes contenant les données de la table significatives. Ensuite, les méthodes getRowCount, getColumnCount, getValueAt et getColumnName peuvent utiliser le tableau pour fournir les valeurs du tableau. Notez également comment la méthode isCellEditable est écrite pour désactiver la modification des deux premières colonnes.

Maintenant, JTable, nous pouvons utiliser la classe SampleTableModel suivante au lieu d'utiliser deux tableaux pour créer l'objet :

JTable table = new JTable(new ExampleTableModel());

Lorsque le code s'exécute, vous verrez que l'objet JTable utilise le modèle de tableau car il n'y a aucune cellule de tableau à modifier et les noms de colonnes sont utilisés correctement. Si la méthode getColumnName n'a pas été implémentée, les noms de colonnes de la table apparaîtront comme les noms par défaut de A, B, C, D, etc.

我们现在考虑一下该方法  getColumnClass。仅这一点使得表模型值得实现，因为它为JTable对象提供了每列中包含的数据类型。如果您还记得，对象数据数组有两列不是String数据类型：Place包含int的World Record列和包含的列booleans。了解这些数据类型会更改JTable对象为这些列提供的功能。运行带有表模型的示例表代码意味着该World Record列实际上将是一系列复选框。

添加ComboBox编辑器

您可以为表中的单元格定义自定义编辑器。例如，您可以使组合框替换字段的标准文本编辑。

以下是使用JComboBoxcountry字段的示例  ：

String[] countries = {"Australia", "Brazil", "Canada", "China"
,"France", "Japan", "Norway", "Russia", "South Korea"
, "Tunisia", "USA"};
JComboBox countryCombo = new JComboBox(countries);

要设置country列的默认编辑器，请使用TableColumn该类获取对country列的引用，并使用该setCellEditor方法将该列设置JComboBox为单元格编辑器：

TableColumn countryColumn = table.getColumnModel().getColumn(2);
countryColumn.setCellEditor(new DefaultCellEditor(countryCombo));

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!