模块 java.desktop
包 javax.swing

类 JTable

java.lang.Object
java.awt.Component
java.awt.Container
javax.swing.JComponent
javax.swing.JTable
所有已实现的接口：
ImageObserver , MenuContainer , Serializable , EventListener , Accessible , CellEditorListener , ListSelectionListener , RowSorterListener , TableColumnModelListener , TableModelListener , Scrollable
@JavaBean (defaultProperty ="UI", description ="A component which displays data in a two dimensional grid.") public class JTable extends JComponent implements TableModelListener , Scrollable , TableColumnModelListener , ListSelectionListener , CellEditorListener , Accessible , RowSorterListener
JTable 用于显示和编辑常规的二维单元格表。有关面向任务的文档和使用 JTable 的示例，请参阅 The Java Tutorial 中的 如何使用表格。

JTable 具有许多功能，可以自定义其呈现和编辑，但为这些功能提供默认值，以便可以轻松设置简单的表格。例如，要设置一个包含 10 行 10 列数字的表格：

   TableModel dataModel = new AbstractTableModel() {
     public int getColumnCount() { return 10; }
     public int getRowCount() { return 10;}
     public Object getValueAt(int row, int col) { return Integer.valueOf(row*col); }
   };
   JTable table = new JTable(dataModel);
   JScrollPane scrollpane = new JScrollPane(table);

JTable s 通常放在 JScrollPane 内。默认情况下，JTable 会调整其宽度，这样就不需要水平滚动条了。要允许水平滚动条，请使用 AUTO_RESIZE_OFF 调用 setAutoResizeMode(int) 。请注意，如果您希望在独立视图（在 JScrollPane 之外）中使用 JTable 并希望显示标题，您可以使用 getTableHeader() 获取它并单独显示它。

要启用行的排序和过滤，请使用 RowSorter 。您可以通过以下两种方式之一设置行排序器：

  • 直接设置 RowSorter 。例如：table.setRowSorter(new TableRowSorter(model))。
  • 将 autoCreateRowSorter 属性设置为 true ，以便 JTable 为您创建一个 RowSorter。例如：setAutoCreateRowSorter(true)。

在设计使用 JTable 的应用程序时，值得密切注意表示表数据的数据结构。 DefaultTableModel 是一个模型实现，它使用 Vector of Vector s of Object s 来存储单元格值。除了将数据从应用程序复制到 DefaultTableModel 外，还可以将数据包装在 TableModel 接口的方法中，以便数据可以直接传递给 JTable，如上例所示。这通常会导致更高效的应用程序，因为模型可以自由选择最适合数据的内部表示。决定是使用 AbstractTableModel 还是 DefaultTableModel 的一个好的经验法则是使用 AbstractTableModel 作为创建子类的基类，当不需要子类化时使用 DefaultTableModel。

源代码分发演示区中的“TableExample”目录提供了一些JTable用法的完整示例，包括如何使用JTable提供从数据库中获取的数据的可编辑视图以及如何修改显示中的列使用专门的渲染器和编辑器。

JTable 专门使用整数来指代它显示的模型的行和列。 JTable 只是采用表格单元格范围，并使用 getValueAt(int, int) 在绘画期间从模型中检索值。重要的是要记住，各种 JTable 方法返回的列和行索引是根据 JTable（视图）的，不一定与模型使用的索引相同。

默认情况下，JTable 中的列可能会重新排列，以便视图的列以与模型中的列不同的顺序出现。这根本不会影响模型的实现：当列重新排序时，JTable 在内部维护列的新顺序并在查询模型之前转换其列索引。

因此，在编写 TableModel 时，无需监听列重新排序事件，因为无论视图中发生什么，模型都将在其自己的坐标系中查询。在示例区域中，有一个排序算法的演示，它正是利用这种技术来插入另一个坐标系，其中行的顺序发生了变化，而不是列的顺序。

同样，当使用 RowSorter 提供的排序和过滤功能时，底层 TableModel 不需要知道如何进行排序，而 RowSorter 会处理它。当将 JTable 的基于行的方法与底层 TableModel 一起使用时，坐标转换将是必要的。所有 JTable 的基于行的方法都是根据 RowSorter 的，这不一定与底层的 TableModel 的方法相同。例如，选择始终根据 JTable 进行，因此在使用 RowSorter 时，您需要使用 convertRowIndexToView 或 convertRowIndexToModel 进行转换。下面显示了如何将坐标从 JTable 转换为基础模型的坐标：

  int[] selection = table.getSelectedRows();
  for (int i = 0; i < selection.length; i++) {
   selection[i] = table.convertRowIndexToModel(selection[i]);
  }
  // selection is now in terms of the underlying TableModel

默认情况下，如果启用排序，JTable 将根据排序模型保留选择和可变行高。例如，如果当前选择了就基础模型而言的第 0 行，则在排序后将选择就基础模型而言的第 0 行。视觉上的选择可能会改变，但就底层模型而言，它将保持不变。一个例外是模型索引不再可见或已被删除。例如，如果根据模型过滤掉第 0 行，则选择在排序后将为空。

J2SE 5 向JTable 添加方法以提供对一些常见打印需求的便捷访问。简单的新 print() 方法允许快速轻松地为您的应用程序添加打印支持。此外，新的 getPrintable(javax.swing.JTable.PrintMode, java.text.MessageFormat, java.text.MessageFormat) 方法可用于更高级的打印需求。

对于所有JComponent类，您可以使用InputMap 和ActionMap 将Action 对象与KeyStroke 相关联，并在指定条件下执行操作。

Warning: Swing 不是线程安全的。有关详细信息，请参阅 Swing 的线程策略。

Warning: 此类的序列化对象将与未来的 Swing 版本不兼容。当前的序列化支持适用于运行相同版本 Swing 的应用程序之间的短期存储或 RMI。从 1.4 开始，对所有 JavaBeans 的长期存储的支持已添加到 java.beans 包中。请参阅 XMLEncoder 。

