JTable的使用

               最近在写一些表格程序，但由于对Jtable不熟悉，写起来很费劲，于是就顺便把JTable的APi

看了一下，写了几个测试程序，与大家共同分享，希望可以帮助那些对Jtable不熟悉的同学有所帮助

            首先来看一看类层次结构图：

                             Java.lang.Object

                                       --Java.awt.Component

                                                 --Java.awt.Container 
                                                               --Javax.swing.JComponent 

--Javax.swing.JTabel

              从类的层次结构可以看出，jtable的直接父类是JComponent，因此jtable也就具备JComponent的属性和方法（私有的除外）

JTabel构造函数：
JTable():建立一个新的JTables,并使用系统默认的Model.
JTable(int numRows,int numColumns):建立一个具有numRows行，numColumns列的空表格，使用的是DefaultTableModel.
JTable(Object[][] rowData,Object[][] columnNames):建立一个显示二维数组数据的表格，且可以显示列的名称。
JTable(TableModel dm):建立一个JTable,有默认的字段模式以及选择模式，并设置数据模式。
JTable(TableModel dm,TableColumnModel cm):建立一个JTable,设置数据模式与字段模式，并有默认的选择模式。
JTable(TableModel dm,TableColumnModel cm,ListSelectionModel sm):建立一个JTable,设置数据模式、字段模式、与选择模式。
JTable(Vector rowData,Vector columnNames):建立一个以Vector为输入来源的数据表格，可显示行的名称。

           JTable与TableModel

              我们经常看到TableModel，AbstractTableModel，DefaultTableModel ，那么JTable已经有了自己的构造函数，为什么还要有这些TableModel呢？如果JTable比作一个人的话，TableModel就相当于形式各样的衣服，“人”要改变自己的外在表现，只需要“换衣服”，就可以了。利用jtable的默认构造方法只能创造一个静态的表格，使用MOdel，我们可以根据改变model来改变table。

             既然如此，那为什么有上面三个呢？他们是什么关系呢？

             TableModel是一个接口，AbstractTableModel是一个抽象类，继承了接口的部分方法，DefaultTableModel 是AbstractTableModel的一个实现类，包含了表格的基本操作。

               TableModel---implements--->AbstractTableModel-----extends--->DefaultTableModel

1、使用TableModel接口更灵活，可以根据用户需求建立相应的表格

package jtable_v1;

import java.util.Vector;

import javax.swing.event.TableModelListener;
import javax.swing.table.TableModel;

public class MyTableModel1 implements TableModel{
	private Vector<String> ziduan;
	private Vector<Object> dataVec;
	public MyTableModel1(Vector<String> ziduan,Vector<Object> dataVec){
		this.ziduan=ziduan;
		this.dataVec=dataVec;
	}
	@Override
	public int getRowCount() {
		
		return dataVec.size();
	}

	@Override
	public int getColumnCount() {
		// TODO Auto-generated method stub
		return ziduan.size();
	}

	@Override
	public String getColumnName(int columnIndex) {
		// 返回列的名称
		return ziduan.elementAt(columnIndex);
	}

	@Override
	public Class<?> getColumnClass(int columnIndex) {
		// 得到列的类型属性
		return String.class;
	}

	@Override
	public boolean isCellEditable(int rowIndex, int columnIndex) {
		// 单元格是否可编辑
		if(rowIndex==0){
			//第一行不可编辑
			return false;
		}
		return true;
	}

	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		// TODO Auto-generated method stu
			Vector<String> vec=(Vector<String>)dataVec.elementAt(rowIndex);
			String str=vec.elementAt(columnIndex).toString();
		    return str;
	}

	@Override
	public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
		// TODO Auto-generated method stub
		Vector<String> vec=(Vector<String>)dataVec.elementAt(rowIndex);
		vec.setElementAt(aValue.toString(), columnIndex);
	}

	@Override
	public void addTableModelListener(TableModelListener l) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void removeTableModelListener(TableModelListener l) {
		// TODO Auto-generated method stub
		
	}

}

 

对应的测试主类

写道

