本文链接: http://blog.csdn.net/xietansheng/article/details/72814531
Java Swing GUI 图形界面窗口开发基础教程，本教程将系统性地详细介绍 Java Swing 开发中常用的一些组件、布局管理器等相关知识技术，并且每章节都将通过代码实例展示实际应用。
教程总目录: Java Swing 图形界面开发（目录）
1. Swing简介
Swing 是 Java 为图形界面应用开发提供的一组工具包，是 Java 基础类的一部分。
Swing 包含了构建图形界面（GUI）的各种组件，如: 窗口、标签、按钮、文本框等。
Swing 提供了许多比 AWT 更好的屏幕显示元素，使用纯 Java 实现，能够更好的兼容跨平台运行。
为了和 AWT 组件区分，Swing 组件在javax.swing.*包下，类名均以 J 开头，例如: JFrame、JLabel、JButton等。
2. Swing组件
一个 Java 的图形界面，由各种不同类型的“元素”组成，例如: 窗口、菜单栏、对话框、标签、按钮、文本框等等，这些“元素”统一被称为 组件（Component）。
组件按照不同的功能，可分为 顶层容器、中间容器、基本组件。一个简单窗口的组成，如下层级结构所示:
顶层容器
菜单栏
中间容器
基本组件
基本组件


组件类型的继承关系:
顶层容器 属于窗口类组件，继承自java.awt.Window；
中间容器 和 基本组件 继承自javax.swing.JComponent。
2.1 顶层容器
顶层容器属于窗口类组件，可以独立显示，一个图形界面至少需要一个窗口，例如:

#
组件
描述
1
JFrame
一个普通的窗口（绝大多数 Swing 图形界面程序使用 JFrame 作为顶层容器）
2
JDialog
对话框
2.2 中间容器
中间容器充当基本组件的载体，不可独立显示。中间容器可以添加若干基本组件（也可以嵌套添加中间容器），对容器内的组件进行管理，类似于给各种复杂的组件进行分组管理。最顶层的一个中间容器必须依托在顶层容器（窗口）内。
常用的中间容器（面板）:

#
组件
描述
1
JPanel
一般轻量级面板容器组件
2
JScrollPane
带滚动条的，可以水平和垂直滚动的面板组件
3
JSplitPane
分隔面板
4
JTabbedPane
选项卡面板
5
JLayeredPane
层级面板
特殊的中间容器:

#
组件
描述
1
JMenuBar
菜单栏
2
JToolBar
工具栏
3
JPopupMenu
弹出菜单
4
JInternalFrame
内部窗口
2.3 基本组件
基本组件是直接实现人机交互的组件。
常用的简单的基本组件:

#
组件
描述
1
JLabel
标签
2
JButton
按钮
3
JRadioButton
单选按钮
4
JCheckBox
复选框
5
JToggleButton
开关按钮
6
JTextField
文本框
7
JPasswordField
密码框
8
JTextArea
文本区域
9
JComboBox
下拉列表框
10
JList
列表
11
JProgressBar
进度条
12
JSlider
滑块
选取器组件:

#
组件
描述
1
JFileChooser
文件选取器
2
JColorChooser
颜色选取器
其他较为复杂的基本组件:

#
组件
描述
1
JTable
表格
2
JTree
树
3. 布局管理器
把 Swing 的各种组件(JComponent)添加到面板容器中(JPanel)，需要给面板容器指定布局管理器(LayoutManager)，明确容器(Container)内的各个组件之间的排列布局方式。
常用的布局管理器:

#
布局管理器
描述
1
FlowLayout
流式布局，按组件加入的顺序，按水平方向排列，排满一行换下一行继续排列。
2
GridLayout
网格布局，把Container按指定行列数分隔出若干网格，每一个网格按顺序放置一个控件。
3
GridBagLayout
网格袋布局，按网格划分Container，每个组件可占用一个或多个网格，可将组件垂直、水平或沿它们的基线对齐。
4
BoxLayout
箱式布局，将Container中的多个组件按 水平 或 垂直 的方式排列。
5
GroupLayout
分组布局，将组件按层次分组（串行 或 并行），分别确定 组件组 在 水平 和 垂直 方向上的位置。
6
CardLayout
卡片布局，将Container中的每个组件看作一张卡片，一次只能显示一张卡片，默认显示第一张卡片。
7
BorderLayout
边界布局，把Container按方位分为 5 个区域（东、西、南、北、中），每个区域放置一个组件。
8
SpringLayout
弹性布局，通过定义组件四条边的坐标位置来实现布局。
9
null
绝对布局，通过设置组件在Container中的坐标位置来放置组件。
4. 代码实例: 一个简单的窗口程序
package com.xiets.swing;

import javax.swing.*;

public class Main {

    public static void main(String[] args) {
        // 1. 创建一个顶层容器（窗口）
        JFrame jf = new JFrame("测试窗口");          // 创建窗口
        jf.setSize(250, 250);                       // 设置窗口大小
        jf.setLocationRelativeTo(null);             // 把窗口位置设置到屏幕中心
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE); // 当点击窗口的关闭按钮时退出程序（没有这一句，程序不会退出）

        // 2. 创建中间容器（面板容器）
        JPanel panel = new JPanel();                // 创建面板容器，使用默认的布局管理器

        // 3. 创建一个基本组件（按钮），并添加到 面板容器 中
        JButton btn = new JButton("测试按钮");
        panel.add(btn);

        // 4. 把 面板容器 作为窗口的内容面板 设置到 窗口
        jf.setContentPane(panel);

        // 5. 显示窗口，前面创建的信息都在内存中，通过 jf.setVisible(true) 把内存中的窗口显示在屏幕上。
        jf.setVisible(true);
    }

}

结果展示:

