模块  java.desktop
软件包  javax.swing

Class 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用于显示和编辑常规的二维单元格表。 见How to Use Tables中的Java教程面向任务的文档和使用的例子JTable 。

    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调用AUTO_RESIZE_OFF 。 请注意，如果您希望在独立视图中使用JTable （在JScrollPane之外）并希望显示标题，则可以使用getTableHeader()获取它并单独显示它。

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

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

    在设计使用JTable应用程序时，值得密切关注将代表表格数据的数据结构。 DefaultTableModel是一个模型实现，它使用Vector的Vector s Object s来存储单元格值。 除了将数据从应用程序复制到DefaultTableModel ，还可以将数据包装在TableModel接口的方法中，以便数据可以直接传递到JTable ，如上例所示。 这通常会导致更高效的应用程序，因为模型可以自由选择最适合数据的内部表示。 决定是否使用AbstractTableModel或DefaultTableModel一个好的经验法则是使用AbstractTableModel作为创建子类的基类，而不需要子类DefaultTableModel时使用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将根据排序JTable保留选择和变量行高。 例如，如果当前选择了第0行（就基础模型而言），则在排序行0之后，将选择基础模型。 视觉上选择可能会改变，但就底层模型而言，它将保持不变。 唯一的例外是模型索引不再可见或被删除。 例如，如果过滤掉模型中的第0行，则排序后选择将为空。

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

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

    警告： Swing不是线程安全的。 有关更多信息，请参阅Swing's Threading Policy 。

    警告：此类的序列化对象与以后的Swing版本不兼容。 当前的序列化支持适用于运行相同版本Swing的应用程序之间的短期存储或RMI。 从1.4开始， java.beans软件包中添加了对所有JavaBeans java.beans长期存储的支持。 请参阅XMLEncoder 。

    从以下版本开始：
    1.2
    另请参见：
    DefaultTableModel ， TableRowSorter ， Serialized Form

    • 字段详细信息

      • 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
        如果此表中允许行选择，则为True。

      • cellSelectionEnabled

        protected boolean cellSelectionEnabled
        从Java 2平台v1.3开始已过时。 请使用rowSelectionAllowed属性和columnSelectionAllowed的财产columnModel代替。 或者使用方法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
        显示单元格内容的对象表，由 TableModel界面中 getColumnClass中声明的类索引。

      • defaultEditorsByColumnClass

        protected transient Hashtable<Object,​Object> defaultEditorsByColumnClass
        显示和编辑单元格内容的对象表，由 TableModel界面中 getColumnClass中声明的类索引。

      • selectionForeground

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

      • selectionBackground

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

    • 构造方法详细信息

      • JTable

        public JTable​(int numRows,
              int numColumns)
        使用numRows构建JTable其中numRows和numColumns为空单元DefaultTableModel 。 列将具有“A”，“B”，“C”等形式的名称。
        参数
        numRows - 表所包含的行数
        numColumns - 表所包含的列数
        另请参见：
        DefaultTableModel

      • JTable

        public JTable​(Vector<? extends Vector> rowData,
              Vector<?> columnNames)
        构造一个JTable以显示的值Vector的Vectors ， rowData ，其列名称为columnNames 。 Vectors包含的rowData应包含该行的值。 换句话说，可以使用以下代码获得第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 - 每列的名称

    • 方法详细信息

      • configureEnclosingScrollPane

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

      • unconfigureEnclosingScrollPane

        protected void unconfigureEnclosingScrollPane()
        逆转的效果configureEnclosingScrollPane通过更换columnHeaderView与封闭滚动窗格null 。 JTable的removeNotify方法调用此方法，这是受保护的，使得此默认卸载过程可以由子类所覆盖。
        从以下版本开始：
        1.3
        另请参见：
        removeNotify() ， configureEnclosingScrollPane()

      • createScrollPaneForTable

        @Deprecated
public static JScrollPane createScrollPaneForTable​(JTable aTable)
        Deprecated.
        As of Swing version 1.0.2, replaced by new JScrollPane(aTable).
        相当于 new JScrollPane(aTable) 。
        参数
        aTable - 用于滚动窗格的 JTable
        结果
        a JScrollPane使用 aTable创建

      • setTableHeader

        @BeanProperty(description="The JTableHeader instance which renders the column headers.")