package jtable_v1;

import java.awt.event.MouseEvent;
import java.util.Vector;

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.RowSorter;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

public class Table1Text {
private JTable table;
public static void main(String[] args) {
// TODO Auto-generated method stub
new Table1Text().init();
}

public void init(){

JFrame jf=new JFrame();
jf.setSize(400, 300);
jf.setLocationRelativeTo(null);
jf.setDefaultCloseOperation(3);
MyTableModel1 tableModel=initTableModel();
table=new JTable(tableModel);

//表格排序,当单击表头时，所在列会自动排序
RowSorter<javax.swing.table.TableModel> sorter = new TableRowSorter<TableModel>(table.getModel());
table.setRowSorter(sorter);

table.addMouseListener(new java.awt.event.MouseAdapter(){
public void mouseClicked(MouseEvent e) {//仅当鼠标单击时响应
//得到选中的行列的索引值
int r= table.getSelectedRow();
int c= table.getSelectedColumn();
//得到选中的单元格的值，表格中都是字符串
Object value= table.getValueAt(r, c);
String info=r+"行"+c+"列 值 : "+value.toString();
javax.swing.JOptionPane.showMessageDialog(null,info);
}
});

JScrollPane jsp=new JScrollPane(table);
jf.add(jsp);
jf.setVisible(true);
}

public MyTableModel1 initTableModel(){

Vector<String> ziduan=new Vector<String>();
ziduan.add("学号");
ziduan.add("姓名");
ziduan.add("班级");
ziduan.add("年龄");

Vector<Object> dataVec=new Vector<Object>();
for(int i=0;i<40;i++){
Vector<String> vec=new Vector<String>();
for(int j=0;j<ziduan.size();j++){
vec.add(i+"---"+j);
}
dataVec.add(vec);
}

MyTableModel1 tableModel=new MyTableModel1(ziduan, dataVec);
return tableModel;

}

}

 2、使用AbstractTableModel抽象类，只需在实例类中实现下面三个方法就可以了，比较简单，用于显示数据，简化操作

public int getRowCount();//得到行数
  public int getColumnCount();//得到列数
  public Object getValueAt(int row, int column);//得到某行某列的值
3、使用DefaultTableModel，这个类是java类库中已经有的，可以直接使用，但是里面的内容很多，有许多用不到时，我们还是可以考虑自己写一个tablemodel的实现类

package jtable_v3;

import java.awt.event.MouseEvent;
import java.util.Vector;

import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.RowSorter;
import javax.swing.table.TableModel;
import javax.swing.table.TableRowSorter;

public class Table1Text {
	private JTable table;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new Table1Text().init();
	}
	
	public void init(){
		
		JFrame jf=new JFrame();
		jf.setSize(400, 300);
		jf.setLocationRelativeTo(null);
		jf.setDefaultCloseOperation(3);
	//	DeFaultTableModel1 tableModel=initTableModel1();
		DeFaultTableModel1 tableModel=new DeFaultTableModel1(4,4);
		table=new JTable(tableModel);
		
		Object[] columnData=new Object[]{"中国","日本","美国","俄罗斯"};
		tableModel.addColumn("国家",columnData);
		tableModel.addRow(columnData);
		//表格排序,当单击表头时，所在列会自动排序
		RowSorter<javax.swing.table.TableModel> sorter = new TableRowSorter<TableModel>(table.getModel());
	    table.setRowSorter(sorter);

		table.addMouseListener(new java.awt.event.MouseAdapter(){
       	 public void mouseClicked(MouseEvent e) {//仅当鼠标单击时响应
       		 //得到选中的行列的索引值
       		int r= table.getSelectedRow();
    			int c=	 table.getSelectedColumn();
    		    //得到选中的单元格的值，表格中都是字符串
    			Object value= table.getValueAt(r, c);
			 String info=r+"行"+c+"列 值 : "+value.toString();
			 javax.swing.JOptionPane.showMessageDialog(null,info);
       	 }
        });

		JScrollPane jsp=new JScrollPane(table);
		jf.add(jsp);
		jf.setVisible(true);
	}
	
	public DeFaultTableModel1 initTableModel(){
		
		Vector<String> ziduan=new Vector<String>();
		ziduan.add("学号");
		ziduan.add("姓名");
		ziduan.add("班级");
		ziduan.add("年龄");
		
		Vector<Object> dataVec=new Vector<Object>();
		for(int i=0;i<40;i++){
			Vector<String> vec=new Vector<String>();
			for(int j=0;j<ziduan.size();j++){
				vec.add(i+"---"+j);
			}
			dataVec.add(vec);
		}
		
		DeFaultTableModel1 tableModel=new DeFaultTableModel1(ziduan, dataVec);
		return tableModel;
		
	}

}

 

