{"id":3005,"date":"2026-06-21T11:44:25","date_gmt":"2026-06-21T03:44:25","guid":{"rendered":"http:\/\/www.valleychildtherapy.com\/blog\/?p=3005"},"modified":"2026-06-21T11:44:25","modified_gmt":"2026-06-21T03:44:25","slug":"how-to-use-a-jtable-in-swing-4209-91efc8","status":"publish","type":"post","link":"http:\/\/www.valleychildtherapy.com\/blog\/2026\/06\/21\/how-to-use-a-jtable-in-swing-4209-91efc8\/","title":{"rendered":"How to use a JTable in Swing?"},"content":{"rendered":"

In the realm of Java GUI programming, Swing stands out as a powerful and versatile toolkit. One of the most useful components in Swing is the JTable, which allows developers to display and manipulate tabular data in a user – friendly way. As a Swing supplier, I’ve had the privilege of working with numerous clients to implement JTable in their applications, and I’m excited to share my insights on how to use it effectively. Swing<\/a><\/p>\n

<\/p>\n

Understanding the Basics of JTable<\/h3>\n

A JTable is a visual component that presents data in a two – dimensional table format, similar to a spreadsheet. It consists of rows and columns, where each cell can hold a value. To create a basic JTable, you first need to define the data model.<\/p>\n

The simplest way to create a JTable is by using a DefaultTableModel<\/code>. Here’s a basic example:<\/p>\n

import javax.swing.JFrame;\nimport javax.swing.JTable;\nimport javax.swing.table.DefaultTableModel;\n\npublic class BasicJTableExample {\n    public static void main(String[] args) {\n        \/\/ Define column names\n        String[] columnNames = {"Name", "Age", "City"};\n        \/\/ Define data\n        Object[][] data = {\n                {"John", 25, "New York"},\n                {"Jane", 30, "Los Angeles"},\n                {"Bob", 22, "Chicago"}\n        };\n        \/\/ Create a DefaultTableModel\n        DefaultTableModel model = new DefaultTableModel(data, columnNames);\n        \/\/ Create a JTable with the model\n        JTable table = new JTable(model);\n        \/\/ Create a JFrame to hold the table\n        JFrame frame = new JFrame("Basic JTable Example");\n        frame.add(table.getTableHeader(), java.awt.BorderLayout.NORTH);\n        frame.add(table, java.awt.BorderLayout.CENTER);\n        frame.setSize(400, 300);\n        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n        frame.setVisible(true);\n    }\n}\n<\/code><\/pre>\n
In this example, we first define an array of column names and a two – dimensional array of data. We then create a DefaultTableModel<\/code> using these arrays. Finally, we create a JTable<\/code> with the model and add it to a JFrame<\/code> for display.<\/p>\n
Customizing the Appearance of JTable<\/h3>\n
While the basic JTable looks functional, you may want to customize its appearance to match the overall look and feel of your application. You can customize various aspects such as cell colors, fonts, and borders.<\/p>\n
To change the cell color, you can use a custom TableCellRenderer<\/code>. Here’s an example:<\/p>\n
import javax.swing.JFrame;\nimport javax.swing.JTable;\nimport javax.swing.table.DefaultTableCellRenderer;\nimport javax.swing.table.DefaultTableModel;\nimport java.awt.Color;\nimport java.awt.Component;\n\npublic class CustomCellColorExample {\n    public static void main(String[] args) {\n        String[] columnNames = {"Name", "Age", "City"};\n        Object[][] data = {\n                {"John", 25, "New York"},\n                {"Jane", 30, "Los Angeles"},\n                {"Bob", 22, "Chicago"}\n        };\n        DefaultTableModel model = new DefaultTableModel(data, columnNames);\n        JTable table = new JTable(model);\n\n        \/\/ Create a custom cell renderer\n        DefaultTableCellRenderer renderer = new DefaultTableCellRenderer() {\n            @Override\n            public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {\n                Component c = super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);\n                if (row % 2 == 0) {\n                    c.setBackground(Color.LIGHT_GRAY);\n                } else {\n                    c.setBackground(Color.WHITE);\n                }\n                return c;\n            }\n        };\n\n        \/\/ Apply the renderer to all columns\n        for (int i = 0; i < table.getColumnCount(); i++) {\n            table.getColumnModel().getColumn(i).setCellRenderer(renderer);\n        }\n\n        JFrame frame = new JFrame("Custom Cell Color Example");\n        frame.add(table.getTableHeader(), java.awt.BorderLayout.NORTH);\n        frame.add(table, java.awt.BorderLayout.CENTER);\n        frame.setSize(400, 300);\n        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n        frame.setVisible(true);\n    }\n}\n<\/code><\/pre>\n
In this code, we create a custom DefaultTableCellRenderer<\/code> and override the getTableCellRendererComponent<\/code> method. Inside this method, we set the background color of every other row to light gray. We then apply this renderer to all columns of the table.<\/p>\n
Handling User Interaction<\/h3>\n
JTable allows users to interact with the data in various ways, such as selecting rows, editing cells, and sorting columns.<\/p>\n
Row Selection<\/h4>\n
To handle row selection, you can add a ListSelectionListener<\/code> to the table’s selection model. Here’s an example:<\/p>\n
import javax.swing.JFrame;\nimport javax.swing.JTable;\nimport javax.swing.event.ListSelectionEvent;\nimport javax.swing.event.ListSelectionListener;\nimport javax.swing.table.DefaultTableModel;\n\npublic class RowSelectionExample {\n    public static void main(String[] args) {\n        String[] columnNames = {"Name", "Age", "City"};\n        Object[][] data = {\n                {"John", 25, "New York"},\n                {"Jane", 30, "Los Angeles"},\n                {"Bob", 22, "Chicago"}\n        };\n        DefaultTableModel model = new DefaultTableModel(data, columnNames);\n        JTable table = new JTable(model);\n\n        table.getSelectionModel().addListSelectionListener(new ListSelectionListener() {\n            @Override\n            public void valueChanged(ListSelectionEvent e) {\n                if (!e.getValueIsAdjusting()) {\n                    int selectedRow = table.getSelectedRow();\n                    if (selectedRow != -1) {\n                        System.out.println("Selected row: " + selectedRow);\n                        for (int i = 0; i < table.getColumnCount(); i++) {\n                            System.out.println(table.getColumnName(i) + ": " + table.getValueAt(selectedRow, i));\n                        }\n                    }\n                }\n            }\n        });\n\n        JFrame frame = new JFrame("Row Selection Example");\n        frame.add(table.getTableHeader(), java.awt.BorderLayout.NORTH);\n        frame.add(table, java.awt.BorderLayout.CENTER);\n        frame.setSize(400, 300);\n        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n        frame.setVisible(true);\n    }\n}\n<\/code><\/pre>\n
In this example, we add a ListSelectionListener<\/code> to the table’s selection model. When the user selects a row, the valueChanged<\/code> method is called, and we print out the selected row and its data.<\/p>\n
Cell Editing<\/h4>\n
By default, cells in a JTable<\/code> are editable. However, you can control the editing behavior by implementing a custom TableModel<\/code> or by using the isCellEditable<\/code> method of the TableModel<\/code>.<\/p>\n
import javax.swing.JFrame;\nimport javax.swing.JTable;\nimport javax.swing.table.DefaultTableModel;\n\nclass CustomTableModel extends DefaultTableModel {\n    public CustomTableModel(Object[][] data, String[] columnNames) {\n        super(data, columnNames);\n    }\n\n    @Override\n    public boolean isCellEditable(int row, int column) {\n        \/\/ Make only the "Age" column editable\n        return column == 1;\n    }\n}\n\npublic class CellEditingExample {\n    public static void main(String[] args) {\n        String[] columnNames = {"Name", "Age", "City"};\n        Object[][] data = {\n                {"John", 25, "New York"},\n                {"Jane", 30, "Los Angeles"},\n                {"Bob", 22, "Chicago"}\n        };\n        CustomTableModel model = new CustomTableModel(data, columnNames);\n        JTable table = new JTable(model);\n\n        JFrame frame = new JFrame("Cell Editing Example");\n        frame.add(table.getTableHeader(), java.awt.BorderLayout.NORTH);\n        frame.add(table, java.awt.BorderLayout.CENTER);\n        frame.setSize(400, 300);\n        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n        frame.setVisible(true);\n    }\n}\n<\/code><\/pre>\n
In this code, we create a custom TableModel<\/code> that overrides the isCellEditable<\/code> method. We make only the "Age" column editable.<\/p>\n
Column Sorting<\/h4>\n
JTable provides built – in support for column sorting. You can enable sorting by calling the setAutoCreateRowSorter<\/code> method on the table.<\/p>\n
import javax.swing.JFrame;\nimport javax.swing.JTable;\nimport javax.swing.table.DefaultTableModel;\n\npublic class ColumnSortingExample {\n    public static void main(String[] args) {\n        String[] columnNames = {"Name", "Age", "City"};\n        Object[][] data = {\n                {"John", 25, "New York"},\n                {"Jane", 30, "Los Angeles"},\n                {"Bob", 22, "Chicago"}\n        };\n        DefaultTableModel model = new DefaultTableModel(data, columnNames);\n        JTable table = new JTable(model);\n        table.setAutoCreateRowSorter(true);\n\n        JFrame frame = new JFrame("Column Sorting Example");\n        frame.add(table.getTableHeader(), java.awt.BorderLayout.NORTH);\n        frame.add(table, java.awt.BorderLayout.CENTER);\n        frame.setSize(400, 300);\n        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n        frame.setVisible(true);\n    }\n}\n<\/code><\/pre>\n
This code enables column sorting. Users can click on the column headers to sort the data in ascending or descending order.<\/p>\n
Working with Large Datasets<\/h3>\n
When dealing with large datasets, you may encounter performance issues if you load all the data into the DefaultTableModel<\/code> at once. A better approach is to use a custom TableModel<\/code> that loads data on – demand.<\/p>\n
import javax.swing.JFrame;\nimport javax.swing.JTable;\nimport javax.swing.table.AbstractTableModel;\n\nclass LargeDatasetTableModel extends AbstractTableModel {\n    private static final int ROW_COUNT = 10000;\n    private static final int COLUMN_COUNT = 5;\n\n    @Override\n    public int getRowCount() {\n        return ROW_COUNT;\n    }\n\n    @Override\n    public int getColumnCount() {\n        return COLUMN_COUNT;\n    }\n\n    @Override\n    public Object getValueAt(int rowIndex, int columnIndex) {\n        \/\/ Here you can implement logic to load data on - demand\n        return "Row " + rowIndex + ", Column " + columnIndex;\n    }\n\n    @Override\n    public String getColumnName(int column) {\n        return "Column " + column;\n    }\n}\n\npublic class LargeDatasetExample {\n    public static void main(String[] args) {\n        LargeDatasetTableModel model = new LargeDatasetTableModel();\n        JTable table = new JTable(model);\n\n        JFrame frame = new JFrame("Large Dataset Example");\n        frame.add(table.getTableHeader(), java.awt.BorderLayout.NORTH);\n        frame.add(table, java.awt.BorderLayout.CENTER);\n        frame.setSize(400, 300);\n        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);\n        frame.setVisible(true);\n    }\n}\n<\/code><\/pre>\n
In this example, we create a custom TableModel<\/code> that extends AbstractTableModel<\/code>. The getValueAt<\/code> method can be implemented to load data from a database or other data source on – demand, which helps to improve performance when dealing with large datasets.<\/p>\n
Conclusion<\/h3>\n
<\/p>\n
JTable is a powerful and flexible component in the Swing toolkit. By understanding its basic usage, customizing its appearance, handling user interaction, and working with large datasets, you can create sophisticated and user – friendly applications.<\/p>\n
Clothes Rack<\/a> As a Swing supplier, we have extensive experience in implementing JTable and other Swing components in various projects. Whether you need a simple table for displaying data or a complex, customized table with advanced features, we can provide the solutions you need. If you’re interested in learning more about our Swing – related services or have a project in mind, we invite you to contact us for a procurement discussion.<\/p>\n
References<\/h3>\n