引用：
*mysql的jar文件
*Spring_HOME/lib/poi/*.jar
2，编写数据库链接类
package com.zzg.db
import java.sql.Connection
import java.sql.DriverManager
public class DbUtils {
private static Connection conn
static {
try {
Class.forName("com.mysql.jdbc.Driver")
conn = DriverManager.getConnection("jdbc:mysql://localhost/test","root","123456")
} catch (Exception e) {
e.printStackTrace()
}
}
public static Connection getConn() {
return conn
}
public static void setConn(Connection conn) {
DbUtils.conn = conn
}
}
3，编写数据库 *** 作类
package com.zzg.db
import java.sql.Connection
import java.sql.PreparedStatement
import java.sql.SQLException
public class ExcuteData {
private PreparedStatement pstmt
public boolean ExcuData(String sql) {
Connection conn = DbUtils.getConn()
boolean flag=false
try {
pstmt = conn.prepareStatement(sql)
flag=pstmt.execute()
} catch (SQLException e) {
e.printStackTrace()
}
return flag
}
}
4，编写的Excel表格实体类
package com.zzg.model
public class TableCell {
private String _name
private String _value
public String get_name() {
return _name
}
public void set_name(String _name) {
this._name = _name
}
public String get_value() {
return _value
}
public void set_value(String _value) {
this._value = _value
}
}
5，编写主键生成方法
package com.zzg.util
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Random
public class GenericUtil {
public static String getPrimaryKey()
{
String primaryKey
primaryKey = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date())
Random r = new Random()
primaryKey +=r.nextInt(100000)+100000
return primaryKey
}
}
6，编写的Excel *** 作类
package com.zzg.deployData
import java.io.File
import java.io.FileInputStream
import java.io.FileNotFoundException
import java.io.IOException
import java.io.Serializable
import java.util.ArrayList
import java.util.List
import org.apache.poi.hssf.usermodel.HSSFCell
import org.apache.poi.hssf.usermodel.HSSFRow
import org.apache.poi.hssf.usermodel.HSSFSheet
import org.apache.poi.hssf.usermodel.HSSFWorkbook
import com.zzg.db.ExcuteData
import com.zzg.model.TableCell
import com.zzg.util.GenericUtil
public class OperExcel<T extends Serializable>{
private HSSFWorkbook workbook
private String tableName
private Class<T>type
private String sheetName
public OperExcel(File excelFile, String tableName, Class<T>type,
String sheetName) throws FileNotFoundException,
IOException {
workbook = new HSSFWorkbook(new FileInputStream(excelFile))
this.tableName = tableName
this.type = type
this.sheetName = sheetName
InsertData()
}
// 向表中写入数据
public void InsertData() {
System.out.println("yyy")
ExcuteData excuteData = new ExcuteData()
List<List>datas = getDatasInSheet(this.sheetName)
// 向表中添加数据之前先删除表中数据
String strSql = "delete from " + this.tableName
excuteData.ExcuData(strSql)
// 拼接sql语句
for (int i = 1i <datas.size()i++) {
strSql = "insert into " + this.tableName + "("
List row = datas.get(i)
for (short n = 0n <row.size()n++) {
TableCell excel = (TableCell) row.get(n)
if (n != row.size() - 1)
strSql += excel.get_name() + ","
else
strSql += excel.get_name() + ")"
}
strSql += " values ("
for (short n = 0n <row.size()n++) {
TableCell excel = (TableCell) row.get(n)
try {
if (n != row.size() - 1) {
strSql += getTypeChangeValue(excel) + ","
} else
strSql += getTypeChangeValue(excel) + ")"
} catch (RuntimeException e) {
e.printStackTrace()
} catch (Exception e) {
e.printStackTrace()
}
}
//执行sql
excuteData.ExcuData(strSql)
}
}
/**
* 获得表中的数据
* @param sheetName 表格索引(EXCEL 是多表文档,所以需要输入表索引号)
* @return 由LIST构成的行和表
*/
public List<List>getDatasInSheet(String sheetName) {
List<List>result = new ArrayList<List>()
// 获得指定的表
HSSFSheet sheet = workbook.getSheet(sheetName)
// 获得数据总行数
int rowCount = sheet.getLastRowNum()
if (rowCount <1) {
return result
}
// 逐行读取数据
for (int rowIndex = 0rowIndex <rowCountrowIndex++) {
// 获得行对象
HSSFRow row = sheet.getRow(rowIndex)
if (row != null) {
List<TableCell>rowData = new ArrayList<TableCell>()
// 获得本行中单元格的个数
int columnCount = sheet.getRow(0).getLastCellNum()
// 获得本行中各单元格中的数据
for (short columnIndex = 0columnIndex <columnCountcolumnIndex++) {
HSSFCell cell = row.getCell(columnIndex)
// 获得指定单元格中数据
Object cellStr = this.getCellString(cell)
TableCell TableCell = new TableCell()
TableCell.set_name(getCellString(
sheet.getRow(0).getCell(columnIndex)).toString())
TableCell.set_value(cellStr == null ? "" : cellStr
.toString())
rowData.add(TableCell)
}
result.add(rowData)
}
}
return result
}
/**
* 获得单元格中的内容
* @param cell
* @return result
*/
protected Object getCellString(HSSFCell cell) {
Object result = null
if (cell != null) {
int cellType = cell.getCellType()
switch (cellType) {
case HSSFCell.CELL_TYPE_STRING:
result = cell.getStringCellValue()
break
case HSSFCell.CELL_TYPE_NUMERIC:
result = cell.getNumericCellValue()
break
case HSSFCell.CELL_TYPE_FORMULA:
result = cell.getNumericCellValue()
break
case HSSFCell.CELL_TYPE_ERROR:
result = null
break
case HSSFCell.CELL_TYPE_BOOLEAN:
result = cell.getBooleanCellValue()
break
case HSSFCell.CELL_TYPE_BLANK:
result = null
break
}
}
return result
}
// 根据类型返回相应的值
@SuppressWarnings("unchecked")
public String getTypeChangeValue(TableCell excelElement)
throws RuntimeException, Exception {
String colName = excelElement.get_name()
String colValue = excelElement.get_value()
String retValue = ""
if (colName.equals("id")) {
retValue = "'" + GenericUtil.getPrimaryKey() + "'"
return retValue
}
if (colName == null) {
retValue = null
}
if (colName.equals("class_createuser")) {
retValue = "yaa101"
return "'" + retValue + "'"
}
retValue = "'" + colValue + "'"
return retValue
}
}
7，编写调用 *** 作的Excel类的方法
package com.zzg.deployData
import java.io.File
import java.io.FileNotFoundException
import java.io.IOException
public class DeployData {
private File fileOut
public void excute(String filepath) {
fileOut = new File(filepath)
this.deployUserInfoData()
}
public void deployUserInfoData() {
try {
new OperExcel(fileOut, "test", Object.class, "Sheet1")
} catch (FileNotFoundException e) {
e.printStackTrace()
} catch (IOException e) {
e.printStackTrace()
}
}
}
8，编写客户端
package com.zzg.client
import com.zzg.deployData.DeployData
public class DeployClient {
public static void main(String[] args) {
DeployData deployData = new DeployData()
deployData.excute("D://test.xls")
}
}
HSSFWorkbook wb=new HSSFWorkbook()//创建一个ExcelHSSFSheet sheet=wb.createSheet("sheet1")//创建一个Sheet
HSSFRow row=sheet.createRow(0)//创建一个行
HSSFCell cell=row.createCell((short)0) //创建一个单元格
cell.setEncoding(HSSFCell.ENCODING_UTF_16)
cell.setCellValue("序号")//设置值
cell=row.createCell((short)1)
cell.setEncoding(HSSFCell.ENCODING_UTF_16)
cell.setCellValue("姓")
多少有点麻烦建意不要用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=0i<6i++){
//利用 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)来解决上述的不便，以增加我们设计
表格的d性。我们下面就先对 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 方法,让用户可以很有d性地构
造自己的表格模式后者继承前者类,是 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
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）