public void setTableHeader​(JTableHeader tableHeader)
        设置tableHeader这个工作JTable至newHeader 。 拥有null tableHeader是合法的。
        参数
        tableHeader - 新tableHeader
        另请参见：
        getTableHeader()

      • setRowHeight

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

      • getRowHeight

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

      • 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 。
        参数
        row - 要返回其高度的行
        结果
        行中单元格的高度（以像素为单位）
        从以下版本开始：
        1.3

      • setRowMargin

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

      • getRowMargin

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

      • 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()

      • getIntercellSpacing

        public Dimension getIntercellSpacing()
        返回单元格之间的水平和垂直空间。 默认间距取决于外观。
        结果
        细胞之间的水平和垂直间距
        另请参见：
        setIntercellSpacing(java.awt.Dimension)

      • setGridColor

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

      • getGridColor

        public Color getGridColor()
        返回用于绘制网格线的颜色。 默认颜色取决于外观。
        结果
        用于绘制网格线的颜色
        另请参见：
        setGridColor(java.awt.Color)

      • setShowGrid

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

      • setShowHorizontalLines

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

      • setShowVerticalLines

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

      • getShowHorizontalLines

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

      • getShowVerticalLines

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

      • 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() ， doLayout()

      • getAutoResizeMode

        public int getAutoResizeMode()
        返回表的自动调整大小模式。 默认模式为AUTO_RESIZE_SUBSEQUENT_COLUMNS。
        结果
        表的autoResizeMode
        另请参见：
        setAutoResizeMode(int) ， doLayout()

      • 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应自动创建列， autoCreateColumnsFromModel true
        另请参见：
        getAutoCreateColumnsFromModel() ， createDefaultColumnsFromModel()

      • getAutoCreateColumnsFromModel

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

      • createDefaultColumnsFromModel

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

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

        另请参见：
        getAutoCreateColumnsFromModel()

      • getDefaultRenderer

        public TableCellRenderer getDefaultRenderer​(类<?> columnClass)
        返回在TableColumn未设置渲染器时要使用的单元格渲染器。 在渲染单元格期间，根据列中单元格的类从Hashtable个条目中提取渲染器。 如果此columnClass没有条目， columnClass该方法返回最具体超类的条目。 该JTable安装用于条目Object ， Number ，和Boolean ，所有这些都可以被修改或替换。
        参数
        columnClass - 返回此columnClass的默认单元格渲染器
        结果
        此columnClass的渲染器
        另请参见：
        setDefaultRenderer(java.lang.Class<?>, javax.swing.table.TableCellRenderer) ， getColumnClass(int)

      • getDefaultEditor

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

      • 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会对选择的行为产生微妙的影响。

        如果一个外观使用的是忽略这个属性，你仍然可以开始拖拽，并通过调用拖放操作exportAsDrag在桌子上的TransferHandler 。

        参数
        b - 是否启用自动拖动处理
        异常
        HeadlessException - 如果 b是 true和 GraphicsEnvironment.isHeadless()返回 true
        从以下版本开始：
        1.4
        另请参见：
        GraphicsEnvironment.isHeadless() ， getDragEnabled() ， JComponent.setTransferHandler(javax.swing.TransferHandler) ， TransferHandler

      • getDragEnabled

        public boolean getDragEnabled()
        返回是否启用自动拖动处理。
        结果
        dragEnabled属性的值
        从以下版本开始：
        1.4
        另请参见：
        setDragEnabled(boolean)

      • 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

        只有当此组件具有接受drop的TransferHandler ，drop mode才有意义。

        参数
        dropMode - 要使用的放置模式
        异常
        IllegalArgumentException - 如果不支持丢弃模式或 null
        从以下版本开始：
        1.6
        另请参见：
        getDropMode() ， getDropLocation() ， JComponent.setTransferHandler(javax.swing.TransferHandler) ， TransferHandler

      • getDropLocation

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

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

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

        结果
        下降的位置
        从以下版本开始：
        1.6
        另请参见：
        setDropMode(javax.swing.DropMode) ， TransferHandler.canImport(TransferHandler.TransferSupport)

      • 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
        另请参见：
        TableRowSorter

      • getAutoCreateRowSorter

        public boolean getAutoCreateRowSorter()
        如果模型更改，则返回true ，应创建新的RowSorter并将其安装为表的分拣机; 否则，返回false 。
        结果
        如果在模型更改时应创建 RowSorter true
        从以下版本开始：
        1.6

      • setUpdateSelectionOnSort

        @BeanProperty(expert=true,
              description="Whether or not to update the selection on sorting")