本文链接: https://blog.csdn.net/xietansheng/article/details/72814492
0. JavaSwing 简介
Java Swing 图形界面开发简介
1. JavaSwing 布局管理器
JavaSwing_1.1: FlowLayout（流式布局）
JavaSwing_1.2: GridLayout（网格布局）
JavaSwing_1.3: GridBagLayout（网格袋布局）
JavaSwing_1.4: BoxLayout（箱式布局）
JavaSwing_1.5: GroupLayout（分组布局）
JavaSwing_1.6: CardLayout（卡片布局）
JavaSwing_1.7: BorderLayout（边界布局）
JavaSwing_1.8: SpringLayout（弹性布局）
JavaSwing_1.9: null（绝对布局）
2. JavaSwing 基本组件
JavaSwing_2.1: JLabel（标签）
JavaSwing_2.2: JButton（按钮）
JavaSwing_2.3: JRadioButton（单选按钮）
JavaSwing_2.4: JCheckBox（复选框）
JavaSwing_2.5: JToggleButton（开关按钮）
JavaSwing_2.6: JTextField（文本框）
JavaSwing_2.7: JPasswordField（密码框）
JavaSwing_2.8: JTextArea（文本区域）
JavaSwing_2.9: JComboBox（下拉列表框）
JavaSwing_2.10: JList（列表框）
JavaSwing_2.11: JProgressBar（进度条）
JavaSwing_2.12: JSlider（滑块）
3. JavaSwing 面板组件
JavaSwing_3.1: JPanel（面板）
JavaSwing_3.2: JScrollPane（滚动面板）
JavaSwing_3.3: JSplitPane（分隔面板）
JavaSwing_3.4: JTabbedPane（选项卡面板）
JavaSwing_3.5: JLayeredPane（层级面板）
4. JavaSwing 其他组件
JavaSwing_4.1: JFrame（窗口）
JavaSwing_4.2: JDialog、JOptionPane（对话框）
JavaSwing_4.3: JFileChooser（文件选择器）
JavaSwing_4.4: JColorChooser（颜色选择器）
JavaSwing_4.5: JMenuBar（菜单栏）
JavaSwing_4.6: JToolBar（工具栏）
JavaSwing_4.7: JPopupMenu（弹出菜单）
JavaSwing_4.8: JTable（表格）
JavaSwing_4.9: JTree（树）
JavaSwing_4.10: JInternalFrame（内部窗口）
5. JavaSwing 相关特性
JavaSwing_5.1: 组件的位置和尺寸
JavaSwing_5.2: 组件边框（Border）
JavaSwing_5.3: 事件处理
JavaSwing_5.4: 多线程并发与线程安全
JavaSwing_5.5: 拖拽功能
JavaSwing_5.6: 系统托盘（System Tray）
JavaSwing_5.7: 闪屏（Splash Screen）
扩展：Java AWT/Swing 其他相关
Java绘图: 使用Graphics类绘制线段、矩形、椭圆/圆弧/扇形、图片、文本
Java图片操作 — 图片的读取、绘制、缩放、裁剪、保存
Java代码截屏：使用 Java 代码截取电脑屏幕并保存
Java模拟鼠标键盘输入事件 — Robot 类
Java操作桌面应用 — Desktop 类
Java操作系统剪贴板(Clipboard)实现复制和粘贴

为什么需要Swing?

使用AWT已经能够实现图形界面，为什么还需要Swing?

AWT依赖本地系统支持，在不同的系统上，外观不同.
AWT只能实现所有平台上都有的组件，大大限制了AWT所支持的组件的数量.
Swing完全使用100%Java实现，组件全都使用Java绘制.
在不同的平台上用户体验完全相同.
可以控制所有组件的底层代码，甚至可以重写所有组件.
组件数量非常多，可以实现更多功能.
使用MVC设计模式，组件实现更加合理和易于维护.
组件本身功能也更加强大.
实际Java的GUI应用中，大多使用Swing，很少使用AWT.

虽然AWT在实际使用中很少使用，Swing和AWT还是存在着很大的关联.
大部分Swing组件(Jcomponent及其子类)都是AWT中Container类的子类
Swing为AWT中几乎所有的组件都提供了相对应的组件.(通常在你熟悉的AWT组件前面加上J就是对应的Swing组件)
Swing中可以使用AWT中的布局管理对界面进行布局管理
Swing中使用的时间处理方式和AWT中的事件处理方式相似

BoxLayout

出了AWT提供了Layout之外，Swing也提供了另外一种Layout.BoxLayout将组件放在单一的行或列中，和FlowLayout不同的是，它可以考虑到组件的对齐方式，最大，最小和最佳尺寸.

除此之外，开发者还可以下载第三方的Layout或者干脆自己继承Layout类设计和编写自己的Layout.



Swing基本组件

Swing为几乎所有的AWT组件提供了自己的实现，并且功能更加强大.
可以使用setToolTipText()方法为组件设置鼠标悬停提示.
大部分的Swing组件（按钮、标签、菜单项等），除了可以设置文字之外，还可以设置图标（ImageIcon类).
Swing组件可以设置一个或多个边框.其中空白边框可以用户增大组件之间的间隔，结合布局期使用往往会得到很好的效果.
Swing组件可以设置不同的外观。每一个JComponent类都有一个对应的ComponentUI类，它为这个Jcomponent类完成诸如绘制、事件处理、计算组件大小的任务.

Swing常见组件的分类

顶层容器：

JFrame、JApplet、JDialog和Jwindow

组件容器：

Jpanel、JScrollPane、JSplitPane、JToolBar…

特殊容器（一般不会手动创建和使用）：

JInternalFrame、JRootPane、JLayeredPane和JDesktopPane…

基本组件（实现主要的人机交互）：

JButton、JComboBox、JList、JMenu、JSlider…

不可编辑组件：

JLabel、JProgressBar和JToolTip。

可编辑组件：

JTextField、JTextArea、JTable等。

对话框组件：

JFileChooser、JcolorChooser等。

Swing组件的关系图



Swing菜单与工具栏

Swing菜单

菜单是基本的GUI组件。

Swing菜单主要涉及的类有：

JMenuBar：主菜单栏

JPopupMenu：邮件弹出式菜单

JMenu：菜单，其下可以添加菜单项

JMenuItem：菜单项，单击将触发某功能

JCheckBoxMenuItem：带有复选框的菜单项

JRadioButtonMenuItem：带有单选框的菜单项

Jseparator：菜单的项的分割符

Swing工具栏

工具栏是除了菜单之外另外一种非常常用的GUI组件。

Swing工具栏主要涉及的类有：

JToolBar：主工具栏容器，里面可放置各种按钮和组件

JToolTip：按钮提示

JButton：工具栏上的具体按钮，通过菜单栏的add(Action)方法创建

Swing对话框

JFileChooser

让用户选择一个已有的文件或者新建一个文件

可以使用JFileChooser的showDialog、showOpenDialog或showSaveDialog()方法来打开文件对话框，但是它仅仅会返回用户选择的按钮（确认还是取消）和文件名（如果确认的话），接下来的要实现的例如存盘或者打开的功能还需要程序员自己编写

这个类提供了专门的方法用于设置可选择的文件类型，还可以指定每类文件使用的类型图标



JColorChooser

