Java Swing编程技术应用：JTable表格案例分享
      表格是GUI编程中使用较多，但也是最麻烦的一个控件之一。表格是用来显示二维数据，提供编辑，选择等功能。如果只是显示水泵数据，这还是非常easy的，只要在JTable中传入二维数组或集合就可以了

   
  1. public class SimpleTable  
  2. {  
  3.     JFrame jf = new JFrame("简单表格");  
  4.     JTable table;  
  5.     //定义二维数组作为表格数据  
  6.     Object[][] tableData =   
  7.     {  
  8.         new Object[]{"李清照" , 29 , "女"},  
  9.         new Object[]{"苏格拉底", 56 , "男"},  
  10.         new Object[]{"李白", 35 , "男"},  
  11.         new Object[]{"弄玉", 18 , "女"},  
  12.         new Object[]{"虎头" , 2 , "男"}  
  13.     };  
  14.     //定义一维数据作为列标题  
  15.     Object[] columnTitle = {"姓名" , "年龄" , "性别"};  
  16.     public void init()  
  17.     {  
  18.         //以二维数组和一维数组来创建一个JTable对象  
  19.         table = new JTable(tableData , columnTitle);  
  20.         //将JTable对象放在JScrollPane中，并将该JScrollPane放在水泵窗口中显示出来  
  21.         jf.add(new JScrollPane(table));  
  22.         jf.pack();  
  23.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  24.         jf.setVisible(true);  
  25.     }  
  26.     public static void main(String[] args)   
  27.     {  
  28.         new SimpleTable().init();  
  29.     }  
  30. }  

