本文目录一览：
如何用java应用程序创建表格
多少有点麻烦
建意不要用java来实现
JTable 组件:
类层次结构图：
java.lang.Object
--java.awt.Component
--java.awt.Container
--javax.swing.JComponent
--javax.swing.JTabel
在使用 JTable 以前，我们先看一下它的构造函数有哪些， 以及应该如何使用：
JTabel 构造函数：
JTable():建立一个新的 JTables,并使用系统默认的 Model.
JTable(int numRows,int numColumns):建立一个具有 numRows 行，numColumns 列的空表格，
使用的是 DefaultTableModel.
JTable(Object[ ][ ] rowData,Object[ ][ ] columnNames):建立一个显示二维数组数据的表格，且可
以显示列的名称。
JTable(TableModeldm):建立一个 JTable,有默认的字段模式以及选择模式，并设置数据模式。
JTable(TableModeldm,TableColumnModel cm):建立一个 JTable,设置数据模式与字段模式，并
有默认的选择模式。
JTable(TableModel dm,TableColumnModel cm,ListSelectionModel sm):建立一个 JTable,设置数
据模式、字段模式、与选择模式。
JTable(Vector rowData,Vector columnNames):建立一个以 Vector 为输入来源的数据表格，可显
示行的名称。
我们先以 Array 构造方式，说明如何利用 JTable 来建立一个简单的表格:
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class SimpleTable{
public SimpleTable(){
JFrame f=new JFrame();
Object[ ][ ] playerInfo={
{" 阿 呆 ",new Integer(66),new Integer(32),new Integer(98),new
Boolean(false)},
{"阿呆",new Integer(82),new Integer(69),new Integer(128),new
Boolean(true)},
};
String[ ] Names={"姓名","语文","数学","总分","及格"};
JTable table=new JTable(playerInfo,Names);
table.setPreferredScrollableViewportSize(new Dimension(550,30));
JScrollPane scrollPane=new JScrollPane(table);
f.getContentPane().add(scrollPane,BorderLayout.CENTER);
f.setTitle("SimpleTable");
f.pack();
f.show();
f.addWindowListener(newWindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String[] args){
SimpleTable b=new SimpleTable();
}
}
表格由两部份组成:分别是行标题(Column Header)与行对象(Column Object).利用 JTable
所提供的 getTableHeader()方法取得行标题。在这个例子中，我们将 JTable 放在 JScrollPane
中，这种做法可以将 Column Header 与 Colmn Object 完整的显示出来,因为 JScrollPane 会自
动 取 得 Column Header. 但 如 果 文 坛 读 者 将 上 面 第 15 行 去 掉 并 修 改 第 16 行 :
f.getContentPane().add(table,BorderLayout.CENTER);
则运行结果你会发现 Column Header 不见了。
如果你不想用 JScrollPane,要解决这个问题，你必须将程序修改如下:
JTable table=new JTable(p,n);
table.setPreferredScrollableViewportSize(new Dimension(550,30));
f.getContentPane().add(table.getTableHeader(),BorderLayout.NORTH);
f.getContentPane().add(table,BorderLayout.CENTER);
运行结果就会跟之前一样有行标题了.
上面的运行结果就会跟发现，每个字段的宽度都是一样的，除非你自行拉曳某个列宽。若
我们想一开始就设置列宽的值，可以利
用 TableColumn 类所提供的 setPreferredWidth()方法来设置，并可利用 JTable 类所提供的
setAutoResizeMode()方法来设置调整某个
列宽时其他列宽的变化情况，我们看下面这个例子:
import javax.swing.*;
import javax.swing.table.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;
public class SimpleTable2{
public SimpleTable2(){
JFrame f=new JFrame();
Object[][] p={
{" 阿 呆 ",new Integer(66),new Integer(32),new Integer(98),new
Boolean(false),new Boolean(false)},
{" 阿 呆 ",new Integer(82),new Integer(69),new Integer(128),new
Boolean(true),new Boolean(false)},
};
String[] n={"姓名","语文","数学","总分","及格","作弊"};
TableColumn column=null;
JTable table=new JTable(p,n);
table.setPreferredScrollableViewportSize(new Dimension(550,30));
table.setAutoResizeMode(JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS);
for (int i=0;i6;i++){
//利用 JTable 中的 getColumnModel()方法取得 TableColumnModel 对象;再利用
TableColumnModel 界面所定义的 getColumn()方法取
//TableColumn 对象,利用此对象的 setPreferredWidth()方法就可以控制字段的宽度.
column=table.getColumnModel().getColumn(i);
if ((i%2)==0)
column.setPreferredWidth(150);
else
column.setPreferredWidth(50);
}
JScrollPane scrollPane=new JScrollPane(table);
f.getContentPane().add(scrollPane,BorderLayout.CENTER);
f.setTitle("SimpleTable");
f.pack();
f.show();
f.setVisible(true);
f.addWindowListener(newWindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String[] args){
new SimpleTable2();
}
}
列可调整的 5 个参数：
AUTO_RESIZE_SUBSEQUENT_COLUMENS:当调整某一列宽时，此字段之后的所有字段列
宽都会跟着一起变动。此为系统默认值。
AUTO_RESIZE_ALL_COLUMNS:当调整某一列宽时，此表格上所有字段的列宽都会跟着一
起变动。
AUTO_RESIZE_OFF:当调整某一列宽时，此表格上所有字段列宽都不会跟着改变。
AUTO_RESIZE_NEXT_COLUMN:当调整某一列宽时，此字段的下一个字段的列宽会跟着改
变，其余均不会变。
AUTO_RESIZE_LAST_COLUMN:当调整某一列宽时，最后一个字段的列宽会跟着改变，其
余均不会改变。
由以上范例可知,利用 Swing 来构造一个表格其实很简单的，只要你利用 Vector 或 Array
来作为我们表格的数据输入，将 Vector 或 Array 的
内容填入 JTable 中，一个基本的表格就产生了。不过，虽然利用 JTable(Object[][]
rowData,Object[][] columnNames)以及
JTable(Vector rowData,Vector columnNames)构造函数来构造构造 JTable 很方便,但却有些缺
点。例如上例中，我们表格中的每个字段
(cell)一开始都是默认为可修改的，用户因此可能修改到我们的数据;其次，表格中每个单元
(cell)中的数据类型将会被视为同一种。在我
们的例子中，数据类型皆被显示为 String 的类型，因此，原来的数据类型声明为 Boolean 的
数据会以 String 的形式出现而不是以检查框(
Check Box)出现。
除此之外，如果我们所要显示的数据是不固定的，或是随情况而变，例如同样是一份成绩
单，老师与学生所看到的表格就不会一样，显
示的外观或操作模式也许也不相同。为了因应这些种种复杂情况，上面简单的构造方式已不
宜使用，Swing 提供各种 Model(如：
TableModel、TableColumnModel 与 ListSelectionModel)来解决上述的不便，以增加我们设计
表格的弹性。我们下面就先对 TableModel 来
做介绍:
TableModel
TableModel类本身是一个interface,在这个interface里面定义了若干的方法:包括了存取表
格字段(cell)的内容、计算表格的列数等等的基本存取操作，让设计者可以简单地利用
TableModel 来实作他所想要的表格。TableModel 界面是放在 javax.swing.table package 中，
这个 package 定义了许多 JTable 会用到的各种 Model,读者可利用 java api 文件找到这个
package,并由此 package 找到各类或界面所定义的方法。
TableModel 方法：
void addTableModelListener(TableModelListener l):使表格具有处理 TableModelEvent 的能
力。当表格的 Table Model 有所变化时，会发出 TableModel Event 事件信息.
Class getColumnClass(int columnIndex):返回字段数据类型的类名称.
int getColumnCount():返回字段(行)数量.
String getColumnName(int columnIndex):返回字段名称.
int getRowCount():返回数据列数量.
Object getValueAt(int rowIndex,int columnIndex):返回数据某个 cell 中的值.
boolean isCellEditable(int rowIndex,int columnIndex):返回cell是否可编辑,true的话
为可编辑.
void removeTableModelListener(TableModelListener l):从 TableModelListener 中
移除一个 listener.
void setValueAt(Object aValue,int rowIndex,int columnIndex): 设 置 某 个
cell(rowIndex,columnIndex)的值;
由于TableModel本身是一个Interface,因此若要直接实现此界面来建立表格并不是件轻松
的事.幸好 java 提供了两个类分别实现了这个界面,一个是 AbstractTableModel 抽象类,一个是
DefaultTableModel 实体类.前者实现了大部份的 TableModel 方法,让用户可以很有弹性地构
造自己的表格模式;后者继承前者类,是 java 默认的表格模式.这三者的关系如下所示:
TableModel---implements---AbstractTableModel-----extends---DefaultTableModel
AbstractTableModel:
java 提供的 AbstractTableModel 是一个抽象类,这个类帮我们实现大部份的 TableModel 方
法,除了 getRowCount(),getColumnCount(),getValueAt()这三个方法外.因此我们的主要任务就
是去实现这三个方法.利用这个抽象类就可以设计出不同格式的表格.我们来看看它所
提供的方法:
AbstractTableModel 方法:
void addTableModelListener(TableModelListener l):使表格具有处理 TableModelEvent 的能
力.当表格的 Table Model 有所变化时,会发出 TableModelEvent 事件信息.
int findColumn(String columnName):寻找在行名称中是否含有 columnName 这个项目.若
有,则返回其所在行的位置;反之则返回-1 表示
void fireTableCellUpdated(int row, int column):通知所有的 Listener 在这个表格中的
(row,column)字段的内容已经改变了.
void fireTableChanged(TableModelEvent e):将所收的事件通知传送给所有在这个 table
model 中注册过的 TableModelListeners.
void fireTableDataChanged():通知所有的 listener 在这个表格中列的内容已经改变了.列的
数目可能已经改变了,因此 JTable 可能需要重新显示此表格的结构.
void fireTableRowsDeleted(int firstRow, int lastRow):通知所有的 listener 在这个表格中第
firstrow 行至 lastrow 列已经被删除了.
void fireTableRowsUpdated(int firstRow, int lastRow):通知所有的 listener 在这个表格中第
firstrow 行至 lastrow 列已经被修改了.
void fireTableRowsInserted(int firstRow, int lastRow):通知所有的 listener 在这个表格中第
firstrow 行至 lastrow 列已经被加入了
.
void fireTableStructureChanged():通知所有的listener在这个表格的结构已经改变了.行的数
目,名称以及数据类型都可能已经改变了
.
Class getColumnClass(int columnIndex):返回字段数据类型的类名称.
String getColumnName(int column): 若 没 有 设 置 列 标 题 则 返 回 默 认 值 , 依 次 为
A,B,C,...Z,AA,AB,..;若无此 column,则返回一个空的 String
.
Public EventListener[] getListeners(Class listenerType):返回所有在这个 table model 所建立的
listener 中符合 listenerType 的 listener,并以数组形式返回.
boolean isCellEditable(int rowIndex, int columnIndex):返回所有在这个 table model 所建立的
listener 中符合 listenerType 形式的 listener,并以数组形式返回.
voidremoveTableModelListener(TableModelListener l):从 TableModelListener 中移除一个
listener.
voidsetValueAt(Object aValue, int rowIndex, int columnIndex)
:设置某个 cell(rowIndex,columnIndex)的值.
若你仔细比较TableModel所定义的方法与上述AbstractTableModel所提供的方法,你可以发
现,AbstractTableModel 抽象类并没有实现
getRowCount(),getColumnCount(),getValueAt()这三个方法,这也就是为什么我们要去实现这
三个方法的原因.下面我们来看如何使用
AbstractTableModel 来实作出自己想要的表格模式.
范例:TableModel1.java
import javax.swing.table.AbstractTableModel;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public classTableModel1{
publicTableModel1() {
JFrame f = new JFrame();
MyTable mt=new MyTable();
JTable t=new JTable(mt);
t.setPreferredScrollableViewportSize(new Dimension(550, 30));
JScrollPane s = new JScrollPane(t);
f.getContentPane().add(s, BorderLayout.CENTER);
f.setTitle("JTable1");
f.pack();
f.setVisible(true);
f.addWindowListener(newWindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[]) {
newTableModel1();
}
}
class MyTable extendsAbstractTableModel{
Object[][] p = {
{"阿呆", new Integer(66),
new Integer(32), new Integer(98), new Boolean(false),new Boolean(false)},
{"阿瓜", new Integer(85),
new Integer(69), new Integer(154), new Boolean(true),new Boolean(false)},
};
String[] n = {"姓名",
"语文",
"数学",
"总分",
"及格",
"作弊"};
public int getColumnCount() {
return n.length;
}
public int getRowCount() {
return p.length;
}
public String getColumnName(int col) {
return n[col];
}
public Object getValueAt(int row, int col) {
return p[row][col];
}
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
}
上例中表格内的数据类型不论是 String,int 或是 Boolean 类型,都均以 string 的类型显示.
例如在及格的字段中,原本的数据是以 Boolean
类型来表示,但显示在 JTable 上时便转换成字符串形式,若想要使表格能显示出不同的数据类
型,我们要在 MyTable 中 Override 写 getColumnCl
ass()方法,这个方法可以让我们分辨出表格中每一行的数据类型,并将此类型作适当的显示:
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
这样"作弊"会以 Check Box 显示,数据类型一律靠右显示,String 类型一律靠左显示.
TableModel2.java
import javax.swing.table.AbstractTableModel;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public classTableModel2 implementsActionListener{
JTable t = null;
publicTableModel2() {
JFrame f = new JFrame("DataModel");
JButton b1 = new JButton("数学老师");
b1.addActionListener(this);
JButton b2 = new JButton("学生阿呆");
b2.addActionListener(this);
JPanel panel = new JPanel();
panel.add(b1);
panel.add(b2);
t=new JTable(new MyTable(1));
t.setPreferredScrollableViewportSize(new Dimension(550, 30));
JScrollPane s = new JScrollPane(t);
f.getContentPane().add(panel, BorderLayout.NORTH);
f.getContentPane().add(s, BorderLayout.CENTER);
f.pack();
f.setVisible(true);
f.addWindowListener(newWindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public void actionPerformed(ActionEvent e)
{
if (e.getActionCommand().equals("学生阿呆"))
t.setModel(new MyTable(1));
if (e.getActionCommand().equals("数学老师"))
t.setModel(new MyTable(2));
t.revalidate();
}
public static void main(String args[]) {
newTableModel2();
}
}
class MyTable extendsAbstractTableModel{
Object[][] p1 = {
{"阿呆", "1234",new Integer(66),
new Integer(50), new Integer(116), new Boolean(false),new Boolean(false)}};
String[] n1 = {"姓名","学号","语文","数学","总分","及格","作弊"};
Object[][] p2 = {
{"阿呆", "1234",new Integer(50), new Boolean(false),new Boolean(false),"01234"},
{"阿瓜", "1235",new Integer(75), new Boolean(true),new Boolean(false),"05678"}};
String[] n2 = {"姓名","学号","数学","及格","作弊","电话"};
int model = 1;
public MyTable(int i){
model = i;
}
public int getColumnCount() {
if(model ==1)
return n1.length;
else
return n2.length;
}
public int getRowCount() {
if(model ==1)
return p1.length;
else
return p2.length;
}
public String getColumnName(int col) {
if(model ==1)
return n1[col];
else
return n2[col];
}
public Object getValueAt(int row, int col) {
if(model == 1)
return p1[row][col];
else
return p2[row][col];
}
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
}
TableColumnModel:
TableColumnModel 本身是一个 Interface,里面定义了许多与表格的"列(行)"有关的方法,例
如增加列,删除列,设置与取得"列"的相关信
息.通常我们不会直接实现 TableColumnModel 界面,而是会利用 JTable 的 getColumnModel()
方法取得 TableColumnModel 对象,再利用此对象对
字段做设置.举例来说,如果我们想设计的表格是包括有下拉式列表的 Combo Box,我们就能
利用 TableColumnModel 来达到这样的效果.
我们先看看下面的例子:
import javax.swing.table.AbstractTableModel;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class ColumnModelTest{
public ColumnModelTest() {
JFrame f = new JFrame();
/* 由 于 我 们 的 MyTable 类 继 承 了 AbstractTableModel 并 且 实 作 了
getColmunCount(),getRowCount(),getValueAt()方法.因此我们可以通
*过 MyTable 来产生 TableModel 的实体.
*/
MyTable mt=new MyTable();
JTable t=new JTable(mt);//我们利用 MyTable 来建立 JTable.
JComboBox c = new JComboBox();//建立一个 JComboBox 的对象.
c.addItem("Taipei");//我们在新建立的 JComboBox 对象里新增三个项目.
c.addItem("ChiaYi");
c.addItem("HsinChu");
/*我们利用 JTable 所提供的 getTableColumnModel()方法取得 TableColumnModel 对象,
再由 TableColumnModel 类所提供的 getColumn()方
*法取得 TableColumn 对象,TableColumn 类可针对表格中的每一行做具体的设置,例如
设置字段的宽度,某行的标头,设置输入较复杂的
*数据类型等等.在这里,我们利用 TableColumn 类所提供的 setCellEditor()方法,将
JComboBox 作为第二行的默认编辑组件.
*/
t.getColumnModel().getColumn(1).setCellEditor(new DefaultCellEditor(c));
t.setPreferredScrollableViewportSize(new Dimension(550, 30));
JScrollPane s = new JScrollPane(t);
f.getContentPane().add(s, BorderLayout.CENTER);
f.setTitle("ColumnModelTest");
f.pack();
f.setVisible(true);
f.addWindowListener(newWindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}
public static void main(String args[]) {
new ColumnModelTest();
}
}
class MyTable extendsAbstractTableModel{
Object[][] p = {
{"阿呆", "Taipei",new Integer(66),
new Integer(32), new Integer(98), new Boolean(false),new Boolean(false)},
{"阿瓜", "ChiaYi",new Integer(85),
new Integer(69), new Integer(154), new Boolean(true),new Boolean(false)},
};
String[] n = {"姓名",
"居住地",
"语文",
"数学",
"总分",
"及格",
"作弊"};
public int getColumnCount() {
return n.length;
}
public int getRowCount() {
return p.length;
}
public String getColumnName(int col) {
return n[col];
}
public Object getValueAt(int row, int col) {
return p[row][col];
}
public Class getColumnClass(int c) {
return getValueAt(0, c).getClass();
}
/*pu
Java如何做动态表格？
一、动态加载表格
1.首先在html中为表格的添加位置设置id
即是在html的body标签内部写一个div标签表明表格要添加到此div的内部。如下
div id="tdl"div
2.在javascript中写添加表格的语句
若在当前html文件中，则写在script标签内部，如
代码如下:
script type="text/javascript"
document.getElementById("tbl").innerHTML="tabletrtd/td/tr/table" //此处添加的表格可根据自己需要创建
/script
若是通过引入js文件，则在js文件（假设是test.js）中直接写如下语句
代码如下:
document.getElementById("tbl").innerHTML="tabletrtd/td/tr/table"
然后再引入自己的html文件
代码如下:
script type="text/javascript" src="test.js"/script
二、 动态添加表格行
1.首先在html中为表格行的添加位置设置id，此位置必须是tbody内部（不是特别准确，但根据我的测试就得到此结论，有其他的方法请留言，谢谢），如下
代码如下:
table
thead/thead
tfoottfoot //tfoot与thead是与tbody配套使用，但我在写的时候，没用也可以。
tbody id="rows"/tbody
/table
[\s\S ]*\n
2.在javascript内容中，要先创建行和单元格，再在.tbody中添加行，如下
[code]
row=document.createElement("tr"); //创建行
td1=document.createElement("tr"); //创建单元格
td1.appendChild(document.createTextNode("content")); //为单元格添加内容
row.appendChild(td1); //将单元格添加到行内
document.getElementById("rows").append(row); //将行添加到tbody中
Java怎么输出一个表格
用java输出数据库表 示例：
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Font;
import java.beans.Statement;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
public class Stmessege1 extends JFrame {
private static final long serialVersionUID = 1L;
private JTable table;// 声明表格
void Stmessege11() {
setSize(460, 320);
setVisible(true);
}
public Vector getDataVector() throws SQLException, ClassNotFoundException {
Connection conn = null;
java.sql.Statement stmt = null;
Class.forName("com.mysql.jdbc.Driver");
String dburl = "jdbc:mysql://localhost:3306/hp";
String dbuser = "root";
String dbpassword = "19920102";
conn = DriverManager.getConnection(dburl, dbuser, dbpassword);
stmt = conn.createStatement();
String sql = "select* from xsgli";
ResultSet rs = stmt.executeQuery(sql);
Vector dataVector = new Vector();
while (rs.next()) {
Vector rowVector = new Vector();
for (int i = 1; i = 7; i++) {
if (i == 2 || i == 4) {
rowVector.add(String.valueOf(rs.getInt(i)));
} else {
rowVector.add(rs.getString(i));
}
}
dataVector.add(rowVector);
}
return dataVector;
}
public Vector getColumnVector() {
Vector columnVector = new Vector();
columnVector.add("姓名");
columnVector.add("学号");
columnVector.add("性别");
columnVector.add("班级");
columnVector.add("系别");
columnVector.add("成绩");
columnVector.add("专业");
return columnVector;
}
public Stmessege1() throws SQLException, ClassNotFoundException {
super();
setTitle("学生学籍数据显示");
setBounds(100, 100, 382, 223);
// setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
Connection conn = null;
Statement stmt = null;
Class.forName("com.mysql.jdbc.Driver");
String dburl = "jdbc:mysql://localhost:3306/hp";
String dbuser = "root";
String dbpassword = "19920102";
conn = DriverManager.getConnection(dburl, dbuser, dbpassword);
java.sql.Statement st = conn.createStatement();
String sql = "select* from xsgli";
ResultSet rs = st.executeQuery(sql);
Vector columnVector = getColumnVector();
Vector dataVector = getDataVector();
final JScrollPane scrollPane = new JScrollPane();
getContentPane().add(scrollPane, BorderLayout.CENTER);
table = new JTable(dataVector, columnVector);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
scrollPane.setViewportView(table);
}
}
java表格代码怎么写
java表格就是java swing。
//创建表头
String[] columnNames = { "First Name", "Last Name", "Sport",
"# of Years", "Vegetarian" };
//创建显示数据
Object[][] data = {
{ "Kathy", "Smith", "Snowboarding", new Integer(5),
new Boolean(false) },
{ "John", "Doe", "Rowing", new Integer(3), new Boolean(true) },
{ "Sue", "Black", "Knitting", new Integer(2),
new Boolean(false) },
{ "Jane", "White", "Speed reading", new Integer(20),
new Boolean(true) },
{ "Joe", "Brown", "Pool", new Integer(10), new Boolean(false) } };
/*
* JTable还提供了一个重载的构造方法,传入两个Vector
* JTable(Vector rowData, Vector columnNames)
*
*/
final JTable table = new JTable(data, columnNames);
table.setBackground(Color.YELLOW);
java 的表格模型是什么?
DefaultTableModel是常用的java表格模型。
参考代码：
package com.dusd;
import java.awt.BorderLayout;
import java.awt.Container;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.InputEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.Arrays;
import java.util.Vector;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumnModel;
/**
* 表格模型事件示例
* p
* liA component generally gains the focus when the user clicks it,
* or when the user tabs between components, or otherwise interacts
* with a component. A component can also be given the focus programmatically,
* such as when its containing frame or dialog-box is made visible.
* The snippet of the codes below shows how to give a particular component
* the focus every time the window gains the focus.
*
* @author HAN
*
*/
public class TableModel extends JFrame {
/**
*
*/
private static final long serialVersionUID = -8581492063632813033L;
public TableModel() {
// TODO Auto-generated constructor stub
final Container container = getContentPane();
VectorString tableColumnNames = new VectorString();
tableColumnNames.add("A");
tableColumnNames.add("B");
VectorVectorString tableValues = new VectorVectorString();
for (int i = 1; i 5; i++) {
VectorString vector = new VectorString();
vector.add("A" + i);
vector.add("B" + i);
tableValues.add(vector);
}
final DefaultTableModel defaultTableModel = new DefaultTableModel(
tableValues, tableColumnNames);
final JTable table = new JTable(defaultTableModel);
JScrollPane scrollPane = new JScrollPane();
scrollPane.setViewportView(table);
container.add(scrollPane, BorderLayout.CENTER);
JPanel panel = new JPanel();
container.add(panel, BorderLayout.SOUTH);
JLabel labelA = new JLabel("A: ");
final JTextField textFieldA = new JTextField(15);
JLabel labelB = new JLabel("B: ");
final JTextField textFieldB = new JTextField(15);
JButton buttonAdd = new JButton("添加");
JButton buttonDel = new JButton("删除");
JButton buttonDeselected = new JButton("取消选择");
panel.add(labelA);
panel.add(textFieldA);
panel.add(labelB);
panel.add(textFieldB);
panel.add(buttonAdd);
panel.add(buttonDel);
panel.add(buttonDeselected);
buttonAdd.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
int[] selectedRows = table.getSelectedRows(); // table
// 默认情况容许多行选择
VectorString rowData = new VectorString();
rowData.add(textFieldA.getText());
rowData.add(textFieldB.getText());
if (selectedRows.length == 0) {
defaultTableModel.addRow(rowData);
textFieldA.setText(null);
textFieldB.setText(null);
} else if (selectedRows.length == 1) {
// System.out.println(selectedRows[0]);
defaultTableModel.insertRow(selectedRows[0] + 1, rowData);
textFieldA.setText(null);
textFieldB.setText(null);
} else {
JOptionPane.showMessageDialog(container,
"Your operation is forbidden", "Warning",
JOptionPane.WARNING_MESSAGE);
}
}
});
buttonDel.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
int[] selectedRows = table.getSelectedRows(); // table
// 默认情况容许多行选择
for (int i = 0; i selectedRows.length; i++) {
// System.out.println(selectedRows[i]);
defaultTableModel.removeRow(selectedRows[i] - i);
}
}
});
buttonDeselected.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
// TODO Auto-generated method stub
table.clearSelection();
}
});
scrollPane.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
// System.out.println("here");
if (e.getClickCount() == 1
e.getButton() == MouseEvent.BUTTON1) {
table.clearSelection();
}
}
});
// make the text field focused every time the window is activated
addWindowFocusListener(new WindowAdapter() {
@Override
public void windowGainedFocus(WindowEvent e) {
// TODO Auto-generated method stub
textFieldA.requestFocus();
}
});
// **************************************************************
// This is a standard snippet to realize the desired column selection as in
// Excel
// **************************************************************
// row selection mode
table.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
// column selection mode
TableColumnModel tableColumnModel = table.getColumnModel();
tableColumnModel.getSelectionModel().setSelectionMode(
ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
// allow the column selection (the row selection is allowed by default)
table.setColumnSelectionAllowed(true);
final JTableHeader tableHeader = table.getTableHeader();
tableHeader.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
// TODO Auto-generated method stub
// Extended modifiers represent the state of all modal keys,
// such as ALT, CTRL, META.
if (e.getClickCount() == 1
e.getButton() == MouseEvent.BUTTON1) {
// Point point = new Point(e.getX(), e.getY());
Point point = new Point(e.getPoint());
int columnNum = tableHeader.columnAtPoint(point);
// System.out.println(columnNum);
int[] selectedColumns = table.getSelectedColumns();
if (selectedColumns.length != 0) {
// System.out.println("here1");
// System.out.println(InputEvent.getModifiersExText(e.getModifiersEx()));
if (e.getModifiersEx() == (InputEvent.CTRL_DOWN_MASK)) {
// System.out.println("ctrl");
if (Arrays.binarySearch(selectedColumns, columnNum) = 0) {
table.removeColumnSelectionInterval(columnNum,
columnNum);
} else {
table.addColumnSelectionInterval(columnNum,
columnNum);
}
} else if (e.getModifiersEx() == (InputEvent.SHIFT_DOWN_MASK)) {
// System.out.println("shift");
table.setColumnSelectionInterval(
selectedColumns[0], columnNum);
} else {
table.setColumnSelectionInterval(columnNum,
columnNum);
}
} else {
// System.out.println("here2");
table.setColumnSelectionInterval(columnNum, columnNum);
}
table.setRowSelectionInterval(0, table.getRowCount() - 1);
}
}
});
defaultTableModel.addTableModelListener(new TableModelListener() {
public void tableChanged(TableModelEvent e) {
// TODO Auto-generated method stub
int type = e.getType();
int firstRow = e.getFirstRow();
// int lastRow = e.getLastRow(); // the last row seems to be always equal to the first row
int column = e.getColumn();
switch (type) {
case TableModelEvent.DELETE:
System.out.print("此次事件由 删除 行触发：");
System.out.println("此次删除的是第 " + firstRow + " 行");
break;
case TableModelEvent.INSERT:
System.out.print("此次事件由 插入 行触发：");
System.out.println("此次插入的是第 " + firstRow + " 行");
break;
case TableModelEvent.UPDATE:
System.out.print("此次事件由 更新 行触发：");
System.out.println("此次更新的是第 " + firstRow + " 行第 " + column + " 列");
break;
default:
System.out.println("此次事件由 其他原因 触发");
}
}
});
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
TableModel frame = new TableModel();
frame.setTitle("表格模型事件示例");
frame.pack(); //Realize the components.
// frame.setBounds(100, 100, 600, 300);
// textFieldA.requestFocus();
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setVisible(true); //Display the window.
}
}