可以让用户选择所需要的颜色

通常使用这个类的静态方法showDialog()来输出标准的颜色选择对话框，其返回值就是选择的颜色

也可以通过静态方法createDialog()方式输出个性化的颜色选择对话框，例如为其添加菜单、定义其事件处理程序，这个方法的返回值就是一个对话框



JOptionPane

如果要提示一些简单的信息，在AWT中，我们需要自己继承Dialog类，并添加相应的组件。

在javax.swing包内提供了JOptionPane来显示一些简单的提示信息，或是做一些简单的选择

通过使用这个类提供的一些静态方法show×××Dialog，就可以产生四种简单的对话框

这四种对话框(除了输入对话框可以不指定父窗口)都需要提供一个父窗口组件ParentComponent

指定了父窗口后，这些对话框自动成为模式对话框

Swing中的特殊容器

JSplitPane

可以把两个组件显示在两个显示区域内，且随着区域间分隔线的拖动，区域内组件的大小也随之发生变动

它允许设置水平分割或者垂直分割；也允许设置动态拖曳功能（拖动分界线时两边组件是否会随着拖曳动态改变大小还是在拖曳结束后才改动）

我们通常先把组件放到Scroll Pane中，再把Scroll Pane放到Split Pane中。这样在每部分窗口中，都可以拖动滚动条看到组件的全部内容

具体的API请查看API文档和教材。

JTabbedPane

Tab是一种常用的界面元素，可以节省界面空间，在同一个窗口上组织多项功能，也是微软新界面体系Ribbon的核心元素之一

在基于Tab的界面中，我们可以给每项设置一个标签，每个标签下面包含为完成此功能专用的若干组件

用户要使用哪项功能，只用点击相应的标签，就可以进入相应的页面

在AWT中，可以通过CardLayout和按钮结合的方式来实现。

由于基于Tab的界面现在非常流行，在Swing中，Java提供了一种专门的容器来实现Tab界面

JLayeredPane

有关层次的组件。

JDesktopPane与JInternalFrame

如果要实现在一个主窗口中打开很多个文档，每个文档各自占用一个新的窗口，就需要使用JInternalFrame容器类

JInternalFrame的使用跟JFrame几乎一样，可以最大化、最小化、关闭窗口、加入菜单

唯一不同的是JInternalFrame不是顶级容器，只能作为中间容器，必须依附于顶层容器上

通常我们会将JInernalFrame加入JDesktopPane类的对象来方便管理，JDesktopPane继承自JLayeredPane，用来建立虚拟桌面。它可以显示并管理众多JInternalFrame之间的层次关系

Swing中的数值调整组件

JProgressBar

在一些软件运行时，会出现一个进度条告知目前进度如何.通过使用该组件我们可以轻松地微软件嘉善一个进度条.

JSlider

一个可以让用户通过拖动控制杆选择一个介于最大和最小值之间的数值的组件.

适合用于控制不是很精确的场景.

在界面空间比较大的时候使用比较方便，若界面空间太小，则选择不精确.



JSpinner

用于精确选择数值的组件

类似于可编辑的JComboBox，是种复合组件，由三个部分组成：向上按钮、向下按钮和一个文本编辑区

可以通过按钮来选择待选项，也可以直接在文本编辑区内输入

适用于界面空间较小或者对选择的数值控制比较精确的场景



Swing中的列表组件

MVC

Model-View-Controller Pattern(模型-视图-控制器模式)，是一种常用的图形界面设计模式。

模型：图形界面系统中组件的内部数据表示。

视图：用于将组件的内部数据显示出来给用户看的类。

控制器：将模型和视图连接起来

控制用户界面上的事件

从视图上获取消息

将视图上的消息传递给模型

MVC的两种模式



JList

Swing的几乎所有组件都是根据MVC模式设计的

而JList才是使用MVC模式的经典例子。



构造函数：

public JList()

public JList(ListModel model)

public JList(Object[] data)

public JList(Vector data)

监听器：

public void addListSelectionListener( ListSelectionListener lsl)

DefaultListModel是ListModel的默认实现。



JList选择相关方法

public void clearSelection()

public int getSelectedIndex()

public int[] getSelectedIndices()

public Object getSelectedValue()

public Object[] getSelectedValues()
public void setSelectedIndex(int index)

public void setSelectedIndices(int[] indices)

public int getSelectionMode()

public void setSelectionMode(int mode)

ListSelectionModel.SINGLE_SELECTION

JComboBox

JComboxBox是下拉列表框。

和JList类似，JComboBox使用ComboBoxModel。

构造函数：

public JComboBox()

public JComboBox(Vector items)

public JComboBox(ComboBoxModel model)

监听器：

public void addActionListener(ActionListener al)



选择：

public int getSelectedIndex()

public Object getSelectedItem()

public void setSelectedItem(Object item)

public void setSelectedIndex(int index)

其他：

public void setEnabled(boolean enabled)

public void setEditable(boolean editable)

ListCellReader

ListCellRenderer用于将ListModel中的每一个数据项，渲染称为某种显示格式。

JList和JComboBox都可以使用ListCellRenderer来显示每一个列表项目。

默认的ListCellRenderer只是将ListModel中的数据显示成为一个简单的字符串。

如果需要显示格式更为复杂的列表项目，则可以自己继承并重写ListCellRenderer。

Swing中的树组件

树形结构

树形结构是一种常用的层次化显示组件。

Swing中使用JTree来表示树形结构。

JTree也完全遵循MVC模式。

低层使用TreeModel，并通过TreeCellRenderer来显示树形结构。

术语：

Root（根）

Parent（父）

Node（节点）

Branch（枝）



JTree和DefaultTreeModel

JTree用于将TreeModel中的数据以树形结构的形式显示在图形界面上。

DefaultTreeModel是一种简单的树形数据结构的实现。

DefaultTreeModel中包含有TreeNode，一般称为Root(根)

TreeNode又可以包含其他的TreeNode。

TreeModel的常用方法：

getChild(Object parent, int index)

getChildCount (Object parent)

getIndexOfChild(Object parent, Object child)

getRoot()

isLeaf(Object node)

创建JTree
DefaultMutableTreeNode root = new DefaultMutableTreeNode("Root");
treeModel = new DefaultTreeModel(root);
tree = new JTree(treeModel);

DefaultMutableTreeNode subroot = new DefaultMutableTreeNode("Subroot");
treeModel.insertNodeInto(subroot, root, 0);	