下面举个JTable表格调整和选择方式的例子，eg

   
  1. public class AdjustingWidth  
  2. {  
  3.     JFrame jf = new JFrame("调整表格列宽");  
  4.     JMenuBar menuBar = new JMenuBar();  
  5.     JMenu adjustModeMenu = new JMenu("调整方式");  
  6.     JMenu selectUnitMenu = new JMenu("选择单元");  
  7.     JMenu selectModeMenu = new JMenu("选择方式");  
  8.  
  9.     //定义5个单选框按钮，用以控制表格的宽度调整方式  
  10.     JRadioButtonMenuItem[] adjustModesItem = new JRadioButtonMenuItem[5];  
  11.     //定义3个单选框按钮，用以控制表格的选择方式  
  12.     JRadioButtonMenuItem[] selectModesItem = new JRadioButtonMenuItem[3];  
  13.  
  14.     JCheckBoxMenuItem rowsItem = new JCheckBoxMenuItem("选择行");  
  15.     JCheckBoxMenuItem columnsItem = new JCheckBoxMenuItem("选择列");  
  16.     JCheckBoxMenuItem cellsItem = new JCheckBoxMenuItem("选择单元格");  
  17.     ButtonGroup adjustBg = new ButtonGroup();  
  18.     ButtonGroup selectBg = new ButtonGroup();  
  19.     //定义一个int类型的数组，用于保存表格所有的宽度调整方式  
  20.     int[] adjustModes = new int[]{  
  21.         JTable.AUTO_RESIZE_OFF,  
  22.         JTable.AUTO_RESIZE_NEXT_COLUMN,  
  23.         JTable.AUTO_RESIZE_SUBSEQUENT_COLUMNS,  
  24.         JTable.AUTO_RESIZE_LAST_COLUMN,  
  25.         JTable.AUTO_RESIZE_ALL_COLUMNS   
  26.     };  
  27.     int[] selectModes = new int[]{  
  28.         ListSelectionModel.MULTIPLE_INTERVAL_SELECTION ,  
  29.         ListSelectionModel.SINGLE_INTERVAL_SELECTION ,  
  30.         ListSelectionModel.SINGLE_SELECTION  
  31.     };  
  32.     JTable table;  
  33.     //定义二维数组作为表格数据  
  34.     Object[][] tableData =   
  35.     {  
  36.         new Object[]{"李清照" , 29 , "女"},  
  37.         new Object[]{"苏格拉底", 56 , "男"},  
  38.         new Object[]{"李白", 35 , "男"},  
  39.         new Object[]{"弄玉", 18 , "女"},  
  40.         new Object[]{"虎头" , 2 , "男"}  
  41.     };  
  42.     //定义一维数据作为列标题  
  43.     Object[] columnTitle = {"姓名" , "年龄" , "性别"};  
  44.  
  45.     public void init()  
  46.     {  
  47.         //以二维数组和一维数组来创建一个JTable对象  
  48.         table = new JTable(tableData , columnTitle);  
  49.  
  50.         //-----------为窗口安装设置表格调整方式的菜单-----------  
  51.         adjustModesItem[0] = new JRadioButtonMenuItem("只调整表格");  
  52.         adjustModesItem[1] = new JRadioButtonMenuItem("只调整下一列");  
  53.         adjustModesItem[2] = new JRadioButtonMenuItem("平均调整余下列");  
  54.         adjustModesItem[3] = new JRadioButtonMenuItem("只调整最后一列");  
  55.         adjustModesItem[4] = new JRadioButtonMenuItem("平均调整所有列");  
  56.         menuBar.add(adjustModeMenu);  
  57.         for (int i = 0; i < adjustModesItem.length ; i++)  
  58.         {  
  59.             //默认选中第三个菜单项，即对应表格默认的宽度调整方式  
  60.             if (i == 2)  
  61.             {  
  62.                 adjustModesItem[i].setSelected(true);  
  63.             }  
  64.             adjustBg.add(adjustModesItem[i]);  
  65.             adjustModeMenu.add(adjustModesItem[i]);  
  66.             final int index = i;  
  67.             //为设置调整方式的菜单项添加监听器  
  68.             adjustModesItem[i].addActionListener(new ActionListener()  
  69.             {  
  70.                 public void actionPerformed(ActionEvent evt)  
  71.                 {  
  72.                     //如果当前菜单项处于选中状态，表格使用对应的调整方式  
  73.                     if (adjustModesItem[index].isSelected())  
  74.                     {  
  75.                         table.setAutoResizeMode(adjustModes[index]);  
  76.                     }  
  77.                 }  
  78.             });  
  79.         }  
  80.         //-----------为窗口安装设置表格选择方式的菜单-----------  
  81.         selectModesItem[0] = new JRadioButtonMenuItem("无限制");  
  82.         selectModesItem[1] = new JRadioButtonMenuItem("单独的连续区");  
  83.         selectModesItem[2] = new JRadioButtonMenuItem("单选");  
  84.         menuBar.add(selectModeMenu);  
  85.         for (int i = 0; i < selectModesItem.length ; i++)  
  86.         {  
  87.             //默认选中第一个菜单项，即对应表格默认的选择方式  
  88.             if (i == 0)  
  89.             {  
  90.                 selectModesItem[i].setSelected(true);  
  91.             }  
  92.             selectBg.add(selectModesItem[i]);  
  93.             selectModeMenu.add(selectModesItem[i]);  
  94.             final int index = i;  
  95.             //为设置选择方式的菜单项添加监听器  
  96.             selectModesItem[i].addActionListener(new ActionListener()  
  97.             {  
  98.                 public void actionPerformed(ActionEvent evt)  
  99.                 {  
  100.                     //如果当前菜单项处于选中状态，表格使用对应的选择方式  
  101.                     if (selectModesItem[index].isSelected())  
  102.                     {  
  103.                         table.getSelectionModel().setSelectionMode(selectModes[index]);  
  104.                     }  
  105.                 }  
  106.             });  
  107.         }  
  108.         menuBar.add(selectUnitMenu);  
  109.         //-----------为窗口安装设置表格选择单元的菜单-----------  
  110.         rowsItem.setSelected(table.getRowSelectionAllowed());  
  111.         columnsItem.setSelected(table.getColumnSelectionAllowed());  
  112.         cellsItem.setSelected(table.getCellSelectionEnabled());  
  113.  
  114.         rowsItem.addActionListener(new ActionListener()  
  115.         {  
  116.             public void actionPerformed(ActionEvent event)  
  117.             {  
  118.                 table.clearSelection();  
  119.                 //如果该菜单项处于选中状态，设置表格的选择单元是行  
  120.                 table.setRowSelectionAllowed(rowsItem.isSelected());  
  121.                 //如果选择行、选择列同时被选中，其实质是选择单元格  
  122.                 cellsItem.setSelected(table.getCellSelectionEnabled());  
  123.             }  
  124.         });  
  125.         selectUnitMenu.add(rowsItem);  
  126.         columnsItem.addActionListener(new ActionListener()  
  127.         {  
  128.             public void actionPerformed(ActionEvent event)  
  129.             {  
  130.                 table.clearSelection();  
  131.                 //如果该菜单项处于选中状态，设置表格的选择单元是列  
  132.                 table.setColumnSelectionAllowed(columnsItem.isSelected());  
  133.                 //如果选择行、选择列同时被选中，其实质是选择单元格  
  134.                 cellsItem.setSelected(table.getCellSelectionEnabled());  
  135.             }  
  136.         });  
  137.         selectUnitMenu.add(columnsItem);  
  138.         cellsItem.addActionListener(new ActionListener()  
  139.         {  
  140.             public void actionPerformed(ActionEvent event)  
  141.             {  
  142.                 table.clearSelection();  
  143.                 //如果该菜单项处于选中状态，设置表格的选择单元是单元格  
  144.                 table.setCellSelectionEnabled(cellsItem.isSelected());  
  145.                 //该选项的改变会同时影响选择行、选择列两个菜单  
  146.                 rowsItem.setSelected(table.getRowSelectionAllowed());  
  147.                 columnsItem.setSelected(table.getColumnSelectionAllowed());  
  148.             }  
  149.         });  
  150.         selectUnitMenu.add(cellsItem);  
  151.  
  152.         jf.setJMenuBar(menuBar);  
  153.         //分别获取表格的三个表格列，并设置三列的最小宽度，最佳宽度和最大宽度  
  154.         TableColumn nameColumn = table.getColumn(columnTitle[0]);  
  155.         nameColumn.setMinWidth(40);  
  156.         TableColumn ageColumn = table.getColumn(columnTitle[1]);  
  157.         ageColumn.setPreferredWidth(50);  
  158.         TableColumn genderColumn = table.getColumn(columnTitle[2]);  
  159.         genderColumn.setMaxWidth(50);  
  160.  
  161.  
  162.         //将JTable对象放在JScrollPane中，并将该JScrollPane放在窗口中显示出来  
  163.         jf.add(new JScrollPane(table));  
  164.         System.out.println(table.getModel());  
  165.         jf.pack();  
  166.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  167.         jf.setVisible(true);  
  168.     }  
  169.  
  170.     public static void main(String[] args)   
  171.     {  
  172.         new AdjustingWidth().init();  
  173.     }  
  174. }  