注意，我为了练习，将 DefaultTableModel变为自己的DeFaultTableModel1，读者在使用时，可不必，我只是为了我能理解每个函数的实现

写道

package jtable_v3;

import java.io.Serializable;
import java.util.Vector;

import javax.swing.event.TableModelEvent;
import javax.swing.table.AbstractTableModel;

public class DeFaultTableModel1 extends AbstractTableModel implements Serializable{
protected Vector dataVector;
protected Vector columnIdentifiers;

public DeFaultTableModel1() {
this(0, 0);
}
public DeFaultTableModel1(int rowCount, int columnCount) {

this(newVector(columnCount), rowCount);
System.out.println(rowCount+"==="+columnCount);
}
public DeFaultTableModel1(Vector columnNames, int rowCount) {
setDataVector(newVector(rowCount), columnNames);
}


private static Vector newVector(int size) {
Vector v = new Vector(size);
v.setSize(size);
return v;
}
private static Vector nonNullVector(Vector v) {
return (v != null) ? v : new Vector();
}


public DeFaultTableModel1(Object[] columnNames, int rowCount) {
this(convertToVector(columnNames), rowCount);
}



public DeFaultTableModel1(Vector data, Vector columnNames) {
setDataVector(data, columnNames);
}
public DeFaultTableModel1(Object[][] data, Object[] columnNames) {
setDataVector(data, columnNames);
}
public Vector getDataVector() {
return dataVector;
}


public void setDataVector(Vector dataVector, Vector columnIdentifiers) {
this.dataVector = nonNullVector(dataVector);
this.columnIdentifiers = nonNullVector(columnIdentifiers);
justifyRows(0, getRowCount());
fireTableStructureChanged();
}
public void setDataVector(Object[][] dataVector, Object[] columnIdentifiers) {
setDataVector(convertToVector(dataVector), convertToVector(columnIdentifiers));
}
public void newDataAvailable(TableModelEvent event) {
fireTableChanged(event);
}
private void justifyRows(int from, int to) {
// Sometimes the DefaultTableModel is subclassed
// instead of the AbstractTableModel by mistake.
// Set the number of rows for the case when getRowCount
// is overridden.
dataVector.setSize(getRowCount());

for (int i = from; i < to; i++) {
if (dataVector.elementAt(i) == null) {
dataVector.setElementAt(new Vector(), i);
}
((Vector)dataVector.elementAt(i)).setSize(getColumnCount());
}
}
public void newRowsAdded(TableModelEvent e) {
justifyRows(e.getFirstRow(), e.getLastRow() + 1);
fireTableChanged(e);
}
public void rowsRemoved(TableModelEvent event) {
fireTableChanged(event);
}

public void setNumRows(int rowCount) {
int old = getRowCount();
if (old == rowCount) {
return;
}
dataVector.setSize(rowCount);
if (rowCount <= old) {
fireTableRowsDeleted(rowCount, old-1);
}
else {
justifyRows(old, rowCount);
fireTableRowsInserted(old, rowCount-1);
}
}
public void setRowCount(int rowCount) {
setNumRows(rowCount);
}
public void addRow(Vector rowData) {
insertRow(getRowCount(), rowData);
}
public void addRow(Object[] rowData) {
addRow(convertToVector(rowData));
}

public void insertRow(int row, Vector rowData) {
dataVector.insertElementAt(rowData, row);
justifyRows(row, row+1);
fireTableRowsInserted(row, row);
}

public void insertRow(int row, Object[] rowData) {
insertRow(row, convertToVector(rowData));
}

private static int gcd(int i, int j) {
return (j == 0) ? i : gcd(j, i%j);
}

private static void rotate(Vector v, int a, int b, int shift) {
int size = b - a;
int r = size - shift;
int g = gcd(size, r);
for(int i = 0; i < g; i++) {
int to = i;
Object tmp = v.elementAt(a + to);
for(int from = (to + r) % size; from != i; from = (to + r) % size) {
v.setElementAt(v.elementAt(a + from), a + to);
to = from;
}
v.setElementAt(tmp, a + to);
}
}
public void moveRow(int start, int end, int to) {
int shift = to - start;
int first, last;
if (shift < 0) {
first = to;
last = end;
}
else {
first = start;
last = to + end - start;
}
rotate(dataVector, first, last + 1, shift);

fireTableRowsUpdated(first, last);
}

public void removeRow(int row) {
dataVector.removeElementAt(row);
fireTableRowsDeleted(row, row);
}

public void setColumnIdentifiers(Vector columnIdentifiers) {
setDataVector(dataVector, columnIdentifiers);
}
public void setColumnIdentifiers(Object[] newIdentifiers) {
setColumnIdentifiers(convertToVector(newIdentifiers));
}

public void setColumnCount(int columnCount) {
columnIdentifiers.setSize(columnCount);
justifyRows(0, getRowCount());
fireTableStructureChanged();
}

public void addColumn(Object columnName) {
addColumn(columnName, (Vector)null);
}

public void addColumn(Object columnName, Vector columnData) {
columnIdentifiers.addElement(columnName);
if (columnData != null) {
int columnSize = columnData.size();
if (columnSize > getRowCount()) {
dataVector.setSize(columnSize);
}
justifyRows(0, getRowCount());
int newColumn = getColumnCount() - 1;
for(int i = 0; i < columnSize; i++) {
Vector row = (Vector)dataVector.elementAt(i);
row.setElementAt(columnData.elementAt(i), newColumn);
}
}
else {
justifyRows(0, getRowCount());
}

fireTableStructureChanged();
}

public void addColumn(Object columnName, Object[] columnData) {
addColumn(columnName, convertToVector(columnData));
}

public int getRowCount() {
return dataVector.size();
}

public int getColumnCount() {
return columnIdentifiers.size();
}

public String getColumnName(int column) {
Object id = null;
// This test is to cover the case when
// getColumnCount has been subclassed by mistake ...
if (column < columnIdentifiers.size() && (column >= 0)) {
id = columnIdentifiers.elementAt(column);
}
return (id == null) ? super.getColumnName(column)
: id.toString();
}

public boolean isCellEditable(int row, int column) {
return true;
}

public Object getValueAt(int row, int column) {
Vector rowVector = (Vector)dataVector.elementAt(row);
return rowVector.elementAt(column);
}

public void setValueAt(Object aValue, int row, int column) {
Vector rowVector = (Vector)dataVector.elementAt(row);
rowVector.setElementAt(aValue, column);
fireTableCellUpdated(row, column);
}

protected static Vector convertToVector(Object[] anArray) {
if (anArray == null) {
return null;
}
Vector<Object> v = new Vector<Object>(anArray.length);
for (Object o : anArray) {
v.addElement(o);
}
return v;
}

protected static Vector convertToVector(Object[][] anArray) {
if (anArray == null) {
return null;
}
Vector<Vector> v = new Vector<Vector>(anArray.length);
for (Object[] o : anArray) {
v.addElement(convertToVector(o));
}
return v;
}
// @Override
// public int getRowCount() {
// // TODO Auto-generated method stub
// return 0;
// }
//
// @Override
// public int getColumnCount() {
// // TODO Auto-generated method stub
// return 0;
// }
//
// @Override
// public Object getValueAt(int rowIndex, int columnIndex) {
// // TODO Auto-generated method stub
// return null;
// }
//
}