DefaultMutableTreeNode leaf1 = new DefaultMutableTreeNode("Leaf 1");	
treeModel.insertNodeInto(leaf1, subroot, 0);

DefaultMutableTreeNode leaf2 = new DefaultMutableTreeNode("Leaf 2"); 
treeModel.insertNodeInto(leaf2, root, 1); 


JTree的选择模式

JTree的选择模式，不能在JTree上直接设置，而需要在其TreeModel上设置：
tree.getSelectionModel().setSelectionMode (
	TreeSelectionModel.SINGLE_TREE_SELECTION);

JTree的选择模式：

SINGLE_TREE_SELECTION

DISCONTIGUOUS_TREE_SELECTION

CONTIGUOUS_TREE_SELECTION

监听节点事件

和其他组件一样，JTree使用监听器来监听事件

JTree的事件主要是节点被选中，使用以下方法来添加监听器：

tree.addTreeSelectionListener(TreeSelectionListener)

处理事件需要重写TreeSelectionListener中的valueChanged()方法
public void valueChanged(TreeSelectionEvent e) { 
	DefaultMutableTreeNode node = 					(DefaultMutableTreeNode)tree.getLastSelectedPathComponent(); 
}

扩展DefaultTreeCellRender

和JList一样，JTree可以通过扩展默认的TreeCellRenderer来改变树上每个节点的显示方法。

Swing中的文本组件

JTextField和JPasswordField

JTextField使用方法和AWT中TextField类似。

JPasswordField的使用和JTextField类似，但是用户的输入都以特殊符号替代，无法看出输入的字符。

可以使用以下方法来控制特殊字符：

setEchoChar(*);

JFormattedTextField

JFormattedTextField可以验证用户的输入是否合法。

主要构造函数：

JFormattedTextField(Format)

JFormattedTextField(Formatter)

Format:

DateFormat

MessageFormat

NumberFormat

当JFormattedTextField失去焦点的时候，Format将查看用户的输入，如果可以通过Format将用户的输入转换为特定的类型，则用户输入是合法的。

可以使用isEditValid()方法来获取用户刚刚输入是否合法。

本文链接: https://blog.csdn.net/xietansheng/article/details/78079806
Java Swing 图形界面开发（目录）
1. 概述
官方JavaDocsApi: javax.swing.JTable
JTable，表格。JTable 是用来显示和编辑常规二维单元表。
2. 创建简单的表格
package com.xiets.swing;

import javax.swing.*;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("测试窗口");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建内容面板，使用边界布局
        JPanel panel = new JPanel(new BorderLayout());

        // 表头（列名）
        Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};

        // 表格所有行数据
        Object[][] rowData = {
                {"张三", 80, 80, 80, 240},
                {"John", 70, 80, 90, 240},
                {"Sue", 70, 70, 70, 210},
                {"Jane", 80, 70, 60, 210},
                {"Joe", 80, 70, 60, 210}
        };

        // 创建一个表格，指定 所有行数据 和 表头
        JTable table = new JTable(rowData, columnNames);

        // 把 表头 添加到容器顶部（使用普通的中间容器添加表格时，表头 和 内容 需要分开添加）
        panel.add(table.getTableHeader(), BorderLayout.NORTH);
        // 把 表格内容 添加到容器中心
        panel.add(table, BorderLayout.CENTER);

        jf.setContentPane(panel);
        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

}

结果展示:

表格组件和其他普通组件一样，需要添加到中间容器中才能显示，添加表格到容器中有两种方式:
添加到普通的中间容器中（如上面代码实例所示的添加到JPanel），此时添加的jTable只是表格的行内容，表头(jTable.getTableHeader())需要额外单独添加。此添加方式适合表格行数确定，数据量较小，能一次性显示完的表格；
添加到JScrollPane滚动容器中，此添加方式不需要额外添加表头，jTable添加到jScrollPane中后，表头自动添加到滚动容器的顶部，并支持行内容的滚动（滚动行内容时，表头会始终在顶部显示）。
3. JTable 常用的操作方法
JTable常用构造方法:
// 创建空表格，后续再添加相应数据
JTable() 

// 创建指定行列数的空表格，表头名称默认使用大写字母（A, B, C ...）依次表示
JTable(int numRows, int numColumns) 

// 创建表格，指定 表格行数据 和 表头名称
JTable(Object[][] rowData, Object[] columnNames)

// 使用表格模型创建表格
JTable(TableModel dm)

JTable 字体 和 网格 颜色设置:
// 设置内容字体
void setFont(Font font)

// 设置字体颜色
void setForeground(Color fg)

// 设置被选中的行前景（被选中时字体的颜色）
void setSelectionForeground(Color selectionForeground)

// 设置被选中的行背景
void setSelectionBackground(Color selectionBackground)

// 设置网格颜色
void setGridColor(Color gridColor)

// 设置是否显示网格
void setShowGrid(boolean showGrid)

// 水平方向网格线是否显示
void setShowHorizontalLines(boolean showHorizontalLines)

// 竖直方向网格线是否显示
void setShowVerticalLines(boolean showVerticalLines)

JTable 表头 设置:
// 获取表头
JTableHeader jTableHeader = jTable.getTableHeader();

// 设置表头名称字体样式
jTableHeader.setFont(Font font);

// 设置表头名称字体颜色
jTableHeader.setForeground(Color fg);

// 设置用户是否可以通过在头间拖动来调整各列的大小。
jTableHeader.setResizingAllowed(boolean resizingAllowed);

// 设置用户是否可以拖动列头，以重新排序各列。
jTableHeader.setReorderingAllowed(boolean reorderingAllowed);

JTable 行列 相关设置:
// 设置所有行的行高
void setRowHeight(int rowHeight)

// 设置指定行的行高
void setRowHeight(int row, int rowHeight)

/**
 * 设置当手动改变某列列宽时，其他列的列宽自动调整模式，可选值:
 *     JTable.AUTO_RESIZE_ALL_COLUMNS 在所有的调整大小操作中，按比例调整所有的列。
 *     JTable.AUTO_RESIZE_LAST_COLUMN 在所有的调整大小操作中，只对最后一列进行调整。
 *     JTable.AUTO_RESIZE_NEXT_COLUMN 在 UI 中调整了一个列时，对其下一列进行相反方向的调整。
 *     JTable.AUTO_RESIZE_OFF 不自动调整列的宽度；使用滚动条。
 *     JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS 在 UI 调整中，更改后续列以保持总宽度不变；此为默认行为。
 */
void setAutoResizeMode(int mode)

/*
 * 调整列宽
 */