和JList,JTree类似，JTable采用TableModel来保存表格中的所有状态数据，采用TableColumnModel来保存所有列的数据。eg

   
  1. public class TestDefaultTableModel  
  2. {  
  3.     JFrame mainWin = new JFrame("管理数据行、数据列");  
  4.     final int COLUMN_COUNT = 5;  
  5.     DefaultTableModel model;  
  6.     JTable table;  
  7.     //用于保存被隐藏列的List集合  
  8.     ArrayList<TableColumn> hiddenColumns = new ArrayList<TableColumn>();  
  9.     public void init()  
  10.     {  
  11.         model = new DefaultTableModel(COLUMN_COUNT ,COLUMN_COUNT);  
  12.         for (int i = 0; i < COLUMN_COUNT ; i++ )  
  13.         {  
  14.             for (int j = 0; j < COLUMN_COUNT ; j++ )  
  15.             {  
  16.                 model.setValueAt("老单元格值 " + i + " " + j , i , j);  
  17.             }  
  18.         }  
  19.  
  20.         table = new JTable(model);  
  21.  
  22.         mainWin.add(new JScrollPane(table), BorderLayout.CENTER);  
  23.  
  24.         //为窗口安装菜单  
  25.         JMenuBar menuBar = new JMenuBar();  
  26.         mainWin.setJMenuBar(menuBar);  
  27.         JMenu tableMenu = new JMenu("管理");  
  28.         menuBar.add(tableMenu);  
  29.  
  30.         JMenuItem hideColumnsItem = new JMenuItem("隐藏选中列");  
  31.         hideColumnsItem.addActionListener(new ActionListener()  
  32.         {  
  33.             public void actionPerformed(ActionEvent event)  
  34.             {  
  35.                 //获取所有选中列的索引  
  36.                 int[] selected = table.getSelectedColumns();  
  37.                 TableColumnModel columnModel = table.getColumnModel();  
  38.                 //依次把每一个选中的列隐藏起来，并使用List把这些列保存起来  
  39.                 for (int i = selected.length - 1; i >= 0; i--)  
  40.                 {  
  41.                     TableColumn column = columnModel.getColumn(selected[i]);  
  42.                     table.removeColumn(column);  
  43.                     //把隐藏的列保存起来，确保以后可以显示出来  
  44.                     hiddenColumns.add(column);  
  45.                 }  
  46.             }  
  47.         });  
  48.         tableMenu.add(hideColumnsItem);  
  49.  
  50.         JMenuItem showColumnsItem = new JMenuItem("显示隐藏列");  
  51.         showColumnsItem.addActionListener(new ActionListener()  
  52.         {  
  53.             public void actionPerformed(ActionEvent event)  
  54.             {  
  55.                 //把所有隐藏列依次显示出来  
  56.                 for (TableColumn tc : hiddenColumns)  
  57.                 {  
  58.                     //依次把所有隐藏的列显示出来  
  59.                     table.addColumn(tc);  
  60.                 }  
  61.                 //清空保存隐藏列的List集合  
  62.                 hiddenColumns.clear();              
  63.             }  
  64.         });  
  65.         tableMenu.add(showColumnsItem);  
  66.  
  67.         JMenuItem addColumnItem = new JMenuItem("插入选中列");  
  68.         addColumnItem.addActionListener(new ActionListener()  
  69.         {  
  70.             public void actionPerformed(ActionEvent event)  
  71.             {  
  72.                 //获取所有选中列的索引  
  73.                 int[] selected = table.getSelectedColumns();  
  74.                 TableColumnModel columnModel = table.getColumnModel();  
  75.                 //依次把选中的列添加到JTable之后  
  76.                 for (int i = selected.length - 1; i >= 0; i--)  
  77.                 {    
  78.                     TableColumn column = columnModel.getColumn(selected[i]);  
  79.                     table.addColumn(column);  
  80.                 }  
  81.             }  
  82.         });  
  83.         tableMenu.add(addColumnItem);  
  84.  
  85.         JMenuItem addRowItem = new JMenuItem("增加行");  
  86.         addRowItem.addActionListener(new ActionListener()  
  87.         {  
  88.             public void actionPerformed(ActionEvent event)  
  89.             {  
  90.                 //创建一个String数组作为新增行的内容  
  91.                 String[] newCells = new String[COLUMN_COUNT];  
  92.                 for (int i = 0; i < newCells.length; i++)  
  93.                 {  
  94.                     newCells[i] = "新单元格值 " + model.getRowCount() + " " + i;  
  95.                 }  
  96.                 //向TableModel中新增一行。  
  97.                 model.addRow(newCells);  
  98.             }  
  99.         });  
  100.         tableMenu.add(addRowItem);  
  101.  
  102.         JMenuItem removeRowsItem = new  JMenuItem("删除选中行");  
  103.         removeRowsItem.addActionListener(new ActionListener()  
  104.         {  
  105.             public void actionPerformed(ActionEvent event)  
  106.             {  
  107.                 //获取所有选中行  
  108.                 int[] selected = table.getSelectedRows();  
  109.                 //依次删除所有选中行  
  110.                 for (int i = selected.length - 1; i >= 0; i--)  
  111.                 {  
  112.                     model.removeRow(selected[i]);  
  113.                 }  
  114.             }  
  115.         });  
  116.         tableMenu.add(removeRowsItem);  
  117.  
  118.         mainWin.pack();  
  119.         mainWin.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  120.         mainWin.setVisible(true);  
  121.     }  
  122.  
  123.     public static void main(String[] args)   
  124.     {  
  125.         new TestDefaultTableModel().init();  
  126.     }  
  127. } 