public void setUpdateSelectionOnSort​(boolean update)
        指定在排序后是否应更新选择。 如果为true，则在重新排序时重置选择，以便在模型方面保持选择相同的行。 默认值为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
        另请参见：
        TableRowSorter

      • 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的行和列选择模型JTable默认使用DefaultListSelectionModel以便JTable工作方式与JList相同。 见setSelectionMode的方法JList有关模式的详细信息。

        参数
        selectionMode - 行和列选择模型使用的模式
        另请参见：
        JList.setSelectionMode(int)

      • setRowSelectionAllowed

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

      • getRowSelectionAllowed

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

      • setColumnSelectionAllowed

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

      • getColumnSelectionAllowed

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

      • setCellSelectionEnabled

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

      • getCellSelectionEnabled

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

      • selectAll

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

      • clearSelection

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

      • setRowSelectionInterval

        public void setRowSelectionInterval​(int index0,
                                    int index1)
        选择从 index0到 index1 （含）的行。
        参数
        index0 - 间隔的一端
        index1 - 间隔的另一端
        异常
        IllegalArgumentException - 如果 index0或 index1位于[ getRowCount() -1]之外

      • setColumnSelectionInterval

        public void setColumnSelectionInterval​(int index0,
                                       int index1)
        选择 index0到 index1 （包括 index0和 index1的列。
        参数
        index0 - 间隔的一端
        index1 - 间隔的另一端
        异常
        IllegalArgumentException - 如果 index0或 index1在[ getColumnCount() -1]之外

      • addRowSelectionInterval

        public void addRowSelectionInterval​(int index0,
                                    int index1)
        将 index0到 index1 （包括）的行添加到当前选择中。
        参数
        index0 - 间隔的一端
        index1 - 间隔的另一端
        异常
        IllegalArgumentException - 如果 index0或 index1在[ getRowCount() -1]之外

      • addColumnSelectionInterval

        public void addColumnSelectionInterval​(int index0,
                                       int index1)
        将 index0到 index1 （包括）的列添加到当前选择中。
        参数
        index0 - 间隔的一端
        index1 - 间隔的另一端
        异常
        IllegalArgumentException - 如果 index0或 index1位于[ getColumnCount() -1]之外

      • removeRowSelectionInterval

        public void removeRowSelectionInterval​(int index0,
                                       int index1)
        取消选择从 index0到 index1 （包括 index0的行。
        参数
        index0 - 间隔的一端
        index1 - 间隔的另一端
        异常
        IllegalArgumentException - 如果 index0或 index1位于[ getRowCount() -1]之外

      • removeColumnSelectionInterval

        public void removeColumnSelectionInterval​(int index0,
                                          int index1)
        取消选择 index0到 index1 （含）的列。
        参数
        index0 - 间隔的一端
        index1 - 间隔的另一端
        异常
        IllegalArgumentException - 如果 index0或 index1位于[ 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()
        返回所有选定行的索引。
        结果
        包含所有选定行的索引的整数数组，如果没有选择行，则为空数组
        另请参见：
        getSelectedRow()

      • getSelectedColumns

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

      • 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是第一行），则 row true

      • isColumnSelected

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

      • isCellSelected

        public boolean isCellSelected​(int row,
                              int column)
        如果指定的索引位于行和列的有效范围内并且选择了指定位置的单元格，则返回true。
        参数
        row - 正在查询的行
        column - 要查询的列
        结果
        如果 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 ： 是的 。 将先前的选择从锚点扩展到指定的单元格，清除所有其他选择。
        • toggle ： true ， extend ： false 。 如果选择了指定的单元格，请取消选择它。 如果未选中，请选择它。
        • toggle ： true ， extend ： true 。 将锚点的选择状态应用于它与指定单元格之间的所有单元格。
        参数
        rowIndex - 影响选择 row
        columnIndex - 影响选择 column
        toggle - 参见上面的描述
        extend - 如果为true，则扩展当前选择
        从以下版本开始：
        1.3

      • getColumn

        public TableColumn getColumn​(Object identifier)
        返回 TableColumn对象在其标识符等于表中的列 identifier使用相比时， equals 。
        参数
        identifier - 标识符对象
        结果
        与标识符匹配的 TableColumn对象
        异常
        IllegalArgumentException - 如果 identifier是 null或者没有 TableColumn具有该标识符

      • convertColumnIndexToModel

        public int convertColumnIndexToModel​(int viewColumnIndex)
        将视图中列的索引（ viewColumnIndex到表模型中列的索引。 返回模型中相应列的索引。 如果viewColumnIndex小于零，则返回viewColumnIndex 。
        参数
        viewColumnIndex - 视图中列的索引
        结果
        模型中相应列的索引
        另请参见：
        convertColumnIndexToView(int)

      • convertColumnIndexToView

        public int convertColumnIndexToView​(int modelColumnIndex)
        将表模型中modelColumnIndex的索引（ modelColumnIndex到视图中列的索引。 返回视图中相应列的索引; 如果未显示此列，则返回-1。 如果modelColumnIndex小于零，则返回modelColumnIndex 。
        参数
        modelColumnIndex - 模型中列的索引
        结果
        视图中相应列的索引
        另请参见：
        convertColumnIndexToModel(int)

      • convertRowIndexToView

        public int convertRowIndexToView​(int modelRowIndex)
        将TableModel的行索引TableModel到视图。 如果未对模型的内容进行排序，则模型和视图索引是相同的。
        参数
        modelRowIndex - 模型方面的行索引
        结果
        视图中相应行的索引，如果该行不可见，则返回-1
        异常
        IndexOutOfBoundsException - 如果启用排序并传递超出 TableModel行数的 TableModel
        从以下版本开始：
        1.6
        另请参见：
        TableRowSorter

      • convertRowIndexToModel

        public int convertRowIndexToModel​(int viewRowIndex)
        将视图中行的索引映射到基础TableModel 。 如果未对模型的内容进行排序，则模型和视图索引是相同的。
        参数
        viewRowIndex - 视图中行的索引
        结果
        模型中相应行的索引
        异常
        IndexOutOfBoundsException - 如果启用排序并传递超出 JTable范围的 JTable （由方法 getRowCount确定）
        从以下版本开始：
        1.6
        另请参见：
        TableRowSorter ， getRowCount()

      • getRowCount

        @BeanProperty(bound=false)
public int getRowCount()
        给定无限空间，返回JTable可显示的行数。 如果指定了带过滤器的RowSorter ，则返回的行数可能与基础TableModel的行数不同。
        结果
        JTable显示的行数
        另请参见：
        getColumnCount()

      • getColumnName

        public String getColumnName​(int column)
        返回列位置 column显示的列的名称。
        参数
        column - 要查询的视图中的列
        结果
        第一 column第0列的视图中位置 column的列名称

      • getColumnClass

        public 类<?> getColumnClass​(int column)
        返回列位置 column显示的列的类型。
        参数
        column - 正在查询的视图中的列
        结果
        第一 column第0列的视图中位置 column处的列类型

      • getValueAt

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

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

        参数
        row - 要查询其值的行
        column - 要查询其值的列
        结果
        指定单元格中的Object

      • setValueAt

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

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

        参数
        aValue - 新值
        row - 要更改的单元格的行
        column - 要更改的单元格的列
        另请参见：
        getValueAt(int, int)

      • isCellEditable

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

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

        参数
        row - 要查询其值的行
        column - 要查询其值的列
        结果
        如果单元格是可编辑的，则为true
        另请参见：
        setValueAt(java.lang.Object, int, int)

      • addColumn

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

        要添加一列到这个JTable显示modelColumn在一个给定的模型数据的“列width ， cellRenderer和cellEditor ，您可以使用： 

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

      • removeColumn

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

      • moveColumn

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

      • columnAtPoint

        public int columnAtPoint​(Point point)
        返回 point所在列的索引，如果结果不在[ getColumnCount() -1]范围内，则 getColumnCount() -1。
        参数
        point - 感兴趣的地点
        结果
        point所在列的索引，如果结果不在[ getColumnCount() -1]范围内， getColumnCount() -1
        另请参见：
        rowAtPoint(java.awt.Point)

      • rowAtPoint

        public int rowAtPoint​(Point point)
        返回 point所在行的索引，如果结果不在[ getRowCount() -1]范围内，则 getRowCount() -1。
        参数
        point - 感兴趣的地点
        结果
        point所在行的索引，如果结果不在[ getRowCount() -1]范围内， getRowCount() -1
        另请参见：
        columnAtPoint(java.awt.Point)

      • getCellRect

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

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

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

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

      • doLayout

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

        在布局开始之前，该方法获得resizingColumn的tableHeader 。 由于调整封闭窗口的大小而调用该方法时， resizingColumn为null 。 这意味着调整大小发生在JTable “外部”，并且更改 - 或“delta” - 应该分配给所有列，而不管这个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是一个私有接口，它允许任何包含大小，首选大小，最大大小和最小大小的元素集合的数据结构使其元素由算法操纵。

        分发三角洲

        概观

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

        定义

        调用单个约束min [i]，max [i]和pref [i]。

        调用各自的总和：MIN，MAX和PREF。

        每个新尺寸将使用以下公式计算： 

          size[i] = pref[i] + delta[i]
        其中每个delta delta [i]的计算依据：

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

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

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

        细节

        这里给出的公式的朴素评估将受到以有限精度（使用整数）执行此操作所导致的聚合舍入误差的影响。 为了解决这个问题，不断重新计算上面的乘法因子，并考虑到前一次迭代中的舍入误差。 结果是一个算法，它产生一组整数，其值与提供的targetSize完全相加，并通过在给定元素上均匀分布舍入误差来实现。

        当MAX和MIN界限被击中时

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

        重写：
        doLayout类 Container
        另请参见：
        LayoutManager.layoutContainer(java.awt.Container) ， Container.setLayout(java.awt.LayoutManager) ， Container.validate()

      • sizeColumnsToFit

        @Deprecated
public void sizeColumnsToFit​(boolean lastColumnOnly)
        Deprecated.
        As of Swing version 1.0.3, replaced by doLayout().
        调整表格列的大小以适合可用空间。
        参数
        lastColumnOnly - 确定是否仅调整最后一列的大小
        另请参见：
        doLayout()

      • sizeColumnsToFit

        public void sizeColumnsToFit​(int resizingColumn)
        从Java 2平台v1.4开始已过时。 请改用doLayout()方法。
        参数
        resizingColumn - 调整大小时必须进行此调整的列;如果没有此类列，则调整为-1
        另请参见：
        doLayout()

      • getToolTipText

        public String getToolTipText​(MouseEvent event)
        覆盖JComponent的getToolTipText方法，以便在具有文本集的情况下允许使用渲染器的提示。

        注意： JTable正确显示其渲染器工具提示JTable必须是注册的组件ToolTipManager 。 这在initializeLocalVars自动initializeLocalVars ，但如果稍后JTable被告知setToolTipText(null) ，它将取消setToolTipText(null)组件，并且不再显示渲染器的提示。

        重写：
        getToolTipText在类 JComponent
        参数
        event -该 MouseEvent发起 ToolTip显示器
        结果
        包含工具提示的字符串
        另请参见：
        JComponent.getToolTipText()

      • setSurrendersFocusOnKeystroke

        public void setSurrendersFocusOnKeystroke​(boolean surrendersFocusOnKeystroke)
        设置当由于JTable转发单元的键盘事件而激活编辑器时，此JTable中的编辑器是否获得键盘焦点。 默认情况下，此属性为false，并且除非单击单元格，否则JTable将保留焦点。
        参数
        surrendersFocusOnKeystroke - 如果编辑器在击键导致编辑器被激活时应该获得焦点， surrendersFocusOnKeystroke true
        从以下版本开始：
        1.4
        另请参见：
        getSurrendersFocusOnKeystroke()

      • getSurrendersFocusOnKeystroke

        public boolean getSurrendersFocusOnKeystroke()
        如果编辑器在击键导致激活编辑器时获得焦点，则返回true
        结果
        如果编辑器在击键导致编辑器被激活时应该获得焦点，则为true
        从以下版本开始：
        1.4
        另请参见：
        setSurrendersFocusOnKeystroke(boolean)

      • editCellAt

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

      • editCellAt

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

      • isEditing

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

      • getEditorComponent

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

      • getEditingColumn

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

      • getEditingRow

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

      • getUI

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

      • updateUI

        public void updateUI()
        来自UIManager的L＆F已经改变的通知。 使用UIManager的最新版本替换当前UI对象。
        重写：
        updateUI类 JComponent
        另请参见：
        JComponent.updateUI()

      • setModel

        @BeanProperty(description="The model that is the source of the data for this view.")
public void setModel​(TableModel dataModel)
        将此表的数据模型设置为 dataModel并 dataModel注册以获取来自新数据模型的侦听器通知。
        参数
        dataModel - 此表的新数据源
        异常
        IllegalArgumentException - 如果 dataModel是 null
        另请参见：
        getModel()

      • setColumnModel

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

      • tableChanged

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

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

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

        Specified by:
        tableChanged在接口 TableModelListener
        参数
        e - 一个 TableModelEvent用于通知侦听器表模型已更改

      • columnMarginChanged

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

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

        Specified by:
        columnMarginChanged在接口 TableColumnModelListener
        参数
        e - 收到的活动
        另请参见：
        TableColumnModelListener

      • editingStopped

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

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

        Specified by:
        editingStopped在接口 CellEditorListener
        参数
        e - 收到的活动
        另请参见：
        CellEditorListener

      • editingCanceled

        public void editingCanceled​(ChangeEvent e)
        取消编辑时调用。 将丢弃编辑器对象，并再次呈现单元格。

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

        Specified by:
        editingCanceled接口 CellEditorListener
        参数
        e - 收到的活动
        另请参见：
        CellEditorListener

      • getScrollableUnitIncrement

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

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

        Specified by:
        getScrollableUnitIncrement在接口 Scrollable
        参数
        visibleRect - 视口中可见的视图区域
        orientation - SwingConstants.VERTICAL或 SwingConstants.HORIZONTAL
        direction - 向上/向左滚动小于零，向下/向右滚动大于零
        结果
        用于在指定方向上滚动的“单位”增量
        另请参见：
        Scrollable.getScrollableUnitIncrement(java.awt.Rectangle, int, int)

      • getScrollableBlockIncrement

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

      • 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() ， getScrollableTracksViewportHeight()

      • getFillsViewportHeight

        public boolean getFillsViewportHeight()
        返回此表是否总是足够大以填充封闭视口的高度。
        结果
        此表是否总是足够大以填充封闭视口的高度
        从以下版本开始：
        1.6
        另请参见：
        setFillsViewportHeight(boolean)

      • createDefaultRenderers

        protected void createDefaultRenderers()
        为对象，数字，双精度数，日期，布尔值和图标创建默认单元格渲染器。
        另请参见：
        DefaultTableCellRenderer

      • createDefaultEditors

        protected void createDefaultEditors()
        为对象，数字和布尔值创建默认单元格编辑器。
        另请参见：
        DefaultCellEditor

      • initializeLocalVars

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

      • createDefaultDataModel

        protected TableModel createDefaultDataModel()
        返回默认的表模型对象，即DefaultTableModel 。 子类可以重写此方法以返回不同的表模型对象。
        结果
        默认的表模型对象
        另请参见：
        DefaultTableModel

      • createDefaultColumnModel

        protected TableColumnModel createDefaultColumnModel()
        返回默认的列模型对象，即DefaultTableColumnModel 。 子类可以重写此方法以返回不同的列模型对象。
        结果
        默认的列模型对象
        另请参见：
        DefaultTableColumnModel

      • createDefaultSelectionModel

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

      • createDefaultTableHeader

        protected JTableHeader createDefaultTableHeader()
        返回默认的表头对象，即JTableHeader 。 子类可以重写此方法以返回不同的表头对象。
        结果
        默认表头对象
        另请参见：
        JTableHeader

      • resizeAndRepaint

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

      • getCellEditor

        public TableCellEditor getCellEditor()
        返回活动单元格编辑器，如果表当前未编辑，则为 null 。
        结果
        该 TableCellEditor ，做编辑，或 null如果表当前没有被编辑。
        另请参见：
        cellEditor ， getCellEditor(int, int)

      • setEditingColumn

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

      • setEditingRow

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

      • 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具有非null编辑器，则返回该编辑器。 如果没有，则在此列中查找数据类（使用getColumnClass ）并返回此类数据的默认编辑器。

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

        参数
        row - 要编辑的单元格的行，其中0是第一行
        column - 要编辑的单元格的列，其中0是第一列
        结果
        这个小区的编辑; 如果null返回此类单元格的默认编辑器
        另请参见：
        DefaultCellEditor

      • 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​(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
        结果
        是的，除非用户取消打印
        异常
        HeadlessException - 如果要求方法显示打印对话框或以交互方式运行，则 GraphicsEnvironment.isHeadless将返回 true
        SecurityException - 如果存在安全管理器且其 SecurityManager.checkPrintJobAccess()方法不允许此线程创建打印作业请求
        PrinterException - 如果打印系统中的错误导致作业中止
        从以下版本开始：
        1.6
        另请参见：
        getPrintable(javax.swing.JTable.PrintMode, java.text.MessageFormat, java.text.MessageFormat) ， GraphicsEnvironment.isHeadless()

      • getPrintable

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

        此方法适用于希望自定义JTable的print方法使用的默认Printable实现的print 。 想要简单地打印表的开发人员应该直接使用这些方法之一。

        可以通过两种打印模式之一请求Printable 。 在这两种模式中，它在多个页面中按顺序自然地传播表行，每页尽可能多地排列行。 PrintMode.NORMAL指定以当前大小打印表。 在这种模式下，可能需要以与行的方式类似的方式在页面之间传播列。 当需要时，列按照与表ComponentOrientation一致的顺序ComponentOrientation 。 PrintMode.FIT_WIDTH指定在必要时缩小输出以适合每个页面上的表的整个宽度（以及所有列）。 宽度和高度均等缩放，保持输出的纵横比。

        Printable使用表JTableHeader的相应部分（如果有的话）对每页的表格部分进行处理。

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

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

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

          // 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将其绘制的Printable限制为打印的每个页面的可打印区域。 在某些情况下，它可能会发现无法将所有页面内容放入该区域。 在这些情况下，输出可能会被剪切，但实现会努力做一些合理的事情。 以下是一些已知会发生这种情况的情况，以及这种特定实现如何处理它们：

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

        将Printable包装在另一个内部以创建复杂的报告和文档完全有效。 您甚至可以请求将不同的页面呈现为不同大小的可打印区域。 实现必须准备好处理这个（可能通过动态进行布局计算）。 但是，当必须跨页面传播列时，为每个页面提供不同的高度可能不适用于PrintMode.NORMAL 。

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

        此外， 在调用此方法之前，您可能希望首先修改表的状态，例如取消单元格编辑或让用户适当地调整表的大小。 但是，在获取此Printable 之后 ，您不得修改表的状态（无效修改包括大小或基础数据的更改）。 更改表后，返回的Printable的行为未定义。

        参数
        printMode - 可打印应使用的打印模式
        headerFormat - MessageFormat指定要在打印标题时使用的文本，如果没有则为null
        footerFormat - MessageFormat指定要在打印页脚时使用的文本，如果没有则为null
        结果
        用于打印此JTable的 Printable
        从以下版本开始：
        1.5
        另请参见：
        print(JTable.PrintMode, MessageFormat, MessageFormat, boolean, PrintRequestAttributeSet, boolean) ， Printable ， PrinterJob