java GUI界面之JTable详解

 JTable是将数据以表格的形式显示给用户看的一种组件，它包括行和列，其中每列代表一种属性，例如：学号，姓名，成绩等等。而每行代表的是一个实体，例如一个学生。在JTable中，默认情况下列会平均分配父容器的宽度，你可以通过鼠标改变列的宽度，还可以交换列的排列顺序，当然，这些都可以通过代码进行限定和修改。一下就进入正题，介绍JTable的一些构造函数,JTable有许多构造函数，具体的请查看API文档，这里只对部分构造函数和功能进行介绍：

1.JTable(Object[][] rowData,Object[] columnNames) :  构造一个 JTable 来显示二维数组rowData 中的值，其列名称为 columnNames。

下面是例子的源代码：

[java]  view plain  copy

1. public class JTableTest extends JFrame  
2. {  
3.   
4.     public JTableTest()  
5.     {  
6.         intiComponent();  
7.     }  
8.   
9.     /** 
10.      * 初始化窗体组件 
11.      */  
12.     private void intiComponent()  
13.     {  
14.         /* 
15.          * 设置JTable的列名 
16.          */  
17.         String[] columnNames =  
18.         { "姓名", "学号", "性别", "工期", "学院", "学校" };  
19.   
20.         /* 
21.          * 初始化JTable里面各项的值，设置两个一模一样的实体"赵匡义"学生。 
22.          */  
23.         Object[][] obj = new Object[2][6];  
24.         for (int i = 0; i < 2; i++)  
25.         {  
26.             for (int j = 0; j < 6; j++)  
27.             {  
28.                 switch (j)  
29.                 {  
30.                 case 0:  
31.                     obj[i][j] = "赵匡义";  
32.                     break;  
33.                 case 1:  
34.                     obj[i][j] = "123215";  
35.                     break;  
36.                 case 2:  
37.                     obj[i][j] = "男";  
38.                     break;  
39.                 case 3:  
40.                     obj[i][j] = "两年";  
41.                     break;  
42.                 case 4:  
43.                     obj[i][j] = "计算机技术学院";  
44.                     break;  
45.                 case 5:  
46.                     obj[i][j] = "北京理工大学";  
47.                     break;  
48.                 }  
49.             }  
50.         }  
51.           
52.           
53.         /* 
54.          * JTable的其中一种构造方法 
55.          */  
56.         JTable table = new JTable(obj, columnNames);  
57.         /* 
58.          * 设置JTable的列默认的宽度和高度 
59.          */  
60.         TableColumn column = null;  
61.         int colunms = table.getColumnCount();  
62.         for(int i = 0; i < colunms; i++)  
63.         {  
64.             column = table.getColumnModel().getColumn(i);  
65.             /*将每一列的默认宽度设置为100*/  
66.             column.setPreferredWidth(100);  
67.         }  
68.         /* 
69.          * 设置JTable自动调整列表的状态，此处设置为关闭 
70.          */  
71.         table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);  
72.           
73.         /*用JScrollPane装载JTable，这样超出范围的列就可以通过滚动条来查看*/  
74.         JScrollPane scroll = new JScrollPane(table);  
75.         scroll.setSize(300, 200);  
76.           
77.           
78.         add(scroll);  
79.         this.setVisible(true);  
80.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
81.         this.pack();  
82.     }  
83.   
84.     public static void main(String[] args)  
85.     {  
86.         new JTableTest();  
87.     }  
88. }  

界面如下：

以上这种构造方法，看起来没有用到TableModel，其实是系统帮我们自动生成了一个DefaultModel的实例，DefaultModel是TableModel的子类。每个JTabel都会有一个TableModel,这个TabelModel管理表格的数据，下面就来介绍定义自己的TableModel来实现自己的JTable.

2. JTable(TableModel dm) : 构造一个JTable，使用数据模型dm、默认的列模型和默认的选择模型对其进行初始化。

下面是例子的源代码:

[java]  view plain  copy