但要注意列的增加，只是将原来隐藏的列显示，而不是真正增加塔城地区列，你要新增的话那就重新new个JTable

前面讲的表格，单元格都是字符串，这是由于我们传入的都是DefaultTableModel它最终调用toString方法来绘制表格，具体自定义上海电磁阀单元格的方法如下，eg

   
  1. public class TestTableCellRenderer  
  2. {  
  3.     JFrame jf = new JFrame("使用单元格绘制器");  
  4.     JTable table;  
  5.     //定义二维数组作为表格数据  
  6.     Object[][] tableData =   
  7.     {  
  8.         new Object[]{"李清照" , 29 , "女" , new ImageIcon("icon/3.gif") , true},  
  9.         new Object[]{"苏格拉底", 56 , "男" , new ImageIcon("icon/1.gif") , false},  
  10.         new Object[]{"李白", 35 , "男" , new ImageIcon("icon/4.gif")  , true},  
  11.         new Object[]{"弄玉", 18 , "女" , new ImageIcon("icon/2.gif")  , true},  
  12.         new Object[]{"虎头" , 2 , "男" , new ImageIcon("icon/5.gif") , true}  
  13.     };  
  14.     //定义一维数据作为列标题  
  15.     String[] columnTitle = {"姓名" , "年龄" , "性别" , "主头像" , "是否中国人"};  
  16.     public void init()  
  17.     {  
  18.         //以二维数组和一维数组来创建一个ExtendedTableModel对象  
  19.         ExtendedTableModel model = new ExtendedTableModel(columnTitle , tableData);  
  20.         //以ExtendedTableModel来创建JTable  
  21.         table = new JTable( model);  
  22.         table.setRowSelectionAllowed(false);  
  23.         table.setRowHeight(40);  
  24.         //获取第三列  
  25.         TableColumn lastColumn = table.getColumnModel().getColumn(2);  
  26.         //对第三列采用自定义的单元格绘制器  
  27.         lastColumn.setCellRenderer(new GenderTableCellRenderer());  
  28.  
  29.         //将JTable对象放在JScrollPane中，并将该JScrollPane放在窗口中显示出来  
  30.         jf.add(new JScrollPane(table));  
  31.         jf.pack();  
  32.         jf.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  33.         jf.setVisible(true);  
  34.     }  
  35.     public static void main(String[] args)   
  36.     {  
  37.         new TestTableCellRenderer().init();  
  38.     }  
  39. }  
  40.  
  41. class ExtendedTableModel extends DefaultTableModel  
  42. {  
  43.     //重新提供一个构造器，该构造器的实现委托给DefaultTableModel父类  
  44.     public ExtendedTableModel(String[] columnNames , Object[][] cells)  
  45.     {  
  46.         super(cells , columnNames);  
  47.     }  
  48.     //重写getColumnClass方法，根据每列的第一个值来返回其真实的深井潜水泵数据类型  
  49.     public Class getColumnClass(int c)   
  50.     {  
  51.         return getValueAt(0 , c).getClass();  
  52.     }  
  53. }  
  54.  
  55. class GenderTableCellRenderer extends JPanel implements TableCellRenderer  
  56. {  
  57.     private String cellValue;  
  58.     //定义图标的宽度和高度  
  59.     final int ICON_WIDTH = 23;  
  60.     final int ICON_HEIGHT = 21;  
  61.     public Component getTableCellRendererComponent(JTable table, Object value,   
  62.         boolean isSelected, boolean hasFocus, int row, int column)  
  63.     {  
  64.         cellValue = (String)value;  
  65.         //设置选中状态下绘制边框  
  66.         if (hasFocus)  
  67.         {  
  68.             setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));  
  69.         }  
  70.         else 
  71.         {  
  72.             setBorder(null);  
  73.         }  
  74.         return this;  
  75.     }  
  76.     //重写paint方法，负责绘制该离心泵单元格内容  
  77.     public void paint(Graphics g)  
  78.     {  
  79.         //如果表格值为"男"或"male"，则绘制一个男性图标  
  80.         if (cellValue.equalsIgnoreCase("男")   
  81.             || cellValue.equalsIgnoreCase("male"))  
  82.         {  
  83.             drawImage(g , new ImageIcon("icon/male.gif").getImage());   
  84.         }  
  85.         //如果表格值为"女"或"female"，则绘制一个女性图标  
  86.         if (cellValue.equalsIgnoreCase("女")   
  87.             || cellValue.equalsIgnoreCase("female"))  
  88.         {  
  89.             drawImage(g , new ImageIcon("icon/female.gif").getImage());   
  90.         }  
  91.     }  
  92.     //绘制潜水泵图标的方法  
  93.     private void drawImage(Graphics g , Image image)  
  94.     {  
  95.         g.drawImage(image, (getWidth() - ICON_WIDTH ) / 2   
  96.             , (getHeight() - ICON_HEIGHT) / 2 , null);  
  97.     }  
  98. }

我这里只是实现了每列不同的控件，大家还可以自定义一个水泵表格每行每列都是不同的控件，那就要得到单元格再setCellRender。

崇明鲜花/浦东保洁公司/浦东租车/闸北汽车租赁/闸北婚庆礼仪/破碎机/折纸机/耐腐蚀泵/过滤器/混合器/自攻螺丝/厨房刀具/注册公司/装修公司/空调维修/代开发票


http://www.blogjava.net/hechi158/archive/2012/02/24/370661.html