// 先获取到某列
TableColumn tableColumn = jTable.getColumnModel().getColumn(int columnIndex);

// 设置列的宽度、首选宽度、最小宽度、最大宽度
tableColumn.setWidth(int width);
tableColumn.setPreferredWidth(int preferredWidth);
tableColumn.setMinWidth(int minWidth);
tableColumn.setMaxWidth(int maxWidth);

// 调整该列的列宽，以适合其标题单元格的宽度。
tableColumn.sizeWidthToFit();

// 是否允许手动改变该列的列宽
tableColumn.setResizable(boolean isResizable);

// 设置该列的表头名称
tableColumn.setHeaderValue(Object headerValue);

JTable 数据 相关操作:
/*
 * 表格数据的简单设置和获取
 */
// 设置表格中指定单元格的数据
jTable.getModel().setValueAt(Object aValue, int rowIndex, int columnIndex);

// 获取表格中指定单元格的数据
Object value = jTable.getModel().getValueAt(int rowIndex, int columnIndex);

4. 创建带滚动条的表格
创建带滚动条的表格基本步骤:
// 创建表格
JTable table = new JTable(...);

/* 设置表格相关数据 */

// 设置滚动面板视口大小（超过该大小的行数据，需要拖动滚动条才能看到）
table.setPreferredScrollableViewportSize(new Dimension(int width, int height));

// 创建滚动面板，把 表格 放到 滚动面板 中（表头将自动添加到滚动面板顶部）
JScrollPane scrollPane = new JScrollPane(table);

/* 再把滚动面板 scrollPane 添加到其他容器中显示 */

完整实例代码:
package com.xiets.swing;

import javax.swing.*;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("测试窗口");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建内容面板
        JPanel panel = new JPanel();

        // 表头（列名）
        String[] columnNames = {"序号", "姓名", "语文", "数学", "英语", "总分"};

        // 表格所有行数据
        Object[][] rowData = {
                {1, "张三", 80, 80, 80, 240},
                {2, "John", 70, 80, 90, 240},
                {3, "Sue", 70, 70, 70, 210},
                {4, "Jane", 80, 70, 60, 210},
                {5, "Joe_05", 80, 70, 60, 210},
                {6, "Joe_06", 80, 70, 60, 210},
                {7, "Joe_07", 80, 70, 60, 210},
                {8, "Joe_08", 80, 70, 60, 210},
                {9, "Joe_09", 80, 70, 60, 210},
                {10, "Joe_10", 80, 70, 60, 210},
                {11, "Joe_11", 80, 70, 60, 210},
                {12, "Joe_12", 80, 70, 60, 210},
                {13, "Joe_13", 80, 70, 60, 210},
                {14, "Joe_14", 80, 70, 60, 210},
                {15, "Joe_15", 80, 70, 60, 210},
                {16, "Joe_16", 80, 70, 60, 210},
                {17, "Joe_17", 80, 70, 60, 210},
                {18, "Joe_18", 80, 70, 60, 210},
                {19, "Joe_19", 80, 70, 60, 210},
                {20, "Joe_20", 80, 70, 60, 210}
        };

        // 创建一个表格，指定 表头 和 所有行数据
        JTable table = new JTable(rowData, columnNames);

        // 设置表格内容颜色
        table.setForeground(Color.BLACK);                   // 字体颜色
        table.setFont(new Font(null, Font.PLAIN, 14));      // 字体样式
        table.setSelectionForeground(Color.DARK_GRAY);      // 选中后字体颜色
        table.setSelectionBackground(Color.LIGHT_GRAY);     // 选中后字体背景
        table.setGridColor(Color.GRAY);                     // 网格颜色

        // 设置表头
        table.getTableHeader().setFont(new Font(null, Font.BOLD, 14));  // 设置表头名称字体样式
        table.getTableHeader().setForeground(Color.RED);                // 设置表头名称字体颜色
        table.getTableHeader().setResizingAllowed(false);               // 设置不允许手动改变列宽
        table.getTableHeader().setReorderingAllowed(false);             // 设置不允许拖动重新排序各列

        // 设置行高
        table.setRowHeight(30);

        // 第一列列宽设置为40
        table.getColumnModel().getColumn(0).setPreferredWidth(40);

        // 设置滚动面板视口大小（超过该大小的行数据，需要拖动滚动条才能看到）
        table.setPreferredScrollableViewportSize(new Dimension(400, 300));

        // 把 表格 放到 滚动面板 中（表头将自动添加到滚动面板顶部）
        JScrollPane scrollPane = new JScrollPane(table);

        // 添加 滚动面板 到 内容面板
        panel.add(scrollPane);

        // 设置 内容面板 到 窗口
        jf.setContentPane(panel);

        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

}

结果展示:

5. 表格模型（TableModel）
TableModel 接口指定了 JTable 用于询问表格式数据模型的方法。TableModel 封装了表格中的各种数据，为表格显示提供数据。上面案例中直接使用行数据和表头创建表格，实际上JTable 内部自动将传入的行数据和表头封装成了 TableModel。
只要数据模型实现了 TableModel 接口，就可以通过以下两行代码设置 JTable 显示该模型:
TableModel myData = new MyTableModel(); 
JTable table = new JTable(myData);

TableModel 接口中的方法:
package javax.swing.table;

import javax.swing.*;
import javax.swing.event.*;

public interface TableModel {
    /** 返回总行数 */
    public int getRowCount();

    /** 返回总列数 */
    public int getColumnCount();

    /** 返回指定列的名称（表头名称） */
    public String getColumnName(int columnIndex);

    /** 针对列中所有的单元格值，返回最具体的超类。JTable 使用此方法来设置列的默认渲染器和编辑器。 */
    public Class<?> getColumnClass(int columnIndex);

    /** 判断指定单元格是否可编辑 */
    public boolean isCellEditable(int rowIndex, int columnIndex);

    /** 获取指定单元格的值 */
    public Object getValueAt(int rowIndex, int columnIndex);

    /** 设置指定单元格的值 */
    public void setValueAt(Object aValue, int rowIndex, int columnIndex);

    /** 添加表格模型监听器 */
    public void addTableModelListener(TableModelListener l);

    /** 移除表格模型监听器 */
    public void removeTableModelListener(TableModelListener l);
}

JRE 中常用的已实现 TableModel 接口的类有两个:
（1）javax.swing.table.AbstractTableModel
此抽象类为 TableModel 接口中的大多数方法提供默认实现。它负责管理侦听器，并为生成 TableModelEvents 以及将其调度到侦听器提供方便。要创建一个具体的 TableModel 作为 AbstractTableModel 的子类，只需提供对以下三个方法的实现：
public int getRowCount();
public int getColumnCount();
public Object getValueAt(int row, int column);