1. public class JTableTest extends JFrame  
2. {  
3.   
4.     public JTableTest()  
5.     {  
6.         intiComponent();  
7.     }  
8.   
9.     /** 
10.      * 初始化窗体组件 
11.      */  
12.     private void intiComponent()  
13.     {  
14.         JTable table = new JTable(new MyTableModel());  
15.   
16.         /* 用JScrollPane装载JTable，这样超出范围的列就可以通过滚动条来查看 */  
17.         JScrollPane scroll = new JScrollPane(table);  
18.         add(scroll);  
19.         this.setVisible(true);  
20.         this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
21.         this.pack();  
22.     }  
23.   
24.     private class MyTableModel extends AbstractTableModel  
25.     {  
26.         /* 
27.          * 这里和刚才一样，定义列名和每个数据的值 
28.          */  
29.         String[] columnNames =  
30.         { "姓名", "学号", "年龄", "成绩", "选择" };  
31.         Object[][] data = new Object[2][5];  
32.   
33.         /** 
34.          * 构造方法，初始化二维数组data对应的数据 
35.          */  
36.         public MyTableModel()  
37.         {  
38.             for (int i = 0; i < 2; i++)  
39.             {  
40.                 for (int j = 0; j < 5; j++)  
41.                 {  
42.                     if (0 == i)  
43.                     {  
44.                         switch (j)  
45.                         {  
46.                         case 0:  
47.                             data[i][j] = "邓光侨";  
48.                             break;  
49.                         case 1:  
50.                             data[i][j] = "2008415";  
51.                             break;  
52.                         case 2:  
53.                             data[i][j] = "18";  
54.                             break;  
55.                         case 3:  
56.                             data[i][j] = "90";  
57.                             break;  
58.                         case 4:  
59.                             data[i][j] = new Boolean(false);  
60.                             break;  
61.                         }  
62.                     }  
63.                     if (1 == i)  
64.                     {  
65.                         switch (j)  
66.                         {  
67.                         case 0:  
68.                             data[i][j] = "李洁璇";  
69.                             break;  
70.                         case 1:  
71.                             data[i][j] = "2008321";  
72.                             break;  
73.                         case 2:  
74.                             data[i][j] = "18";  
75.                             break;  
76.                         case 3:  
77.                             data[i][j] = "63";  
78.                             break;  
79.                         case 4:  
80.                             data[i][j] = new Boolean(false);  
81.                             break;  
82.                         }  
83.                     }  
84.                 }  
85.             }  
86.         }  
87.   
88.         // 以下为继承自AbstractTableModle的方法，可以自定义  
89.         /** 
90.          * 得到列名 
91.          */  
92.         @Override  
93.         public String getColumnName(int column)  
94.         {  
95.             return columnNames[column];  
96.         }  
97.           
98.         /** 
99.          * 重写方法，得到表格列数 
100.          */  
101.         @Override  
102.         public int getColumnCount()  
103.         {  
104.             return columnNames.length;  
105.         }  
106.   
107.         /** 
108.          * 得到表格行数 
109.          */  
110.         @Override  
111.         public int getRowCount()  
112.         {  
113.             return data.length;  
114.         }  
115.   
116.         /** 
117.          * 得到数据所对应对象 
118.          */  
119.         @Override  
120.         public Object getValueAt(int rowIndex, int columnIndex)  
121.         {  
122.             return data[rowIndex][columnIndex];  
123.         }  
124.   
125.         /** 
126.          * 得到指定列的数据类型 
127.          */  
128.         @Override  
129.         public Class<?> getColumnClass(int columnIndex)  
130.         {  
131.             return data[0][columnIndex].getClass();  
132.         }  
133.   
134.         /** 
135.          * 指定设置数据单元是否可编辑.这里设置"姓名","学号"不可编辑 
136.          */  
137.         @Override  
138.         public boolean isCellEditable(int rowIndex, int columnIndex)  
139.         {  
140.             if (columnIndex < 2)  
141.                 return false;  
142.             else  
143.                 return true;  
144.         }  
145.           
146.         /** 
147.          * 如果数据单元为可编辑，则将编辑后的值替换原来的值 
148.          */  
149.         @Override  
150.         public void setValueAt(Object aValue, int rowIndex, int columnIndex)  
151.         {  
152.             data[rowIndex][columnIndex] = aValue;  
153.             /*通知监听器数据单元数据已经改变*/  
154.             fireTableCellUpdated(rowIndex, columnIndex);  
155.         }  
156.   
157.     }  
158.   
159.     public static void main(String[] args)  
160.     {  
161.         new JTableTest();  
162.     }  
163. }  

下面是程序界面：

　　这里要指出的是每个数据单元的都有个cell renderer根据其数据类型将数据进行绘画显示出来。默认情况下boolean类型对应的是CheckBox对象，Object类型是将对象的字符显示出来，ImageIcon是将图片以lable形式显示出来等等.具体的可以查看API文档.

转载来自：http://blog.csdn.net/caihanyuan/article/details/7320434