Module  java.desktop
软件包  javax.swing

Class JTable

  • All Implemented Interfaces:
    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用于显示和编辑单元格的常规二维表。 请参阅Java教程中的 How to Use Tables ，了解面向任务的文档和使用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通常放在一个JScrollPane里面。 默认情况下， JTable将调整其宽度，以便不需要水平滚动条。 要允许一个水平滚动条， 请用AUTO_RESIZE_OFF调用AUTO_RESIZE_OFF 。 请注意，如果您希望使用JTable在一个独立的视图（A之外JScrollPane ），并想报头显示，你可以用得到它getTableHeader()并单独显示它。

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

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

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

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

    JTable使用整数来引用它显示的模型的行和列。 JTable只需要一个表格范围的单元格，并使用getValueAt(int, int)在绘制期间从模型中检索值。 重要的是要记住，各种JTable方法返回的列和行索引都是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 ，以便方便地访问一些常见的打印需求。 简单的新的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开始，支持所有JavaBeans的长期存储已被添加到java.beans包中。 请参阅XMLEncoder 。

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

    • 字段详细信息

      • AUTO_RESIZE_OFF

        public static final int AUTO_RESIZE_OFF
        不要自动调整色谱柱宽度; 使用水平滚动条代替。
        另请参见：
        Constant Field Values

      • AUTO_RESIZE_NEXT_COLUMN

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

      • AUTO_RESIZE_SUBSEQUENT_COLUMNS

        public static final int AUTO_RESIZE_SUBSEQUENT_COLUMNS
        在UI调整期间，更改后续列以保留总宽度; 这是默认行为。
        另请参见：
        Constant Field Values

      • AUTO_RESIZE_LAST_COLUMN

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

      • AUTO_RESIZE_ALL_COLUMNS

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

      • 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为true，表格会在单元格之间绘制垂直线。

      • 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的过时。 请使用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​(TableModel dm,
              TableColumnModel cm,
              ListSelectionModel sm)
        构造一个JTable ，它以dm作为数据模型初始化， cm作为列模型，以及sm作为选择模型。 如果任何参数为null此方法将使用相应的默认模型初始化表。 该autoCreateColumnsFromModel标志设置为false，如果cm非空，否则将被设置为true，列模型中填充了适合TableColumns的列dm 。
        参数
        dm - 表的数据模型
        cm - 表格的列模型
        sm - 表的行选择模型
        另请参见：
        createDefaultDataModel() ， createDefaultColumnModel() ， createDefaultSelectionModel()

      • 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)
        已过时。 截至Swing 1.0.2版，替换为new JScrollPane(aTable) 。
        相当于 new JScrollPane(aTable) 。
        参数
        aTable - 一个用于滚动窗格的 JTable
        结果
        一个 JScrollPane创建使用 aTable

      • setTableHeader

        @BeanProperty(description="The JTableHeader instance which renders the column headers.")