自从：
1.2
参见：

  • 字段详细信息

    • AUTO_RESIZE_OFF

      public static final int AUTO_RESIZE_OFF
      不要自动调整列宽；改用水平滚动条。
      参见：

    • AUTO_RESIZE_NEXT_COLUMN

      public static final int AUTO_RESIZE_NEXT_COLUMN
      当在 UI 中调整一列时，以相反的方式调整下一列。
      参见：

    • AUTO_RESIZE_SUBSEQUENT_COLUMNS

      public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS
      UI调整时，更改后续列以保持总宽度；这是默认行为。
      参见：

    • AUTO_RESIZE_LAST_COLUMN

      public static final int AUTO_RESIZE_LAST_COLUMN
      在所有调整大小操作期间，仅对最后一列应用调整。
      参见：

    • AUTO_RESIZE_ALL_COLUMNS

      public static final int AUTO_RESIZE_ALL_COLUMNS
      在所有调整大小操作期间，按比例调整所有列的大小。
      参见：

    • dataModel

      protected TableModel  dataModel
      表的TableModel。

    • columnModel

      protected TableColumnModel  columnModel
      表的TableColumnModel。

    • selectionModel

      protected ListSelectionModel  selectionModel
      表的 ListSelectionModel，用于跟踪行选择。

    • tableHeader

      protected JTableHeader  tableHeader
      TableHeader 使用表。

    • rowHeight

      protected int rowHeight
      表中每行的高度（以像素为单位）。

    • rowMargin

      protected int rowMargin
      每行中单元格之间的边距高度（以像素为单位）。

    • gridColor

      protected Color  gridColor
      网格的颜色。

    • showHorizontalLines

      protected boolean showHorizontalLines
      如果 showHorizontalLines 为真，表格将在单元格之间绘制水平线。

    • showVerticalLines

      protected boolean showVerticalLines
      如果 showVerticalLines 为真，则表格在单元格之间绘制垂直线。

    • autoResizeMode

      protected int autoResizeMode
      确定表格是否自动调整表格列的宽度以占据表格的整个宽度，以及它如何调整大小。

    • autoCreateColumnsFromModel

      protected boolean autoCreateColumnsFromModel
      如果为真，该表将查询 TableModel 以构建默认的列集。

    • preferredViewportSize

      protected Dimension  preferredViewportSize
      由 Scrollable 接口用于确定初始可见区域。

    • rowSelectionAllowed

      protected boolean rowSelectionAllowed
      如果此表中允许行选择，则为真。

    • cellSelectionEnabled

      protected boolean cellSelectionEnabled
      自 Java 2 平台 v1.3 起已过时。请改用 columnModel 的 rowSelectionAllowed 属性和 columnSelectionAllowed 属性。或者使用方法 getCellSelectionEnabled 。

    • editorComp

      protected transient Component  editorComp
      如果正在编辑，则为处理编辑的 Component。

    • cellEditor

      protected transient TableCellEditor  cellEditor
      活动单元格编辑器对象，覆盖当前单元格占用的屏幕空间并允许用户更改其内容。 null 如果表当前未在编辑中。

    • editingColumn

      protected transient int editingColumn
      标识正在编辑的单元格的列。

    • editingRow

      protected transient int editingRow
      标识正在编辑的单元格的行。

    • defaultRenderersByColumnClass

      protected transient Hashtable <Object ,Object > defaultRenderersByColumnClass
      显示单元格内容的对象表，按 getColumnClass 接口中的 getColumnClass 声明的类索引。

    • defaultEditorsByColumnClass

      protected transient Hashtable <Object ,Object > defaultEditorsByColumnClass
      显示和编辑单元格内容的对象表，按 getColumnClass 接口中的 getColumnClass 声明的类索引。

    • selectionForeground

      protected Color  selectionForeground
      所选单元格的前景色。

    • selectionBackground

      protected Color  selectionBackground
      所选单元格的背景颜色。

  • 构造方法详细信息

    • JTable

      public JTable()
      构造一个默认的 JTable，它使用默认数据模型、默认列模型和默认选择模型进行初始化。
      参见：

    • JTable

      public JTable(TableModel  dm)
      构造一个 JTable，它使用 dm 作为数据模型、默认列模型和默认选择模型进行初始化。
      参数：
      dm - 表的数据模型
      参见：

    • JTable

      public JTable(TableModel  dm, TableColumnModel  cm)
      构造一个以dm作为数据模型、cm作为列模型和默认选择模型初始化的JTable。
      参数：
      dm - 表的数据模型
      cm - 表的列模型
      参见：

    • JTable

      public JTable(TableModel  dm, TableColumnModel  cm, ListSelectionModel  sm)
      构造一个以dm作为数据模型、cm作为列模型、sm作为选择模型初始化的JTable。如果任何参数是null，此方法将使用相应的默认模型初始化表。如果 cm 不为空，则 autoCreateColumnsFromModel 标志设置为 false，否则设置为 true 并且列模型为 dm 中的列填充合适的 TableColumns。
      参数：
      dm - 表的数据模型
      cm - 表的列模型
      sm - 表的行选择模型
      参见：

    • JTable

      public JTable(int numRows, int numColumns)
      使用 DefaultTableModel 构造一个带有 numRows 和 numColumns 空单元格的 JTable。这些列的名称将采用“A”、“B”、“C”等形式。
      参数：
      numRows - 表包含的行数
      numColumns - 表包含的列数
      参见：

    • JTable

      public JTable(Vector <? extends Vector > rowData, Vector <?> columnNames)
      构造一个 JTable 以显示 Vectors、rowData 的 Vector 中的值，列名称为 columnNames。 rowData 中包含的 Vectors 应包含该行的值。也就是说，第1行第5列单元格的值可以通过以下代码获取： 
      ((Vector)rowData.elementAt(1)).elementAt(5);
      参数：
      rowData - 新表的数据
      columnNames - 每列的名称

    • JTable

      public JTable(Object [][] rowData, Object [] columnNames)
      构造一个 JTable 以显示二维数组 rowData 中的值，列名称为 columnNames 。 rowData是一个行数组，所以第1行第5列的单元格的值可以用下面的代码得到： 
       rowData[1][5];

      所有行的长度必须与 columnNames 相同。

      参数：
      rowData - 新表的数据
      columnNames - 每列的名称

  • 方法详情

    • addNotify

      public void addNotify()
      调用 configureEnclosingScrollPane 方法。
      重写：
      addNotify 在类 JComponent 中
      参见：

    • configureEnclosingScrollPane

      protected void configureEnclosingScrollPane()
      如果这个 JTable 是一个封闭的 JScrollPane 的 viewportView（通常情况），配置这个 ScrollPane 除其他外，安装表的 tableHeader 作为滚动窗格的 columnHeaderView。当 JTable 以通常方式添加到 JScrollPane 时，使用 new JScrollPane(myTable) ，在 JTable 中调用 addNotify（当表添加到视口时）。 JTable 的 addNotify 方法依次调用此方法，该方法受到保护，因此此默认安装过程可以被子类覆盖。
      参见：

    • removeNotify

      public void removeNotify()
      调用 unconfigureEnclosingScrollPane 方法。
      重写：
      removeNotify 在类 JComponent 中
      参见：

    • unconfigureEnclosingScrollPane

      protected void unconfigureEnclosingScrollPane()
      通过将封闭滚动窗格的 columnHeaderView 替换为 null 来反转 configureEnclosingScrollPane 的效果。 JTable 的 removeNotify 方法调用此方法，该方法受到保护，因此此默认卸载过程可以被子类覆盖。
      自从：
      1.3
      参见：

    • createScrollPaneForTable

      @Deprecated public static JScrollPane  createScrollPaneForTable(JTable  aTable)
      已弃用。
      从 Swing 版本 1.0.2 开始，由 new JScrollPane(aTable) 取代。
      相当于 new JScrollPane(aTable) 。
      参数：
      aTable - 用于滚动窗格的 JTable
      返回：
      使用 aTable 创建的 JScrollPane

    • setTableHeader

      @BeanProperty (description ="The JTableHeader instance which renders the column headers.") public void setTableHeader(JTableHeader  tableHeader)
      将与此 JTable 一起工作的 tableHeader 设置为 newHeader。拥有 null tableHeader 是合法的。
      参数：
      tableHeader - 新表头
      参见：

    • getTableHeader

      public JTableHeader  getTableHeader()
      返回此 JTable 使用的 tableHeader。
      返回：
      该表使用的tableHeader
      参见：

    • setRowHeight

      @BeanProperty (description ="The height of the specified row.") public void setRowHeight(int rowHeight)
      将所有单元格的高度（以像素为单位）设置为 rowHeight ，重新验证并重新绘制。单元格的高度将等于行高减去行边距。
      参数：
      rowHeight - 新行高
      抛出：
      IllegalArgumentException - 如果 rowHeight 小于 1
      参见：

    • getRowHeight

      public int getRowHeight()
      返回表格行的高度，以像素为单位。
      返回：
      表格行的高度（以像素为单位）
      参见：

    • setRowHeight

      @BeanProperty (description ="The height in pixels of the cells in <code>row</code>") public void setRowHeight(int row, int rowHeight)
      将 row 的高度设置为 rowHeight ，重新验证并重新绘制。此行中单元格的高度将等于行高减去行边距。
      参数：
      row - 高度被改变的行
      rowHeight - 新行高，以像素为单位
      抛出：
      IllegalArgumentException - 如果 rowHeight 小于 1
      自从：
      1.3

    • getRowHeight

      public int getRowHeight(int row)
      返回 row 中单元格的高度（以像素为单位）。
      参数：
      row - 要返回其高度的行
      返回：
      行中单元格的高度（以像素为单位）
      自从：
      1.3

    • setRowMargin

      @BeanProperty (description ="The amount of space between cells.") public void setRowMargin(int rowMargin)
      设置相邻行中单元格之间的空白空间量。
      参数：
      rowMargin - 一行中单元格之间的像素数
      参见：

    • getRowMargin

      public int getRowMargin()
      获取单元格之间的空白空间量（以像素为单位）。相当于：getIntercellSpacing().height。
      返回：
      一行中单元格之间的像素数
      参见：

    • setIntercellSpacing

      @BeanProperty (bound =false, description ="The spacing between the cells, drawn in the background color of the JTable.") public void setIntercellSpacing(Dimension  intercellSpacing)
      将 rowMargin 和 columnMargin（单元格之间空间的高度和宽度）设置为 intercellSpacing。
      参数：
      intercellSpacing - 一个 Dimension 指定单元格之间的新宽度和高度
      参见：

    • getIntercellSpacing

      public Dimension  getIntercellSpacing()
      返回单元格之间的水平和垂直间距。默认间距取决于外观。
      返回：
      单元格之间的水平和垂直间距
      参见：

    • setGridColor

      @BeanProperty (description ="The grid color.") public void setGridColor(Color  gridColor)
      将用于绘制网格线的颜色设置为 gridColor 并重新显示。默认颜色取决于外观。
      参数：
      gridColor - 网格线的新颜色
      抛出：
      IllegalArgumentException - 如果 gridColor 是 null
      参见：

    • getGridColor

      public Color  getGridColor()
      返回用于绘制网格线的颜色。默认颜色取决于外观。
      返回：
      用于绘制网格线的颜色
      参见：

    • setShowGrid

      @BeanProperty (description ="The color used to draw the grid lines.") public void setShowGrid(boolean showGrid)
      设置表格是否在单元格周围绘制网格线。如果 showGrid 为真，则为真；如果它是假的，它就不会。没有 getShowGrid 方法，因为此状态保存在两个变量中——showHorizontalLines 和 showVerticalLines——每个变量都可以独立查询。
      参数：
      showGrid - 如果表格视图应该绘制网格线则为真
      参见：

    • setShowHorizontalLines

      @BeanProperty (description ="Whether horizontal lines should be drawn in between the cells.") public void setShowHorizontalLines(boolean showHorizontalLines)
      设置表格是否在单元格之间绘制水平线。如果 showHorizontalLines 为真，则为真；如果它是假的，它就不会。
      参数：
      showHorizontalLines - 如果表视图应绘制水平线则为真
      参见：

    • setShowVerticalLines

      @BeanProperty (description ="Whether vertical lines should be drawn in between the cells.") public void setShowVerticalLines(boolean showVerticalLines)
      设置表格是否在单元格之间绘制垂直线。如果 showVerticalLines 为真，则为真；如果它是假的，它就不会。
      参数：
      showVerticalLines - 如果表视图应绘制垂直线则为真
      参见：

    • getShowHorizontalLines

      public boolean getShowHorizontalLines()
      如果表格在单元格之间绘制水平线，则返回 true，否则返回 false。默认值取决于外观。
      返回：
      如果表格在单元格之间绘制水平线，则为 true，否则为 false
      参见：

    • getShowVerticalLines

      public boolean getShowVerticalLines()
      如果表格在单元格之间绘制垂直线，则返回 true，否则返回 false。默认值取决于外观。
      返回：
      如果表格在单元格之间绘制垂直线，则为 true，否则为 false
      参见：

    • setAutoResizeMode

      @BeanProperty (enumerationValues ={"JTable.AUTO_RESIZE_OFF","JTable.AUTO_RESIZE_NEXT_COLUMN","JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS","JTable.AUTO_RESIZE_LAST_COLUMN","JTable.AUTO_RESIZE_ALL_COLUMNS"}, description ="Whether the columns should adjust themselves automatically.") public void setAutoResizeMode(int mode)
      调整表格大小时设置表格的自动调整大小模式。有关不同调整大小模式如何工作的更多信息，请参阅 doLayout() 。
      参数：
      mode - 5 个合法值之一：AUTO_RESIZE_OFF、AUTO_RESIZE_NEXT_COLUMN、AUTO_RESIZE_SUBSEQUENT_COLUMNS、AUTO_RESIZE_LAST_COLUMN、AUTO_RESIZE_ALL_COLUMNS
      参见：

    • getAutoResizeMode

      public int getAutoResizeMode()
      返回表格的自动调整大小模式。默认模式是 AUTO_RESIZE_SUBSEQUENT_COLUMNS。
      返回：
      表的 autoResizeMode
      参见：

    • setAutoCreateColumnsFromModel

      @BeanProperty (description ="Automatically populates the columnModel when a new TableModel is submitted.") public void setAutoCreateColumnsFromModel(boolean autoCreateColumnsFromModel)
      设置此表的 autoCreateColumnsFromModel 标志。如果 autoCreateColumnsFromModel 从 false 变为 true，此方法将调用 createDefaultColumnsFromModel。
      参数：
      autoCreateColumnsFromModel - 如果 JTable 应自动创建列则为真
      参见：

    • getAutoCreateColumnsFromModel

      public boolean getAutoCreateColumnsFromModel()
      确定表是否将从模型创建默认列。如果为真，setModel 将清除所有现有列并从新模型创建新列。此外，如果 tableChanged 通知中的事件指定整个表已更改，则将重建列。默认为真。
      返回：
      表的 autoCreateColumnsFromModel
      参见：

    • createDefaultColumnsFromModel

      public void createDefaultColumnsFromModel()
      使用 TableModel 接口中定义的 getColumnCount 方法从数据模型为表创建默认列。

      在根据模型中的信息创建新列之前清除任何现有列。

      参见：

    • setDefaultRenderer

      public void setDefaultRenderer(Class <?> columnClass, TableCellRenderer  renderer)
      如果在 TableColumn 中没有设置渲染器，则设置要使用的默认单元格渲染器。如果 renderer 是 null ，则删除此列类的默认渲染器。
      参数：
      columnClass - 为此 columnClass 设置默认单元格渲染器
      renderer - 用于此 columnClass 的默认单元格渲染器
      参见：

    • getDefaultRenderer

      public TableCellRenderer  getDefaultRenderer(Class <?> columnClass)
      返回未在 TableColumn 中设置渲染器时要使用的单元格渲染器。在单元格渲染过程中，根据列中单元格的类别，从 Hashtable 条目中获取渲染器。如果此 columnClass 没有条目，则该方法返回最具体的超类的条目。 JTable 安装 Object 、 Number 和 Boolean 的条目，所有这些都可以修改或替换。
      参数：
      columnClass - 返回此 columnClass 的默认单元格渲染器
      返回：
      此 columnClass 的渲染器
      参见：

    • setDefaultEditor

      public void setDefaultEditor(Class <?> columnClass, TableCellEditor  editor)
      如果 TableColumn 中没有设置编辑器，则设置要使用的默认单元格编辑器。如果表格或表格中的特定列不需要编辑，请使用 TableModel 接口中的 isCellEditable 方法以确保此 JTable 不会在这些列中启动编辑器。如果编辑器是 null ，则删除此列类的默认编辑器。
      参数：
      columnClass - 为此列类设置默认的单元格编辑器
      editor - 用于此 columnClass 的默认单元格编辑器
      参见：

    • getDefaultEditor

      public TableCellEditor  getDefaultEditor(Class <?> columnClass)
      返回在 TableColumn 中没有设置编辑器时要使用的编辑器。在编辑单元格期间，根据列中单元格的类别从 Hashtable 条目中获取编辑器。如果此 columnClass 没有条目，则该方法返回最具体的超类的条目。 JTable 安装 Object 、 Number 和 Boolean 的条目，所有这些都可以修改或替换。
      参数：
      columnClass - 返回此列类的默认单元格编辑器
      返回：
      用于此 columnClass 的默认单元格编辑器
      参见：

    • setDragEnabled

      @BeanProperty (bound =false, description ="determines whether automatic drag handling is enabled") public void setDragEnabled(boolean b)
      打开或关闭自动拖动处理。为了启用自动拖动处理，该属性应设置为 true ，表的 TransferHandler 需要为 non-null 。 dragEnabled 属性的默认值为 false 。

      遵守此属性并识别用户拖动手势的工作在于外观实现，尤其是表的 TableUI 。当启用自动拖动处理时，大多数外观（包括子类 BasicLookAndFeel 的外观和感觉）在用户将鼠标按钮按到项目（在单选模式下）或选择（在其他选择模式下）上时开始拖放操作，并且然后将鼠标移动几个像素。因此，将此属性设置为 true 会对选择的行为方式产生微妙的影响。

      如果使用忽略此属性的外观，您仍然可以通过在表的 TransferHandler 上调用 exportAsDrag 来开始拖放操作。

      参数：
      b - 是否启用自动拖动处理
      抛出：
      HeadlessException - 如果 b 是 true 并且 GraphicsEnvironment.isHeadless() 返回 true
      自从：
      1.4
      参见：

    • getDragEnabled

      public boolean getDragEnabled()
      返回是否启用自动拖动处理。
      返回：
      dragEnabled 属性的值
      自从：
      1.4
      参见：

    • setDropMode

      public final void setDropMode(DropMode  dropMode)
      设置此组件的放置模式。为了向后兼容，此属性的默认值为 DropMode.USE_SELECTION 。但是，建议使用其中一种其他模式，以改善用户体验。例如，DropMode.ON 提供了类似的将项目显示为选中的行为，但不会影响表中的实际选择。

      JTable 支持以下丢弃模式：

      • DropMode.USE_SELECTION
      • DropMode.ON
      • DropMode.INSERT
      • DropMode.INSERT_ROWS
      • DropMode.INSERT_COLS
      • DropMode.ON_OR_INSERT
      • DropMode.ON_OR_INSERT_ROWS
      • DropMode.ON_OR_INSERT_COLS

      仅当此组件具有接受丢弃的 TransferHandler 时，丢弃模式才有意义。

      参数：
      dropMode - 使用的丢弃模式
      抛出：
      IllegalArgumentException - 如果丢弃模式不受支持或 null
      自从：
      1.6
      参见：

    • getDropMode

      public final DropMode  getDropMode()
      返回此组件的放置模式。
      返回：
      该组件的放置模式
      自从：
      1.6
      参见：

    • getDropLocation

      @BeanProperty (bound =false) public final JTable.DropLocation  getDropLocation()
      返回此组件在组件上的 DnD 操作期间应直观指示为放置位置的位置，如果当前没有要显示的位置，则返回 null。

      此方法不适用于从 TransferHandler 查询放置位置，因为放置位置仅在 TransferHandler 的 canImport 返回并允许显示位置后设置。

      当此属性更改时，组件将触发名为“dropLocation”的属性更改事件。

      返回：
      下降位置
      自从：
      1.6
      参见：

    • setAutoCreateRowSorter

      @BeanProperty (preferred =true, description ="Whether or not to turn on sorting by default.") public void setAutoCreateRowSorter(boolean autoCreateRowSorter)
      指定是否应在其模型更改时为表创建 RowSorter。

      调用 setAutoCreateRowSorter(true) 时，会立即创建 TableRowSorter 并将其安装在表上。虽然 autoCreateRowSorter 属性仍然是 true ，但每次更改模型时，都会创建一个新的 TableRowSorter 并将其设置为表的行排序器。 autoCreateRowSorter 属性的默认值为 false 。

      参数：
      autoCreateRowSorter - 是否应自动创建 RowSorter
      自从：
      1.6
      参见：

    • getAutoCreateRowSorter

      public boolean getAutoCreateRowSorter()
      返回 true 如果每当模型更改时，应创建一个新的 RowSorter 并将其安装为表的排序器；否则，返回 false 。
      返回：
      如果在模型更改时应创建 RowSorter，则为真
      自从：
      1.6

    • setUpdateSelectionOnSort

      @BeanProperty (expert =true, description ="Whether or not to update the selection on sorting") public void setUpdateSelectionOnSort(boolean update)
      指定是否应在排序后更新选择。如果为 true，则在排序时重置选择，这样就模型而言，相同的行将保持选中状态。默认为真。
      参数：
      update - 是否更新排序选择
      自从：
      1.6

    • getUpdateSelectionOnSort

      public boolean getUpdateSelectionOnSort()
      如果选择应在排序后更新，则返回 true。
      返回：
      是否更新排序的选择
      自从：
      1.6

    • setRowSorter

      @BeanProperty (description ="The table\'s RowSorter") public void setRowSorter(RowSorter <? extends TableModel > sorter)
      设置 RowSorter 。 RowSorter 用于为 JTable 提供排序和过滤。

      此方法清除选择并重置任何可变行高。

      此方法会在适当时触发 PropertyChangeEvent，属性名称为 "rowSorter"。为了向后兼容，此方法会触发属性名称为 "sorter" 的附加事件。

      如果 RowSorter 的底层模型与此 JTable 的底层模型不同，将导致未定义的行为。

      参数：
      sorter - RowSorter ； null 关闭排序
      自从：
      1.6
      参见：

    • getRowSorter

      public RowSorter <? extends TableModel > getRowSorter()
      返回负责排序的对象。
      返回：
      负责排序的对象
      自从：
      1.6

    • setSelectionMode

      @BeanProperty (enumerationValues ={"ListSelectionModel.SINGLE_SELECTION","ListSelectionModel.SINGLE_INTERVAL_SELECTION","ListSelectionModel.MULTIPLE_INTERVAL_SELECTION"}, description ="The selection mode used by the row and column selection models.") public void setSelectionMode(int selectionMode)
      将表的选择模式设置为仅允许单个选择、单个连续间隔或多个间隔。

      笔记：JTable 提供了处理列和行选择的所有方法。设置状态时，例如 setSelectionMode ，它不仅会更新行选择模型的模式，还会在 columnModel 的选择模型中设置类似的值。如果你想让行和列选择模型以不同的模式运行，直接设置它们。

      JTable 的行和列选择模型都默认使用 DefaultListSelectionModel，因此 JTable 的工作方式与 JList 相同。有关模式的详细信息，请参阅 JList 中的 setSelectionMode 方法。

      参数：
      selectionMode - 行和列选择模型使用的模式
      参见：

    • setRowSelectionAllowed

      @BeanProperty (visualUpdate =true, description ="If true, an entire row is selected for each selected cell.") public void setRowSelectionAllowed(boolean rowSelectionAllowed)
      设置是否可以选择此模型中的行。
      参数：
      rowSelectionAllowed - 如果此模型允许行选择，则为真
      参见：

    • getRowSelectionAllowed

      public boolean getRowSelectionAllowed()
      如果可以选择行，则返回 true。
      返回：
      如果可以选择行，则为 true，否则为 false
      参见：

    • setColumnSelectionAllowed

      @BeanProperty (visualUpdate =true, description ="If true, an entire column is selected for each selected cell.") public void setColumnSelectionAllowed(boolean columnSelectionAllowed)
      设置是否可以选择此模型中的列。
      参数：
      columnSelectionAllowed - 如果此模型允许列选择，则为真
      参见：

    • getColumnSelectionAllowed

      public boolean getColumnSelectionAllowed()
      如果可以选择列，则返回 true。
      返回：
      如果可以选择列，则为 true，否则为 false
      参见：

    • setCellSelectionEnabled

      @BeanProperty (visualUpdate =true, description ="Select a rectangular region of cells rather than rows or columns.") public void setCellSelectionEnabled(boolean cellSelectionEnabled)
      设置此表是否允许列选择和行选择同时存在。设置后，表格将行和列选择模型的交集视为选定单元格。覆盖 isCellSelected 以更改此默认行为。此方法等效于将 columnModel 的 rowSelectionAllowed 属性和 columnSelectionAllowed 属性设置为提供的值。
      参数：
      cellSelectionEnabled - 如果允许同时选择行和列则为真
      参见：

    • getCellSelectionEnabled

      public boolean getCellSelectionEnabled()
      如果同时启用了行和列选择模型，则返回 true。相当于 getRowSelectionAllowed() && getColumnSelectionAllowed() 。
      返回：
      如果同时启用了行和列选择模型，则为真
      参见：

    • selectAll

      public void selectAll()
      选择表格中的所有行、列和单元格。

    • clearSelection

      public void clearSelection()
      取消选择所有选定的列和行。

    • setRowSelectionInterval

      public void setRowSelectionInterval(int index0, int index1)
      选择从 index0 到 index1 的行，包括在内。
      参数：
      index0 - 区间的一端
      index1 - 区间的另一端
      抛出：
      IllegalArgumentException - 如果 index0 或 index1 位于 [0, getRowCount() -1] 之外

    • setColumnSelectionInterval

      public void setColumnSelectionInterval(int index0, int index1)
      选择从 index0 到 index1 的列，包括在内。
      参数：
      index0 - 区间的一端
      index1 - 区间的另一端
      抛出：
      IllegalArgumentException - 如果 index0 或 index1 位于 [0, getColumnCount() -1] 之外

    • addRowSelectionInterval

      public void addRowSelectionInterval(int index0, int index1)
      将 index0 到 index1 的行添加到当前选择。
      参数：
      index0 - 区间的一端
      index1 - 区间的另一端
      抛出：
      IllegalArgumentException - 如果 index0 或 index1 位于 [0, getRowCount() -1] 之外

    • addColumnSelectionInterval

      public void addColumnSelectionInterval(int index0, int index1)
      将 index0 到 index1 的列添加到当前选择中。
      参数：
      index0 - 区间的一端
      index1 - 区间的另一端
      抛出：
      IllegalArgumentException - 如果 index0 或 index1 位于 [0, getColumnCount() -1] 之外

    • removeRowSelectionInterval

      public void removeRowSelectionInterval(int index0, int index1)
      取消选择从 index0 到 index1 的行，包括在内。
      参数：
      index0 - 区间的一端
      index1 - 区间的另一端
      抛出：
      IllegalArgumentException - 如果 index0 或 index1 位于 [0, getRowCount() -1] 之外

    • removeColumnSelectionInterval

      public void removeColumnSelectionInterval(int index0, int index1)
      取消选择从 index0 到 index1 的列，包括在内。
      参数：
      index0 - 区间的一端
      index1 - 区间的另一端
      抛出：
      IllegalArgumentException - 如果 index0 或 index1 位于 [0, getColumnCount() -1] 之外

    • getSelectedRow

      @BeanProperty (bound =false) public int getSelectedRow()
      返回第一个选定行的索引，如果未选择任何行，则返回 -1。
      返回：
      第一个选定行的索引

    • getSelectedColumn

      @BeanProperty (bound =false) public int getSelectedColumn()
      返回第一个选定列的索引，如果未选择任何列，则返回 -1。
      返回：
      第一个选定列的索引

    • getSelectedRows

      @BeanProperty (bound =false) public int[] getSelectedRows()
      返回所有选定行的索引。
      返回：
      包含所有选定行的索引的整数数组，如果未选择任何行，则为空数组
      参见：

    • getSelectedColumns

      @BeanProperty (bound =false) public int[] getSelectedColumns()
      返回所有选定列的索引。
      返回：
      包含所有选定列的索引的整数数组，如果未选择列，则为空数组
      参见：

    • getSelectedRowCount

      @BeanProperty (bound =false) public int getSelectedRowCount()
      返回所选行的数量。
      返回：
      所选行数，如果未选择任何行，则为 0

    • getSelectedColumnCount

      @BeanProperty (bound =false) public int getSelectedColumnCount()
      返回所选列的数量。
      返回：
      所选列的数量，如果未选择任何列，则为 0

    • isRowSelected

      public boolean isRowSelected(int row)
      如果指定的索引在行的有效范围内并且该索引处的行被选中，则返回 true。
      参数：
      row - 行模型中的一行
      返回：
      如果 row 是有效索引并且选择了该索引处的行（其中 0 是第一行），则为真

    • isColumnSelected

      public boolean isColumnSelected(int column)
      如果指定的索引在列的有效范围内，并且该索引处的列被选中，则返回 true。
      参数：
      column - 列模型中的列
      返回：
      如果 column 是有效索引并且选择了该索引处的列（其中 0 是第一列），则为真

    • isCellSelected

      public boolean isCellSelected(int row, int column)
      如果指定的索引在行和列的有效范围内并且指定位置的单元格被选中，则返回 true。
      参数：
      row - 被查询的行
      column - 被查询的列
      返回：
      如果 row 和 column 是有效索引并且选择索引 (row, column) 处的单元格，则第一行和第一列在索引 0 处为真

    • changeSelection

      public void changeSelection(int rowIndex, int columnIndex, boolean toggle, boolean extend)
      根据两个标志的状态更新表格的选择模型：toggle 和 extend。大多数由 UI 接收到的键盘或鼠标事件导致的选择更改都通过此方法进行引导，因此该行为可能会被子类覆盖。某些 UI 可能需要比此方法提供更多的功能，例如在操作引线以进行不连续选择时，并且可能不会调用此方法进行某些选择更改。

      此实现使用以下约定：

      • toggle：false，extend：false。清除之前的选择并确保选择了新单元格。
      • toggle：false，extend：true。将先前的选择从锚点扩展到指定的单元格，清除所有其他选择。
      • toggle：true，extend：false。如果选择了指定的单元格，则取消选择它。如果未选中，请选中它。
      • toggle：true，extend：true。将锚点的选择状态应用于它与指定单元格之间的所有单元格。
      参数：
      rowIndex - 影响 row 处的选择
      columnIndex - 影响 column 处的选择
      toggle - 见上面的描述
      extend - 如果为真，则扩展当前选择
      自从：
      1.3

    • getSelectionForeground

      public Color  getSelectionForeground()
      返回所选单元格的前景色。
      返回：
      前景属性的 Color 对象
      参见：

    • setSelectionForeground

      @BeanProperty (description ="A default foreground color for selected cells.") public void setSelectionForeground(Color  selectionForeground)
      设置选定单元格的前景色。单元格渲染器可以使用这种颜色来渲染选定单元格的文本和图形。

      此属性的默认值由外观实现定义。

      这是一个 JavaBeans 绑定属性。

      参数：
      selectionForeground - 在所选列表项的前台使用的 Color
      参见：

    • getSelectionBackground

      public Color  getSelectionBackground()
      返回所选单元格的背景颜色。
      返回：
      Color 用于选定列表项的背景
      参见：

    • setSelectionBackground

      @BeanProperty (description ="A default background color for selected cells.") public void setSelectionBackground(Color  selectionBackground)
      设置选定单元格的背景颜色。单元格渲染器可以使用此颜色来填充选定的单元格。

      此属性的默认值由外观实现定义。

      这是一个 JavaBeans 绑定属性。

      参数：
      selectionBackground - 用于所选单元格背景的 Color
      参见：

    • getColumn

      public TableColumn  getColumn(Object  identifier)
      当使用 equals 进行比较时，返回表中标识符等于 identifier 的列的 TableColumn 对象。
      参数：
      identifier - 标识符对象
      返回：
      与标识符匹配的 TableColumn 对象
      抛出：
      IllegalArgumentException - 如果 identifier 是 null 或没有 TableColumn 有这个标识符

    • convertColumnIndexToModel

      public int convertColumnIndexToModel(int viewColumnIndex)
      将 viewColumnIndex 处视图中列的索引映射到表模型中列的索引。返回模型中相应列的索引。如果 viewColumnIndex 小于零，则返回 viewColumnIndex 。
      参数：
      viewColumnIndex - 视图中列的索引
      返回：
      模型中相应列的索引
      参见：

    • convertColumnIndexToView

      public int convertColumnIndexToView(int modelColumnIndex)
      将位于 modelColumnIndex 的表模型中列的索引映射到视图中列的索引。返回视图中相应列的索引；如果未显示此列，则返回 -1。如果 modelColumnIndex 小于零，则返回 modelColumnIndex 。
      参数：
      modelColumnIndex - 模型中列的索引
      返回：
      视图中相应列的索引
      参见：

    • convertRowIndexToView

      public int convertRowIndexToView(int modelRowIndex)
      根据 TableModel 将行的索引映射到视图。如果模型的内容未排序，则模型和视图索引相同。
      参数：
      modelRowIndex - 就模型而言的行索引
      返回：
      视图中相应行的索引，如果行不可见则为 -1
      抛出：
      IndexOutOfBoundsException - 如果启用排序并传递超出 TableModel 行数的索引
      自从：
      1.6
      参见：

    • convertRowIndexToModel

      public int convertRowIndexToModel(int viewRowIndex)
      根据视图将行的索引映射到基础 TableModel 。如果模型的内容未排序，则模型和视图索引相同。
      参数：
      viewRowIndex - 视图中行的索引
      返回：
      模型中相应行的索引
      抛出：
      IndexOutOfBoundsException - 如果启用了排序并传递了由方法 getRowCount 确定的 JTable 范围之外的索引
      自从：
      1.6
      参见：

    • getRowCount

      @BeanProperty (bound =false) public int getRowCount()
      在给定无限空间的情况下，返回可以在 JTable 中显示的行数。如果已指定带有过滤器的 RowSorter，则返回的行数可能与基础 TableModel 的行数不同。
      返回：
      JTable 中显示的行数
      参见：

    • getColumnCount

      @BeanProperty (bound =false) public int getColumnCount()
      返回列模型中的列数。请注意，这可能与表模型中的列数不同。
      返回：
      表中的列数
      参见：

    • getColumnName

      public String  getColumnName(int column)
      返回出现在列位置 column 的视图中的列的名称。
      参数：
      column - 正在查询的视图中的列
      返回：
      第一列为第 0 列的视图中位于位置 column 的列的名称

    • getColumnClass

      public Class <?> getColumnClass(int column)
      返回列位置 column 处出现在视图中的列的类型。
      参数：
      column - 正在查询的视图中的列
      返回：
      第一列为第 0 列的视图中位于位置 column 的列的类型

    • getValueAt

      public Object  getValueAt(int row, int column)
      返回 row 和 column 处的单元格值。

      笔记该列是在表视图的显示顺序中指定的，而不是在 TableModel 的列顺序中指定的。这是一个重要的区别，因为当用户重新排列表中的列时，视图中给定索引处的列将发生变化。同时，用户的操作永远不会影响模型的列排序。

      参数：
      row - 要查询其值的行
      column - 要查询其值的列
      返回：
      指定单元格中的对象

    • setValueAt

      public void setValueAt(Object  aValue, int row, int column)
      为表模型中位于 row 和 column 的单元格设置值。

      笔记该列是在表视图的显示顺序中指定的，而不是在 TableModel 的列顺序中指定的。这是一个重要的区别，因为当用户重新排列表中的列时，视图中给定索引处的列将发生变化。同时，用户的操作永远不会影响模型的列排序。 aValue 是新值。

      参数：
      aValue - 新值
      row - 要更改的单元格的行
      column - 要更改的单元格的列
      参见：

    • isCellEditable

      public boolean isCellEditable(int row, int column)
      如果 row 和 column 处的单元格可编辑，则返回真。否则，在单元格上调用 setValueAt 将无效。

      笔记该列是在表视图的显示顺序中指定的，而不是在 TableModel 的列顺序中指定的。这是一个重要的区别，因为当用户重新排列表中的列时，视图中给定索引处的列将发生变化。同时，用户的操作永远不会影响模型的列排序。

      参数：
      row - 要查询其值的行
      column - 要查询其值的列
      返回：
      如果单元格可编辑则为真
      参见：

    • addColumn

      public void addColumn(TableColumn  aColumn)
      将 aColumn 附加到此 JTable 的列模型所持有的列数组的末尾。如果 aColumn 的列名是 null ，则将 aColumn 的列名设置为 getModel().getColumnName() 返回的名称。

      要向此 JTable 添加一列以显示具有给定 width、cellRenderer 和 cellEditor 的模型中的第 modelColumn 列数据，您可以使用：

         addColumn(new TableColumn(modelColumn, width, cellRenderer, cellEditor));
      [可以使用任何 TableColumn 构造函数代替此构造函数。] 模型列号存储在 TableColumn 中，并在渲染和编辑期间用于在模型中定位适当的数据值。在视图中对列重新排序时，模型列号不会更改。
      参数：
      aColumn - 要添加的 TableColumn
      参见：

    • removeColumn

      public void removeColumn(TableColumn  aColumn)
      从此 JTable 的列数组中删除 aColumn。注意：此方法不会从模型中删除数据列；它只是删除了负责显示它的 TableColumn。
      参数：
      aColumn - 要删除的 TableColumn
      参见：

    • moveColumn

      public void moveColumn(int column, int targetColumn)
      将列 column 移动到视图中列 targetColumn 当前占用的位置。 targetColumn 处的旧列向左或向右移动以腾出空间。
      参数：
      column - 要移动的列的索引
      targetColumn - 列的新索引

    • columnAtPoint

      public int columnAtPoint(Point  point)
      返回 point 所在列的索引，如果结果不在 [0, getColumnCount() -1] 范围内，则返回 -1。
      参数：
      point - 感兴趣的位置
      返回：
      point 所在列的索引，如果结果不在 [0, getColumnCount() -1] 范围内则为 -1
      参见：

    • rowAtPoint

      public int rowAtPoint(Point  point)
      返回 point 所在行的索引，如果结果不在 [0, getRowCount() -1] 范围内，则返回 -1。
      参数：
      point - 感兴趣的位置
      返回：
      point 所在行的索引，如果结果不在 [0, getRowCount() -1] 范围内则为 -1
      参见：

    • getCellRect

      public Rectangle  getCellRect(int row, int column, boolean includeSpacing)
      返回位于 row 和 column 交集处的单元格的矩形。如果 includeSpacing 为真，则返回的值具有指定行和列的完整高度和宽度。如果为 false，则返回的矩形由单元间距插入，以返回渲染或编辑组件的真实边界，因为它将在渲染期间设置。

      如果列索引有效但行索引小于零，则该方法返回一个矩形，其中 y 和 height 值设置适当并且 x 和 width 值都设置为零。通常，当行或列索引指示适当范围之外的单元格时，该方法返回一个矩形，该矩形描述了表格范围内最近单元格的最近边缘。当行和列索引都超出范围时，返回的矩形将覆盖最近单元格的最近点。

      在所有情况下，使用此方法沿一个轴计算结果的计算不会因为沿另一轴的计算出现异常而失败。当单元格无效时，includeSpacing 参数将被忽略。

      参数：
      row - 所需单元格所在的行索引
      column - 显示中所需单元格所在的列索引；这不一定与表的数据模型中的列索引相同； convertColumnIndexToView(int) 方法可用于将数据模型列索引转换为显示列索引
      includeSpacing - 如果为假，则返回真实的单元格边界 - 通过从列和行模型的高度和宽度中减去单元格间距来计算
      返回：
      包含位于 row ,column 位置的单元格的矩形
      参见：

    • doLayout

      public void doLayout()
      导致此表布置其行和列。重写以便可以调整列的大小以适应包含父项的大小的更改。调整表中一列或多列的大小，使 JTable 的所有列的总宽度等于表的宽度。

      在布局开始之前，该方法获取 tableHeader 的 resizingColumn。当由于调整封闭窗口的大小而调用该方法时，resizingColumn 为 null。这意味着调整大小发生在 JTable 的“外部”，并且无论此 JTable 的自动调整大小模式如何，更改 - 或“增量” - 都应分发到所有列。

      如果 resizingColumn 不是 null ，则它是表中已更改大小的列之一，而不是表本身。在这种情况下，自动调整大小模式控制额外（或不足）空间在可用列之间的分配方式。

      这些模式是：

      • AUTO_RESIZE_OFF：根本不自动调整列的宽度。当它们的总和超过 Viewport 的宽度时，使用水平滚动条来容纳列。如果 JTable 未包含在 JScrollPane 中，这可能会使部分表格不可见。
      • AUTO_RESIZE_NEXT_COLUMN：仅使用调整列大小后的列。这导致相邻单元格之间的“边界”或分隔线可以独立调整。
      • AUTO_RESIZE_SUBSEQUENT_COLUMNS：使用调整后的所有列来吸收更改。这是默认行为。
      • AUTO_RESIZE_LAST_COLUMN：只自动调整最后一列的大小。如果最后一列的边界阻止分配所需的大小，请将最后一列的宽度设置为适当的限制并且不做进一步的调整。
      • AUTO_RESIZE_ALL_COLUMNS：在 JTable 的所有列中传播增量，包括正在调整的列。

      笔记：当 JTable 调整列的宽度时，它绝对尊重它们的最小值和最大值。因此，即使在调用此方法后，列的总宽度仍可能不等于表格的宽度。发生这种情况时，JTable 不会将自己置于 AUTO_RESIZE_OFF 模式以调出滚动条，也不会破坏其当前自动调整大小模式的其他承诺——相反，它允许将其边界设置为大于（或小于）列最小值或最大值，意思是没有足够的空间来显示所有列，或者列不会填充 JTable 的边界。这些分别导致某些列的剪裁或在绘制过程中以 JTable 的背景颜色绘制的区域。

      JTable 类中的私有方法提供了在可用列之间分配增量的机制：

        adjustSizes(long targetSize, final Resizable3 r, boolean inverse)
      下一节将对此进行解释。 Resizable3 是一个私有接口，它允许包含具有大小、首选大小、最大大小和最小大小的元素集合的任何数据结构让其元素由算法操作。

      分布增量

      概述

      将目标大小与 r 中元素的首选大小之和之间的差称为“DELTA”。各个尺寸是通过采用原始首选尺寸并添加 DELTA 的份额来计算的 - 该份额基于每个首选尺寸与其限制范围（最小或最大）的距离。

      定义

      调用单独的约束 min[i]、max[i] 和 pref[i]。

      调用它们各自的总和：MIN、MAX 和 PREF。

      每个新尺寸将使用以下方法计算：

           size[i] = pref[i] + delta[i]
      其中每个单独的 delta[i] 是根据以下公式计算的：

      如果 (DELTA < 0) 我们处于收缩模式，其中：

                  DELTA
     delta[i] = ------------ * (pref[i] - min[i])
           (PREF - MIN)
      如果 (DELTA > 0) 我们处于扩展模式，其中： 
                  DELTA
     delta[i] = ------------ * (max[i] - pref[i])
           (MAX - PREF)

      总体效果是总大小将相同的百分比 k 移向总最小值或最大值，并且该百分比保证容纳所需空间 DELTA。

      细节

      对此处提供的公式的简单评估会受到以有限精度（使用整数）执行此操作引起的聚合舍入误差的影响。为了解决这个问题，上面的乘数会不断重新计算，这会考虑到先前迭代中的舍入误差。结果是生成一组整数的算法，其值恰好与提供的 targetSize 相加，并通过将舍入误差均匀分布在给定元素上来实现。

      当达到 MAX 和 MIN 界限时

      当 targetSize 超出 [MIN, MAX] 范围时，算法将所有大小设置为其适当的限制值（最大值或最小值）。

      重写：
      doLayout 在类 Container 中
      参见：

    • sizeColumnsToFit

      @Deprecated public void sizeColumnsToFit(boolean lastColumnOnly)
      已弃用。
      从 Swing 版本 1.0.3 开始，由 doLayout() 取代。
      调整表格列的大小以适应可用空间。
      参数：
      lastColumnOnly - 确定是否仅调整最后一列的大小
      参见：

    • sizeColumnsToFit

      public void sizeColumnsToFit(int resizingColumn)
      自 Java 2 平台 v1.4 起已过时。请改用 doLayout() 方法。
      参数：
      resizingColumn - 因调整大小而需要进行此调整的列，如果没有此类列，则为 -1
      参见：

    • getToolTipText

      public String  getToolTipText(MouseEvent  event)
      覆盖 JComponent 的 getToolTipText 方法，以便在设置了文本时允许使用渲染器的提示。

      笔记：为了让 JTable 正确显示其渲染器的工具提示，JTable 必须是使用 ToolTipManager 注册的组件。这是在 initializeLocalVars 中自动完成的，但如果稍后通知 JTable setToolTipText(null) 它将取消注册表格组件，并且不会再显示来自渲染器的提示。

      重写：
      getToolTipText 在类 JComponent 中
      参数：
      event - 启动 ToolTip 显示的 MouseEvent
      返回：
      包含工具提示的字符串
      参见：

    • setSurrendersFocusOnKeystroke

      public void setSurrendersFocusOnKeystroke(boolean surrendersFocusOnKeystroke)
      设置当编辑器因单元格的 JTable 转发键盘事件而被激活时，此 JTable 中的编辑器是否获得键盘焦点。默认情况下，此属性为 false，除非单击单元格，否则 JTable 会保留焦点。
      参数：
      surrendersFocusOnKeystroke - 如果当击键导致编辑器被激活时编辑器应该获得焦点则为真
      自从：
      1.4
      参见：

    • getSurrendersFocusOnKeystroke

      public boolean getSurrendersFocusOnKeystroke()
      如果编辑器应该在击键导致编辑器被激活时获得焦点，则返回 true
      返回：
      如果编辑器应该在击键导致编辑器被激活时获得焦点，则为 true
      自从：
      1.4
      参见：

    • editCellAt

      public boolean editCellAt(int row, int column)
      以编程方式开始编辑 row 和 column 处的单元格，如果这些索引在有效范围内，并且这些索引处的单元格是可编辑的。请注意，这是 editCellAt(int, int, null) 的便捷方法。
      参数：
      row - 要编辑的行
      column - 要编辑的列
      返回：
      如果由于任何原因无法编辑单元格，或者索引无效，则为 false

    • editCellAt

      public boolean editCellAt(int row, int column, EventObject  e)
      以编程方式开始编辑 row 和 column 处的单元格，如果这些索引在有效范围内，并且这些索引处的单元格是可编辑的。要防止 JTable 编辑特定表格、列或单元格值，请从 TableModel 接口中的 isCellEditable 方法返回 false。
      参数：
      row - 要编辑的行
      column - 要编辑的列
      e - 传递给 shouldSelectCell 的事件；请注意，从 Java 2 平台 v1.2 开始，不再调用 shouldSelectCell
      返回：
      如果由于任何原因无法编辑单元格，或者索引无效，则为 false

    • isEditing

      @BeanProperty (bound =false) public boolean isEditing()
      如果正在编辑单元格，则返回 true。
      返回：
      如果表格正在编辑单元格则为真
      参见：

    • getEditorComponent

      @BeanProperty (bound =false) public Component  getEditorComponent()
      返回正在处理编辑会话的组件。如果未编辑任何内容，则返回 null。
      返回：
      组件处理编辑会话

    • getEditingColumn

      public int getEditingColumn()
      返回包含当前正在编辑的单元格的列的索引。如果未编辑任何内容，则返回 -1。
      返回：
      包含当前正在编辑的单元格的列的索引；如果没有被编辑则返回 -1
      参见：

    • getEditingRow

      public int getEditingRow()
      返回包含当前正在编辑的单元格的行的索引。如果未编辑任何内容，则返回 -1。
      返回：
      包含当前正在编辑的单元格的行的索引；如果没有被编辑则返回 -1
      参见：

    • getUI

      public TableUI  getUI()
      返回呈现此组件的 L&F 对象。
      重写：
      getUI 在类 JComponent 中
      返回：
      呈现此组件的 TableUI 对象

    • setUI

      @BeanProperty (hidden =true, visualUpdate =true, description ="The UI object that implements the Component\'s LookAndFeel.") public void setUI(TableUI  ui)
      设置呈现此组件并重新绘制的 L&F 对象。
      参数：
      ui - TableUI L&F 对象
      参见：

    • updateUI

      public void updateUI()
      来自 UIManager 的通知，L&F 已更改。用 UIManager 的最新版本替换当前 UI 对象。
      重写：
      updateUI 在类 JComponent 中
      参见：

    • getUIClassID

      @BeanProperty (bound =false) public String  getUIClassID()
      返回用于构造用于呈现此组件的 L&F 类名称的后缀。
      重写：
      getUIClassID 在类 JComponent 中
      返回：
      字符串“TableUI”
      参见：

    • setModel

      @BeanProperty (description ="The model that is the source of the data for this view.") public void setModel(TableModel  dataModel)
      将此表的数据模型设置为 dataModel 并向其注册以接收来自新数据模型的监听器通知。
      参数：
      dataModel - 此表的新数据源
      抛出：
      IllegalArgumentException - 如果 dataModel 是 null
      参见：

    • getModel

      public TableModel  getModel()
      返回提供此 JTable 显示的数据的 TableModel。
      返回：
      TableModel 提供此 JTable 显示的数据
      参见：

    • setColumnModel

      @BeanProperty (description ="The object governing the way columns appear in the view.") public void setColumnModel(TableColumnModel  columnModel)
      将此表的列模型设置为 columnModel 并注册来自新列模型的监听器通知。还将 JTableHeader 的列模型设置为 columnModel 。
      参数：
      columnModel - 此表的新数据源
      抛出：
      IllegalArgumentException - 如果 columnModel 是 null
      参见：

    • getColumnModel

      public TableColumnModel  getColumnModel()
      返回包含该表所有列信息的TableColumnModel。
      返回：
      提供表的列状态的对象
      参见：

    • setSelectionModel

      @BeanProperty (description ="The selection model for rows.") public void setSelectionModel(ListSelectionModel  selectionModel)
      将此表的行选择模型设置为 selectionModel 并注册来自新选择模型的监听器通知。
      参数：
      selectionModel - 新的选择模型
      抛出：
      IllegalArgumentException - 如果 selectionModel 是 null
      参见：

    • getSelectionModel

      public ListSelectionModel  getSelectionModel()
      返回用于维护行选择状态的ListSelectionModel。
      返回：
      提供行选择状态的对象，null如果不允许行选择
      参见：

    • sorterChanged

      public void sorterChanged(RowSorterEvent  e)
      RowSorterListener 通知 RowSorter 以某种方式发生了变化。
      指定者：
      sorterChanged 在接口 RowSorterListener 中
      参数：
      e - RowSorterEvent 描述了变化
      抛出：
      NullPointerException - 如果 e 是 null
      自从：
      1.6

    • tableChanged

      public void tableChanged(TableModelEvent  e)
      在此表的 TableModel 生成 TableModelEvent 时调用。 TableModelEvent应该在模型的坐标系中构建； JTable 在接收到事件时执行到视图坐标系的适当映射。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      请注意，从 1.3 开始，此方法会清除选择（如果有）。

      指定者：
      tableChanged 在接口 TableModelListener 中
      参数：
      e - 一个 TableModelEvent 通知监听器表模型已更改

    • columnAdded

      public void columnAdded(TableColumnModelEvent  e)
      在将列添加到表列模型时调用。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      columnAdded 在接口 TableColumnModelListener 中
      参数：
      e - 一个 TableColumnModelEvent
      参见：

    • columnRemoved

      public void columnRemoved(TableColumnModelEvent  e)
      从表列模型中删除列时调用。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      columnRemoved 在接口 TableColumnModelListener 中
      参数：
      e - 一个 TableColumnModelEvent
      参见：

    • columnMoved

      public void columnMoved(TableColumnModelEvent  e)
      重新定位列时调用。如果正在编辑单元格，则停止编辑并重新绘制单元格。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      columnMoved 在接口 TableColumnModelListener 中
      参数：
      e - 收到的事件
      参见：

    • columnMarginChanged

      public void columnMarginChanged(ChangeEvent  e)
      由于边距更改而移动列时调用。如果正在编辑单元格，则停止编辑并重新绘制单元格。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      columnMarginChanged 在接口 TableColumnModelListener 中
      参数：
      e - 收到的事件
      参见：

    • columnSelectionChanged

      public void columnSelectionChanged(ListSelectionEvent  e)
      TableColumnModel 的选择模型更改时调用。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      columnSelectionChanged 在接口 TableColumnModelListener 中
      参数：
      e - 收到的事件
      参见：

    • valueChanged

      public void valueChanged(ListSelectionEvent  e)
      当行选择更改时调用——重新绘制以显示新选择。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      valueChanged 在接口 ListSelectionListener 中
      参数：
      e - 收到的事件
      参见：

    • editingStopped

      public void editingStopped(ChangeEvent  e)
      编辑完成时调用。保存更改并放弃编辑器。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      editingStopped 在接口 CellEditorListener 中
      参数：
      e - 收到的事件
      参见：

    • editingCanceled

      public void editingCanceled(ChangeEvent  e)
      取消编辑时调用。编辑器对象被丢弃，单元格被再次渲染。

      应用程序代码不会显式使用这些方法，它们由 JTable 在内部使用。

      指定者：
      editingCanceled 在接口 CellEditorListener 中
      参数：
      e - 收到的事件
      参见：

    • setPreferredScrollableViewportSize

      @BeanProperty (bound =false, description ="The preferred size of the viewport.") public void setPreferredScrollableViewportSize(Dimension  size)
      为此表设置视口的首选大小。
      参数：
      size - 一个 Dimension 对象指定一个 JViewport 的 preferredSize ，其视图是这个表
      参见：

    • getPreferredScrollableViewportSize

      public Dimension  getPreferredScrollableViewportSize()
      返回此表的视口的首选大小。
      指定者：
      getPreferredScrollableViewportSize 在接口 Scrollable 中
      返回：
      包含显示此表的 JViewport 的 preferredSize 的 Dimension 对象
      参见：

    • getScrollableUnitIncrement

      public int getScrollableUnitIncrement(Rectangle  visibleRect, int orientation, int direction)
      返回完全显示新行或新列（取决于方向）的滚动增量（以像素为单位）。

      每次用户请求单位滚动时调用此方法。

      指定者：
      getScrollableUnitIncrement 在接口 Scrollable 中
      参数：
      visibleRect - 视口内可见的视图区域
      orientation - SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL
      direction - 小于零向上/向左滚动，大于零向下/向右滚动
      返回：
      在指定方向滚动的“单位”增量
      参见：

    • getScrollableBlockIncrement

      public int getScrollableBlockIncrement(Rectangle  visibleRect, int orientation, int direction)
      返回 visibleRect.height 或 visibleRect.width ，具体取决于此表的方向。请注意，从 Swing 1.1.1（Java 2 v 1.2.2）开始，返回的值将确保视口在行边界上完全对齐。
      指定者：
      getScrollableBlockIncrement 在接口 Scrollable 中
      参数：
      visibleRect - 视口内可见的视图区域
      orientation - SwingConstants.VERTICAL 或 SwingConstants.HORIZONTAL。
      direction - 小于零向上/向左滚动，大于零向下/向右滚动。
      返回：
      visibleRect.height 或 visibleRect.width 根据方向
      参见：

    • getScrollableTracksViewportWidth

      @BeanProperty (bound =false) public boolean getScrollableTracksViewportWidth()
      如果 autoResizeMode 设置为 AUTO_RESIZE_OFF 则返回 false，这表示视口的宽度不决定表格的宽度。否则返回真。
      指定者：
      getScrollableTracksViewportWidth 在接口 Scrollable 中
      返回：
      如果 autoResizeMode 设置为 AUTO_RESIZE_OFF 则返回 false，否则返回 true
      参见：

    • getScrollableTracksViewportHeight

      @BeanProperty (bound =false) public boolean getScrollableTracksViewportHeight()
      返回 false 表示视口的高度不决定表格的高度，除非 getFillsViewportHeight 是 true 并且表格的首选高度小于视口的高度。
      指定者：
      getScrollableTracksViewportHeight 在接口 Scrollable 中
      返回：
      false 除非 getFillsViewportHeight 是 true 并且表格需要拉伸以填充视口
      参见：

    • setFillsViewportHeight

      @BeanProperty (description ="Whether or not this table is always made large enough to fill the height of an enclosing viewport") public void setFillsViewportHeight(boolean fillsViewportHeight)
      设置此表是否始终足够大以填充封闭视口的高度。如果表格的首选高度小于视口，则表格将被拉伸以填充视口。换句话说，这确保了表格永远不会小于视口。此属性的默认值为 false 。
      参数：
      fillsViewportHeight - 此表是否始终足够大以填充封闭视口的高度
      自从：
      1.6
      参见：

    • getFillsViewportHeight

      public boolean getFillsViewportHeight()
      返回此表是否始终足够大以填充封闭视口的高度。
      返回：
      此表是否总是足够大以填充封闭视口的高度
      自从：
      1.6
      参见：

    • createDefaultRenderers

      protected void createDefaultRenderers()
      为对象、数字、双精度数、日期、boolean和图标创建默认单元格渲染器。
      参见：

    • createDefaultEditors

      protected void createDefaultEditors()
      为对象、数字和boolean创建默认单元格编辑器。
      参见：

    • initializeLocalVars

      protected void initializeLocalVars()
      将表属性初始化为其默认值。

    • createDefaultDataModel

      protected TableModel  createDefaultDataModel()
      返回默认表模型对象，即 DefaultTableModel 。子类可以覆盖此方法以返回不同的表模型对象。
      返回：
      默认表模型对象
      参见：

    • createDefaultColumnModel

      protected TableColumnModel  createDefaultColumnModel()
      返回默认的列模型对象，它是一个 DefaultTableColumnModel 。子类可以覆盖此方法以返回不同的列模型对象。
      返回：
      默认列模型对象
      参见：

    • createDefaultSelectionModel

      protected ListSelectionModel  createDefaultSelectionModel()
      返回默认选择模型对象，即 DefaultListSelectionModel 。子类可以覆盖此方法以返回不同的选择模型对象。
      返回：
      默认选择模型对象
      参见：

    • createDefaultTableHeader

      protected JTableHeader  createDefaultTableHeader()
      返回默认表头对象，即 JTableHeader 。子类可以覆盖此方法以返回不同的表头对象。
      返回：
      默认表头对象
      参见：

    • resizeAndRepaint

      protected void resizeAndRepaint()
      相当于 revalidate 后跟 repaint 。

    • getCellEditor

      public TableCellEditor  getCellEditor()
      返回活动的单元格编辑器，如果表当前未在编辑，则为 null。
      返回：
      进行编辑的 TableCellEditor，如果表当前未在编辑，则为 null。
      参见：

    • setCellEditor

      @BeanProperty (description ="The table\'s active cell editor.") public void setCellEditor(TableCellEditor  anEditor)
      设置活动单元格编辑器。
      参数：
      anEditor - 活动单元格编辑器
      参见：

    • setEditingColumn

      public void setEditingColumn(int aColumn)
      设置 editingColumn 变量。
      参数：
      aColumn - 要编辑的单元格的列
      参见：

    • setEditingRow

      public void setEditingRow(int aRow)
      设置 editingRow 变量。
      参数：
      aRow - 要编辑的单元格行
      参见：

    • getCellRenderer

      public TableCellRenderer  getCellRenderer(int row, int column)
      为该行和列指定的单元格返回适当的渲染器。如果此列的 TableColumn 具有非空渲染器，则返回该渲染器。如果不是，则在此列中查找数据的类（使用 getColumnClass ）并返回此类数据的默认渲染器。

      笔记：在整个表包中，内部实现始终使用此方法来提供渲染器，以便子类可以安全地重写此默认行为。

      参数：
      row - 要呈现的单元格的行，其中 0 是第一行
      column - 要呈现的单元格的列，其中 0 是第一列
      返回：
      指定的渲染器；如果 null 返回此类对象的默认渲染器
      参见：

    • prepareRenderer

      public Component  prepareRenderer(TableCellRenderer  renderer, int row, int column)
      通过在 row 、 column 处查询单元格的值和选择状态的数据模型来准备渲染器。返回事件位置下的组件（可能是 Component 或 JComponent ）。

      在打印操作期间，此方法将配置渲染器而不指示选择或焦点，以防止它们出现在打印输出中。要根据表格是否正在打印进行其他自定义，您可以在此处或在自定义渲染器中检查 JComponent.isPaintingForPrint() 的值。

      笔记：在整个表包中，内部实现始终使用此方法来准备渲染器，以便子类可以安全地重写此默认行为。

      参数：
      renderer - TableCellRenderer 准备
      row - 要呈现的单元格的行，其中 0 是第一行
      column - 要呈现的单元格的列，其中 0 是第一列
      返回：
      活动地点下的Component

    • getCellEditor

      public TableCellEditor  getCellEditor(int row, int column)
      为 row 和 column 指定的单元格返回适当的编辑器。如果此列的 TableColumn 具有非空编辑器，则返回该编辑器。如果不是，则在此列中查找数据的类别（使用 getColumnClass ）并返回此类数据的默认编辑器。

      笔记：在整个表包中，内部实现始终使用此方法来提供编辑器，以便子类可以安全地重写此默认行为。

      参数：
      row - 要编辑的单元格的行，其中 0 是第一行
      column - 要编辑的单元格的列，其中 0 是第一列
      返回：
      该单元格的编辑器；如果null返回这种类型的单元格的默认编辑器
      参见：

    • prepareEditor

      public Component  prepareEditor(TableCellEditor  editor, int row, int column)
      通过在 row 、 column 处查询单元格的值和选择状态的数据模型来准备编辑器。

      笔记：在整个表包中，内部实现始终使用此方法来准备编辑器，以便子类可以安全地重写此默认行为。

      参数：
      editor - TableCellEditor 设置
      row - 要编辑的单元格的行，其中 0 是第一行
      column - 要编辑的单元格的列，其中 0 是第一列
      返回：
      正在编辑的Component

    • removeEditor

      public void removeEditor()
      丢弃编辑器对象并释放它用于单元格渲染的不动产。

    • paramString

      protected String  paramString()
      返回此表的字符串表示形式。此方法仅用于调试目的，返回字符串的内容和格式可能因实现而异。返回的字符串可能为空，但可能不是 null 。
      重写：
      paramString 在类 JComponent 中
      返回：
      此表的字符串表示形式

    • print

      public boolean print() throws PrinterException
      一种显示打印对话框的便捷方法，然后以 PrintMode.FIT_WIDTH 模式打印此 JTable，不带页眉或页脚文本。在打印期间将显示带有中止选项的模态进度对话框。

      注意：在无头模式下，不会显示任何对话框，并且会在默认打印机上进行打印。

      返回：
      true，除非用户取消打印
      抛出：
      SecurityException - 如果不允许此线程发起打印作业请求
      PrinterException - 如果打印系统中的错误导致作业中止
      自从：
      1.5
      参见：

    • print

      public boolean print(JTable.PrintMode  printMode) throws PrinterException
      一种显示打印对话框的便捷方法，然后以给定的打印模式打印此 JTable，不带页眉或页脚文本。在打印期间将显示带有中止选项的模态进度对话框。

      注意：在无头模式下，不会显示任何对话框，并且会在默认打印机上进行打印。

      参数：
      printMode - 可打印应使用的打印模式
      返回：
      true，除非用户取消打印
      抛出：
      SecurityException - 如果不允许此线程发起打印作业请求
      PrinterException - 如果打印系统中的错误导致作业中止
      自从：
      1.5
      参见：

    • print

      public boolean print(JTable.PrintMode  printMode, MessageFormat  headerFormat, MessageFormat  footerFormat) throws PrinterException
      一种显示打印对话框的便捷方法，然后在给定的打印模式下使用指定的页眉和页脚文本打印此 JTable。在打印期间将显示带有中止选项的模态进度对话框。

      注意：在无头模式下，不会显示任何对话框，并且会在默认打印机上进行打印。

      参数：
      printMode - 可打印应使用的打印模式
      headerFormat - 一个 MessageFormat 指定用于打印标题的文本，或 null 表示无
      footerFormat - MessageFormat 指定用于打印页脚的文本，或 null 表示无
      返回：
      true，除非用户取消打印
      抛出：
      SecurityException - 如果不允许此线程发起打印作业请求
      PrinterException - 如果打印系统中的错误导致作业中止
      自从：
      1.5
      参见：

    • print

      public boolean print(JTable.PrintMode  printMode, MessageFormat  headerFormat, MessageFormat  footerFormat, boolean showPrintDialog, PrintRequestAttributeSet  attr, boolean interactive) throws PrinterException , HeadlessException
      按照功能齐全的 print 方法指定的方式打印此表，并将默认打印机指定为打印服务。
      参数：
      printMode - 可打印应使用的打印模式
      headerFormat - MessageFormat 指定用于打印标题的文本，或 null 无
      footerFormat - MessageFormat 指定用于打印页脚的文本，或 null 无
      showPrintDialog - 是否显示打印对话框
      attr - PrintRequestAttributeSet 指定任何打印属性，或 null 无
      interactive - 是否以交互模式打印
      返回：
      true，除非用户取消打印
      抛出：
      HeadlessException - 如果要求方法显示打印对话框或交互运行，并且 GraphicsEnvironment.isHeadless 返回 true
      SecurityException - 如果不允许此线程发起打印作业请求
      PrinterException - 如果打印系统中的错误导致作业中止
      自从：
      1.5
      参见：

    • print

      public boolean print(JTable.PrintMode  printMode, MessageFormat  headerFormat, MessageFormat  footerFormat, boolean showPrintDialog, PrintRequestAttributeSet  attr, boolean interactive, PrintService  service) throws PrinterException , HeadlessException
      打印这个 JTable 。采取大多数开发人员为了打印 JTable 会采取的步骤。简而言之，它准备表格，调用 getPrintable 来获取适当的 Printable，然后将其发送到打印机。

      boolean 参数允许您指定是否向用户显示打印对话框。如果是，用户可以使用对话框更改目标打印机或打印属性，甚至取消打印。另外两个参数允许指定 PrintService 和打印属性。这些参数可用于为打印对话框提供初始值，或在未显示对话框时指定值。

      第二个 boolean 参数允许您指定是否以交互模式执行打印。如果 true ，则在打印期间显示带有中止选项的模态进度对话框。此对话框还可以防止可能影响表格的任何用户操作。但是，它不能防止表被代码修改（例如，另一个使用 SwingUtilities.invokeLater 发布更新的线程）。因此，开发人员有责任确保在打印期间没有其他代码以任何方式修改表格（无效修改包括更改：大小、渲染器或基础数据）。在打印期间更改表格时，打印行为未定义。

      如果为该参数指定false，则不会显示任何对话框，并且会立即在事件派发线程上开始打印。这会阻止任何其他事件（包括重绘）在打印完成之前进行处理。虽然这有效地防止了表被更改，但它并没有提供良好的用户体验。因此，仅当从没有可见 GUI 的应用程序打印时才建议指定 false。

      注意：在无头模式下尝试显示打印对话框或以交互方式运行，将导致 HeadlessException 。

      在获取可打印文件之前，此方法将在必要时优雅地终止编辑，以防止编辑器显示在打印结果中。此外，JTable 将在打印期间准备其渲染器，以便不指示选择和焦点。至于进一步自定义表格在打印输出中的外观，开发人员可以提供自定义渲染器或以 JComponent.isPaintingForPrint() 的值为条件的绘制代码。

      有关如何打印表格的更多说明，请参见 getPrintable(javax.swing.JTable.PrintMode, java.text.MessageFormat, java.text.MessageFormat) 。

      参数：
      printMode - 可打印应使用的打印模式
      headerFormat - MessageFormat 指定用于打印标题的文本，或 null 无
      footerFormat - MessageFormat 指定用于打印页脚的文本，或 null 无
      showPrintDialog - 是否显示打印对话框
      attr - PrintRequestAttributeSet 指定任何打印属性，或 null 无
      interactive - 是否以交互模式打印
      service - 目标 PrintService 或 null 使用默认打印机
      返回：
      true，除非用户取消打印
      抛出：
      HeadlessException - 如果要求方法显示打印对话框或交互运行，并且 GraphicsEnvironment.isHeadless 返回 true
      SecurityException - 如果安全管理器存在且其 SecurityManager.checkPrintJobAccess() 方法不允许此线程创建打印作业请求
      PrinterException - 如果打印系统中的错误导致作业中止
      自从：
      1.6
      参见：

    • getPrintable

      public Printable  getPrintable(JTable.PrintMode  printMode, MessageFormat  headerFormat, MessageFormat  footerFormat)
      返回一个 Printable 用于打印此 JTable。

      此方法适用于那些希望自定义 JTable 的 print 方法使用的默认 Printable 实现的用户。只想打印表格的开发人员应该直接使用其中一种方法。

      可以在两种打印模式之一中请求 Printable。在这两种模式下，它都会在多个页面上按顺序自然地分布表行，从而在每页中容纳尽可能多的行。 PrintMode.NORMAL 指定表格以其当前大小打印。在这种模式下，可能需要以与行的方式类似的方式将列跨页分布。当需要时，列以与表的 ComponentOrientation 一致的顺序分布。 PrintMode.FIT_WIDTH 指定在必要时将输出缩放得更小，以适应每一页上表格的整个宽度（以及所有列）。宽度和高度均等缩放，保持输出的纵横比。

      Printable 以表的 JTableHeader 中的相应部分（如果有的话）作为每一页表部分的开头。

      可以通过提供 MessageFormat 参数将页眉和页脚文本添加到输出中。打印代码从格式请求字符串，提供可能包含在格式化字符串中的单个项目：Integer 表示当前页码。

      我们鼓励您阅读 MessageFormat 的文档，因为某些字符（例如单引号）很特殊，需要转义。

      下面是创建可用于打印“Duke's Table: Page - ”和当前页码的 MessageFormat 的示例：

         // notice the escaping of the single quote
   // notice how the page number is included with "{0}"
   MessageFormat format = new MessageFormat("Duke''s Table: Page - {0}");

      Printable 将它绘制的内容限制在它打印的每一页的可打印区域。在某些情况下，它可能会发现无法将页面的所有内容都放入该区域。在这些情况下，输出可能会被剪裁，但实现会努力做一些合理的事情。以下是已知会发生这种情况的几种情况，以及此特定实现如何处理它们：

      • 在任何模式下，当页眉或页脚文本太宽而无法完全放入可打印区域时——从头开始打印尽可能多的文本，由表的 ComponentOrientation 确定。
      • 在任何模式下，当一行太高而无法放入可打印区域时——打印该行的最上部分并且不在表格上绘制下边框。
      • 在 PrintMode.NORMAL 中，当列太宽而无法放入可打印区域时 - 打印列的中心部分并离开表格的左右边框。

      将此 Printable 包裹在另一个中以创建复杂的报告和文档是完全有效的。您甚至可以请求将不同的页面渲染到不同大小的可打印区域。实现必须准备好处理这个问题（可能通过即时进行布局计算）。但是，当 PrintMode.NORMAL 必须跨页分布列时，为每个页面提供不同的高度可能效果不佳。

      至于自定义表格在打印结果中的外观，JTable 本身将负责在打印期间隐藏选择和焦点。对于其他自定义，您的渲染器或绘画代码可以根据 JComponent.isPaintingForPrint() 的值自定义外观

      还，before调用此方法您可能希望first修改表格的状态，例如取消单元格编辑或让用户适当调整表格大小。但是，您不得修改表的状态afterthis Printable 已被提取（无效修改包括大小或基础数据的更改）。一旦表被更改，返回的 Printable 的行为是不确定的。

      参数：
      printMode - 可打印应使用的打印模式
      headerFormat - 一个 MessageFormat 指定用于打印标题的文本，或 null 表示无
      footerFormat - MessageFormat 指定用于打印页脚的文本，或 null 表示无
      返回：
      Printable 用于打印此 JTable
      自从：
      1.5
      参见：

    • getAccessibleContext

      @BeanProperty (bound =false) public AccessibleContext  getAccessibleContext()
      获取与此 JTable 关联的 AccessibleContext。对于表，AccessibleContext 采用 AccessibleJTable 的形式。如有必要，将创建一个新的 AccessibleJTable 实例。
      指定者：
      getAccessibleContext 在接口 Accessible 中
      重写：
      getAccessibleContext 在类 Component 中
      返回：
      作为此 JTable 的 AccessibleContext 的 AccessibleJTable