（2）javax.swing.table.DefaultTableModel
这是 TableModel 的一个实现，它使用一个 Vector 来存储单元格的值对象，该 Vector 由多个 Vector 组成。DefaultTableModel 还增加了许多方便操作表格数据的方法，例如 支持 添加 和 删除 行列 等操作。
下面使用 AbstractTableModel 创建一个表格:
package com.xiets.swing;

import javax.swing.*;
import javax.swing.table.AbstractTableModel;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("测试窗口");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建内容面板，使用边界布局
        JPanel panel = new JPanel(new BorderLayout());

        // 使用表格模型创建一个表格
        JTable table = new JTable(new MyTableModel());

        // 把 表头 添加到容器顶部（使用普通的中间容器添加表格时，表头 和 内容 需要分开添加）
        panel.add(table.getTableHeader(), BorderLayout.NORTH);
        // 把 表格内容 添加到容器中心
        panel.add(table, BorderLayout.CENTER);

        jf.setContentPane(panel);
        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

    /**
     * 表格模型实现，表格显示数据时将调用模型中的相应方法获取数据进行表格内容的显示
     */
    public static class MyTableModel extends AbstractTableModel {
        /**
         * 表头（列名）
         */
        private Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};

        /**
         * 表格所有行数据
         */
        private Object[][] rowData = {
                {"张三", 80, 80, 80, 240},
                {"John", 70, 80, 90, 240},
                {"Sue", 70, 70, 70, 210},
                {"Jane", 80, 70, 60, 210},
                {"Joe", 80, 70, 60, 210}
        };

        /**
         * 返回总行数
         */
        @Override
        public int getRowCount() {
            return rowData.length;
        }

        /**
         * 返回总列数
         */
        @Override
        public int getColumnCount() {
            return columnNames.length;
        }

        /**
         * 返回列名称（表头名称），AbstractTableModel 中对该方法的实现默认是以
         * 大写字母 A 开始作为列名显示，所以这里需要重写该方法返回我们需要的列名。
         */
        @Override
        public String getColumnName(int column) {
            return columnNames[column].toString();
        }

        /**
         * 返回指定单元格的显示的值
         */
        @Override
        public Object getValueAt(int rowIndex, int columnIndex) {
            return rowData[rowIndex][columnIndex];
        }
    }

}

结果展示:

用鼠标点击相应的单元格，会发现单元格不可编辑，因为 AbstractTableModel 中对 isCellEditable(…) 方法的实现是返回 false，即单元格不可编辑。如果某些单元格需要支持编辑，可以重写 isCellEditable(…) 方法针对相应的单元格返回 true 即可。
6. 表格数据改变的监听（TableModelListener）
表格的数据维护，对数据的监听，都是由 表格模型（TableModel）来维护，通过设置表格模型监听器（TableModelListener），可以监听表格单元格数据的更改，表格行列的增加和移除。
设置表格模型监听器主要代码:
// 先获取 表格模型 对象
TableModel tableModel = table.getModel();

// 在 表格模型上 添加 数据改变监听器
tableModel.addTableModelListener(new TableModelListener() {
    @Override
    public void tableChanged(TableModelEvent e) {
        // 第一个 和 最后一个 被改变的行（只改变了一行，则两者相同）
        int firstRow = e.getFirstRow();
        int lastRow = e.getLastRow();

        // 被改变的列
        int column = e.getColumn();

        // 事件的类型，可能的值有:
        //     TableModelEvent.INSERT   新行或新列的添加
        //     TableModelEvent.UPDATE   现有数据的更改
        //     TableModelEvent.DELETE   有行或列被移除
        int type = e.getType();
    }
});

代码实例:
package com.xiets.swing;

import javax.swing.*;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("测试窗口");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建内容面板，使用边界布局
        JPanel panel = new JPanel(new BorderLayout());

        // 表头（列名）
        final Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};

        // 表格所有行数据
        final Object[][] rowData = {
                {"张三", 80, 80, 80, 240},
                {"John", 70, 80, 90, 240},
                {"Sue", 70, 70, 70, 210},
                {"Jane", 80, 70, 60, 210},
                {"Joe", 80, 70, 60, 210}
        };

        // 自定义表格模型，创建一个表格
        JTable table = new JTable(new AbstractTableModel() {
            @Override
            public int getRowCount() {
                return rowData.length;
            }

            @Override
            public int getColumnCount() {
                return rowData[0].length;
            }

            @Override
            public String getColumnName(int column) {
                return columnNames[column].toString();
            }

            @Override
            public boolean isCellEditable(int rowIndex, int columnIndex) {
                // 总分列的索引为 4，总分列不允许编辑，其他列允许编辑，
                // 总分列的数值由 语文、数学、英语 这三列的值相加得出，并同步更新
                return columnIndex != 4;
            }

            @Override
            public Object getValueAt(int rowIndex, int columnIndex) {
                return rowData[rowIndex][columnIndex];
            }

            @Override
            public void setValueAt(Object newValue, int rowIndex, int columnIndex) {
                // 设置新的单元格数据时，必须把新值设置到原数据数值中，
                // 待更新UI重新调用 getValueAt(...) 获取单元格值时才能获取到最新值
                rowData[rowIndex][columnIndex] = newValue;
                // 设置完数据后，必须通知表格去更新UI（重绘单元格），否则显示的数据不会改变
                fireTableCellUpdated(rowIndex, columnIndex);
            }
        });

        /*
         * 上面的继承 AbstractTableModel 实现自定义表格模型，功能并不完整，还有很多需要自己
         * 去实现（例如更新数据，通知UI更新，列名称获取等），建议使用 DefaultTableModel 类，
         * 该类对 TableModel 做了较为完善的实现，支持自动更新数据处理，支持UI自动更新，列名称
         * 处理，添加/移除行列等。无特殊要求不需要重写方法，直接使用即可，如下两行代码即可:
         */
        // DefaultTableModel tableModel = new DefaultTableModel(rowData, columnNames);
        // JTable table = new JTable(tableModel);

        // 获取 表格模型
        final TableModel tableModel = table.getModel();
        // 在 表格模型上 添加 数据改变监听器
        tableModel.addTableModelListener(new TableModelListener() {
            @Override
            public void tableChanged(TableModelEvent e) {
                // 获取 第一个 和 最后一个 被改变的行（只改变了一行，则两者相同）
                int firstRow = e.getFirstRow();
                int lastRow = e.getLastRow();

                // 获取被改变的列
                int column = e.getColumn();

                // 事件的类型，可能的值有:
                //     TableModelEvent.INSERT   新行或新列的添加
                //     TableModelEvent.UPDATE   现有数据的更改
                //     TableModelEvent.DELETE   有行或列被移除
                int type = e.getType();

                // 针对 现有数据的更改 更新其他单元格数据
                if (type == TableModelEvent.UPDATE) {
                    // 只处理 语文、数学、英语 这三列（索引分别为1、2、3）的分数的更改
                    if (column < 1 || column > 3) {
                        return;
                    }
                    // 遍历每一个修改的行，单个学科分数更改后同时更新总分数
                    for (int row = firstRow; row <= lastRow; row++) {
                        // 获取当前行的 语文、数学、英语 的值
                        Object chineseObj = tableModel.getValueAt(row, 1);
                        Object mathObj = tableModel.getValueAt(row, 2);
                        Object englishObj = tableModel.getValueAt(row, 3);

                        // 把对象值转换为数值
                        int chinese = 0;
                        try {
                            chinese = Integer.parseInt("" + chineseObj);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                        int math = 0;
                        try {
                            math = Integer.parseInt("" + mathObj);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }
                        int english = 0;
                        try {
                            english = Integer.parseInt("" + englishObj);
                        } catch (Exception ex) {
                            ex.printStackTrace();
                        }

                        // 重新计算新的总分数
                        int totalScore = chinese + math + english;
                        // 将新的分数值设置到总分单元格（总分数的列索引为4）
                        tableModel.setValueAt(totalScore, row, 4);
                    }
                }
            }
        });

        // 把 表头 添加到容器顶部（使用普通的中间容器添加表格时，表头 和 内容 需要分开添加）
        panel.add(table.getTableHeader(), BorderLayout.NORTH);
        // 把 表格内容 添加到容器中心
        panel.add(table, BorderLayout.CENTER);

        jf.setContentPane(panel);
        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

}