public void setTableHeader​(JTableHeader tableHeader)
        设置tableHeader使用这个JTable到newHeader 。 有一个null tableHeader是合法的。
        参数
        tableHeader - new 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​(Class<?> columnClass)
        返回在TableColumn未设置渲染器时要使用的单元格渲染器。 在渲染单元期间，根据列中单元格的类从Hashtable条目中提取渲染器。 如果没有这个columnClass的条目，该方法返回最具体的超类的条目。 该JTable安装用于条目Object ， Number ，和Boolean ，所有这些都可以被修改或替换。
        参数
        columnClass - 返回此columnClass的默认单元格渲染器
        结果
        这个columnClass的渲染器
        另请参见：
        setDefaultRenderer(java.lang.Class<?>, javax.swing.table.TableCellRenderer) ， getColumnClass(int)

      • getDefaultEditor

        public TableCellEditor getDefaultEditor​(Class<?> columnClass)
        返回在TableColumn未设置编辑器时使用的编辑器。 在编辑单元格期间，根据列中单元格的类从一个Hashtable的条目中获取编辑器。 如果这个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

        如果该组件有TransferHandler接受丢弃，则丢弃模式才有意义。

        参数
        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。
        参数
        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默认使用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 - 如果允许同时进行行和列选择，则为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 - 间隔的另一端
        异常
        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 - 间隔的一端
        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是有效索引， column true，并且选择该索引处的列（其中0是第一列）

      • isCellSelected

        public boolean isCellSelected​(int row,
                              int column)
        如果指定的索引在行和列的有效范围内并且选定了指定位置的单元格，则返回true。
        参数
        row - 正在查询的行
        column - 正在查询的列
        结果
        如果 row和 column是有效索引， column true，并且选择索引为 (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 - 如果为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到视图中列的索引。 返回视图中相应列的索引; 如果此列未显示，则返回-1。 如果modelColumnIndex小于零，则返回modelColumnIndex 。
        参数
        modelColumnIndex - 模型中列的索引
        结果
        视图中相应列的索引
        另请参见：
        convertColumnIndexToModel(int)

      • convertRowIndexToView

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

      • convertRowIndexToModel

        public int convertRowIndexToModel​(int viewRowIndex)
        将该视图的索引映射到基础TableModel 。 如果模型的内容没有被排序，模型和视图索引是相同的。
        参数
        viewRowIndex - 视图中行的索引
        结果
        模型中相应行的索引
        异常
        IndexOutOfBoundsException - 如果排序已启用，并通过方法 getRowCount确定的 JTable范围之外的索引
        从以下版本开始：
        1.6
        另请参见：
        TableRowSorter ， getRowCount()

      • getRowCount

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

      • getColumnName

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

      • getColumnClass

        public Class<?> getColumnClass​(int column)
        返回列位置 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 - 要更改的单元格的列
        另请参见：
        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的列模型所持有的列数组的末尾。 如果列名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，则返回的值具有指定的行和列的完整高度和宽度。 如果它是假的，则返回的矩形由单元间距插入，以返回渲染或编辑组件的真实界限，因为它将在渲染期间设置。

        如果列索引有效但行索引小于零，则该方法返回一个矩形，其中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对列的宽度进行调整时，它绝对遵守其最小值和最大值。 因此，即使在调用此方法之后，列的总宽度仍然不等于表的宽度。 当这种情况发生时， 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 [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。

        细节

        对这里给出的公式的初步评估将受到在有限精度（使用ints）中进行此操作而导致的总体舍入误差。 为了处理这个问题，上面的乘法因子是不断重新计算的，这也考虑了以前迭代中的舍入误差。 结果是产生一组整数的算法，其值与所提供的targetSize精确相加，并且通过在给定元素上均匀地扩展舍入误差来实现。

        当MAX和MIN界限被击中时

        当targetSize在[MIN，MAX]范围之外时，算法将所有大小设置为其适当的极限值（最大值或最小值）。

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

      • sizeColumnsToFit

        @Deprecated
public void sizeColumnsToFit​(boolean lastColumnOnly)
        已过时。 截至Swing 1.0.3版本，由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和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。
        结果
        如果表正在编辑单元格，则为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 - 此表的新数据源
        异常
        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 。

        请注意，从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 - 向上/向左滚动小于0，向下/向右大于零。
        结果
        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)

      • processKeyBinding

        protected boolean processKeyBinding​(KeyStroke ks,
                                    KeyEvent e,
                                    int condition,
                                    boolean pressed)
        描述从类复制： JComponent
        调用以处理键绑定为ks作为的结果KeyEvent e 。 获得适当的InputMap ，获取绑定，从ActionMap获取操作，然后（如果发现操作并且组件已启用）将调用notifyAction通知操作。
        重写：
        processKeyBinding在 JComponent
        参数
        ks - KeyStroke查询
        e - KeyEvent
        condition - 以下值之一：
        • JComponent.WHEN_FOCUSED
        • JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT
        • JComponent.WHEN_IN_FOCUSED_WINDOW
        pressed - 如果按下键，则为true
        结果
        如果对操作有约束力，并且该操作已启用，则为true

      • 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具有非空编辑器，则返回。 如果没有，请查找此列中的数据类（使用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 ，然后将其发送到打印机。

        A 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 for none
        footerFormat - 一个 MessageFormat指定要在打印页脚中使用的文本，或 null for none
        showPrintDialog - 是否显示打印对话框
        attr - 一个 PrintRequestAttributeSet指定任何打印属性，或 null无
        interactive - 是否以交互模式进行打印
        service - 目的地 PrintService或 null使用默认打印机
        结果
        除非用户取消打印，否则为true
        异常
        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 ，表格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本身将在打印期间JTable隐藏选择和对焦。 对于其他自定义，您的渲染器或绘画代码可以根据JComponent.isPaintingForPrint()的值自定义外观

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

        参数
        printMode - 可打印应使用的打印模式
        headerFormat - 一个 MessageFormat指定要在打印头中使用的文本，否则为null
        footerFormat - 指定要在打印页脚中使用的文本的 MessageFormat ，否则为null
        结果
        一个 Printable打印这个JTable
        从以下版本开始：
        1.5
        另请参见：
        print(JTable.PrintMode, MessageFormat, MessageFormat, boolean, PrintRequestAttributeSet, boolean) ， Printable ， PrinterJob