结果展示，修改单科分数，按回车，看总分变化:

7. 表格选择器（ListSelectionModel）
表格数据的选择使用 ListSelectionModel 选择器模型维护，允许用户以不同的模式选中表格中的数据。
ListSelectionModel 的使用:
// 创建表格
final JTable table = new JTable(...);

// 设置是否允许单元格单个选中，默认为 false
table.setCellSelectionEnabled(boolean cellSelectionEnabled);

// 首先通过表格对象 table 获取选择器模型
ListSelectionModel selectionModel = table.getSelectionModel();

// 设置选择器模式，参数可能的值为:
//     ListSelectionModel.MULTIPLE_INTERVAL_SELECTION   一次选择一个或多个连续的索引范围（默认）
//     ListSelectionModel.SINGLE_INTERVAL_SELECTION     一次选择一个连续的索引范围
//     ListSelectionModel.SINGLE_SELECTION              一次只能选择一个列表索引
selectionModel.setSelectionMode(int selectionMode);

// 添加选择模型监听器（选中状态改变时回调）
selectionModel.addListSelectionListener(new ListSelectionListener() {
    @Override
    public void valueChanged(ListSelectionEvent e) {
        // 获取选中的第一行
        int selectedRow = table.getSelectedRow();
        
        // 获取选中的第一列
        int selectedRow = table.getSelectedColumn();        
        
        // 获取选中的所有行
        int[] selectedRows = table.getSelectedRows();
        
        // 获取选中的所有列
        int[] selectedColumns = table.getSelectedColumns();
    }
});

8. 单元格的渲染器（TableCellRenderer）
单元格渲染器用于指定每一个单元格的显示样式。
下面代码实例实现表格的 偶数行背景设置为白色，奇数行背景设置为灰色，第一列的内容水平居中对齐，最后一列的内容水平右对齐，其他列的内容水平左对齐。
package com.xiets.swing;

import javax.swing.*;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableColumn;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("测试窗口");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建内容面板，使用边界布局
        JPanel panel = new JPanel(new BorderLayout());

        // 表头（列名）
        Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};

        // 表格所有行数据
        Object[][] rowData = {
                {"张三", 80, 80, 80, 240},
                {"John", 70, 80, 90, 240},
                {"Sue", 70, 70, 70, 210},
                {"Jane", 80, 70, 60, 210},
                {"Joe_01", 80, 70, 60, 210},
                {"Joe_02", 80, 70, 60, 210},
                {"Joe_03", 80, 70, 60, 210},
                {"Joe_04", 80, 70, 60, 210},
                {"Joe_05", 80, 70, 60, 210}
        };

        // 创建一个表格，指定 所有行数据 和 表头
        JTable table = new JTable(rowData, columnNames);

        // 创建单元格渲染器
        MyTableCellRenderer renderer = new MyTableCellRenderer();

        // 遍历表格的每一列，分别给每一列设置单元格渲染器
        for (int i = 0; i < columnNames.length; i++) {
            // 根据 列名 获取 表格列
            TableColumn tableColumn = table.getColumn(columnNames[i]);
            // 设置 表格列 的 单元格渲染器
            tableColumn.setCellRenderer(renderer);
        }

        // 如果需要自定义表头样式，也可以给表头设置一个自定义渲染器
        // table.getTableHeader().setDefaultRenderer(headerRenderer);

        // 把 表头 添加到容器顶部（使用普通的中间容器添加表格时，表头 和 内容 需要分开添加）
        panel.add(table.getTableHeader(), BorderLayout.NORTH);
        // 把 表格内容 添加到容器中心
        panel.add(table, BorderLayout.CENTER);

        jf.setContentPane(panel);
        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

    /**
     * 单元格渲染器，继承已实现渲染器接口的默认渲染器 DefaultTableCellRenderer
     */
    public static class MyTableCellRenderer extends DefaultTableCellRenderer {
        /**
         * 返回默认的表单元格渲染器，此方法在父类中已实现，直接调用父类方法返回，在返回前做相关参数的设置即可
         */
        @Override
        public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
            // 偶数行背景设置为白色，奇数行背景设置为灰色
            if (row % 2 == 0) {
                setBackground(Color.WHITE);
            } else {
                setBackground(Color.LIGHT_GRAY);
            }

            // 第一列的内容水平居中对齐，最后一列的内容水平右对齐，其他列的内容水平左对齐
            if (column == 0) {
                setHorizontalAlignment(SwingConstants.CENTER);
            } else if (column == (table.getColumnCount() - 1)) {
                setHorizontalAlignment(SwingConstants.RIGHT);
            } else {
                setHorizontalAlignment(SwingConstants.LEFT);
            }
            
            // 设置提示文本，当鼠标移动到当前(row, column)所在单元格时显示的提示文本
            setToolTipText("提示的内容: " + row + ", " + column);

            // PS: 多个单元格使用同一渲染器时，需要自定义的属性，必须每次都设置，否则将自动沿用上一次的设置。

            /*
             * 单元格渲染器为表格单元格提供具体的显示，实现了单元格渲染器的 DefaultTableCellRenderer 继承自
             * 一个标准的组件类 JLabel，因此 JLabel 中相应的 API 在该渲染器实现类中都可以使用。
             *
             * super.getTableCellRendererComponent(...) 返回的实际上是当前对象（this），即 JLabel 实例，
             * 也就是以 JLabel 的形式显示单元格。
             *
             * 如果需要自定义单元格的显示形式（比如显示成按钮、复选框、内嵌表格等），可以在此自己创建一个标准组件
             * 实例返回。
             */

            // 调用父类的该方法完成渲染器的其他设置
            return super.getTableCellRendererComponent(table, value, isSelected, hasFocus, row, column);
        }
    }

}

结果展示:

9. 单元格数据的编辑器（TableCellEditor）
渲染器是用于正常显示单元格数据时提供显示组件，编辑器则是用于编辑单元格数据时显示(使用)的组件。
使用编辑器，可控制单元格内输入的内容格式，监听输入的内容变化等。
常用的编辑组件为 JTextField(文本框)，也可使用 JCheckBox(复选框)、JComboBox(文本框) 等组件作为编辑组件。
编辑器接口为TableCellEditor，只有一个方法，即为指定的单元格提供一个编辑组件。实际使用时通常使用已实现了该接口的默认编辑器DefaultCellEditor。
下面代码使用 DefaultCellEditor 作为基类自定义一个只能输入数字的编辑器:
package com.xiets.swing;

import javax.swing.*;
import javax.swing.table.TableColumn;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("测试窗口");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建内容面板，使用边界布局
        JPanel panel = new JPanel(new BorderLayout());

        // 表头（列名）
        Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};

        // 表格所有行数据
        Object[][] rowData = {
                {"张三", 80, 80, 80, 240},
                {"John", 70, 80, 90, 240},
                {"Sue", 70, 70, 70, 210},
                {"Jane", 80, 70, 60, 210},
                {"Joe", 80, 70, 60, 210}
        };

        // 创建一个表格，指定 所有行数据 和 表头
        JTable table = new JTable(rowData, columnNames);

        // 创建单元格编辑器，使用文本框作为编辑组件
        MyCellEditor cellEditor = new MyCellEditor(new JTextField());

        // 遍历表格中所有数字列，并设置列单元格的编辑器
        for (int i = 1; i < columnNames.length; i++) {
            // 根据 列名 获取 表格列
            TableColumn tableColumn = table.getColumn(columnNames[i]);
            // 设置 表格列 的 单元格编辑器
            tableColumn.setCellEditor(cellEditor);
        }

        // 把 表头 添加到容器顶部（使用普通的中间容器添加表格时，表头 和 内容 需要分开添加）
        panel.add(table.getTableHeader(), BorderLayout.NORTH);
        // 把 表格内容 添加到容器中心
        panel.add(table, BorderLayout.CENTER);

        jf.setContentPane(panel);
        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

    /**
     * 只允许输入数字的单元格编辑器
     */
    public static class MyCellEditor extends DefaultCellEditor {

        public MyCellEditor(JTextField textField) {
            super(textField);
        }

        public MyCellEditor(JCheckBox checkBox) {
            super(checkBox);
        }

        public MyCellEditor(JComboBox comboBox) {
            super(comboBox);
        }

        @Override
        public boolean stopCellEditing() {
            // 获取当前单元格的编辑器组件
            Component comp = getComponent();

            // 获取当前单元格编辑器输入的值
            Object obj = getCellEditorValue();

            // 如果当前单元格编辑器输入的值不是数字，则返回 false（表示数据非法，不允许设置，无法保存）
            if (obj == null || !obj.toString().matches("[0-9]*")) {
                // 数据非法时，设置编辑器组件内的内容颜色为红色
                comp.setForeground(Color.RED);
                return false;
            }

            // 数据合法时，设置编辑器组件内的内容颜色为黑色
            comp.setForeground(Color.BLACK);

            // 合法数据交给父类处理
            return super.stopCellEditing();
        }
    }

}

结果展示:

10. 表格数据的排序（RowSorter）
JTable 还支持单击表头按该列进行升序或降序的排序，只需要给表格设置一个表格行排序器TableRowSorter（按字典顺序排序）。
代码实例:
package com.xiets.swing;

import javax.swing.*;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;
import java.awt.*;

public class Main {

    public static void main(String[] args) {
        JFrame jf = new JFrame("测试窗口");
        jf.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // 创建内容面板，使用边界布局
        JPanel panel = new JPanel(new BorderLayout());

        // 表头（列名）
        Object[] columnNames = {"姓名", "语文", "数学", "英语", "总分"};

        // 表格所有行数据
        Object[][] rowData = {
                {"张三", 80, 80, 80, 240},
                {"John", 70, 80, 90, 240},
                {"Sue", 70, 70, 70, 210},
                {"Jane", 80, 70, 60, 210},
                {"Joe", 80, 70, 60, 210}
        };

        // 创建 表格模型，指定 所有行数据 和 表头
        TableModel tableModel = new DefaultTableModel(rowData, columnNames);

        // 使用 表格模型 创建 表格
        JTable table = new JTable(tableModel);

        // 使用 表格模型 创建 行排序器（TableRowSorter 实现了 RowSorter）
        RowSorter<TableModel> rowSorter = new TableRowSorter<TableModel>(tableModel);

        // 给 表格 设置 行排序器
        table.setRowSorter(rowSorter);

        // 把 表头 添加到容器顶部（使用普通的中间容器添加表格时，表头 和 内容 需要分开添加）
        panel.add(table.getTableHeader(), BorderLayout.NORTH);
        // 把 表格内容 添加到容器中心
        panel.add(table, BorderLayout.CENTER);

        jf.setContentPane(panel);
        jf.pack();
        jf.setLocationRelativeTo(null);
        jf.setVisible(true);
    }

}

结果展示: