利用java操作Excel文件

     利用java操作Excel，需要jar包－jxl.jar，可以到http://sourceforge.net/project/showfiles.php?group_id=79926下载。

一.读取Excel文件内容

   

1. /**读取Excel文件的内容   
2.  * @param file  待读取的文件   
3.  * @return   
4.  */   
5. public static String readExcel(File file){    
6.     StringBuffer sb = new StringBuffer();    
7.         
8.     Workbook wb = null;    
9.     try {    
10.         //构造Workbook（工作薄）对象    
11.         wb=Workbook.getWorkbook(file);    
12.     } catch (BiffException e) {    
13.         e.printStackTrace();    
14.     } catch (IOException e) {    
15.         e.printStackTrace();    
16.     }    
17.         
18.     if(wb==null)    
19.         return null;    
20.         
21.     //获得了Workbook对象之后，就可以通过它得到Sheet（工作表）对象了    
22.     Sheet[] sheet = wb.getSheets();    
23.         
24.     if(sheet!=null&&sheet.length>0){    
25.         //对每个工作表进行循环    
26.         for(int i=0;i 
27.             //得到当前工作表的行数    
28.             int rowNum = sheet[i].getRows();    
29.             for(int j=0;j 
30.                 //得到当前行的所有单元格    
31.                 Cell[] cells = sheet[i].getRow(j);    
32.                 if(cells!=null&&cells.length>0){    
33.                     //对每个单元格进行循环    
34.                     for(int k=0;k 
35.                         //读取当前单元格的值    
36.                         String cellValue = cells[k].getContents();    
37.                         sb.append(cellValue+"\t");    
38.                     }    
39.                 }    
40.                 sb.append("\r\n");    
41.             }    
42.             sb.append("\r\n");    
43.         }    
44.     }    
45.     //最后关闭资源，释放内存    
46.     wb.close();    
47.     return sb.toString();    
48. }   

 

二.写入Excel文件

这里有很多格式了，比如文本内容加粗，加上某些颜色等，可以参考jxl的api，同时还推荐一篇不错的文章：http://www.ibm.com/developerworks/cn/java/l-javaExcel/?ca=j-t10

 

1. /**生成一个Excel文件   
2.      * @param fileName  要生成的Excel文件名   
3.      */   
4.     public static void writeExcel(String fileName){    
5.         WritableWorkbook wwb = null;    
6.         try {    
7.             //首先要使用Workbook类的工厂方法创建一个可写入的工作薄(Workbook)对象    
8.             wwb = Workbook.createWorkbook(new File(fileName));    
9.         } catch (IOException e) {    
10.             e.printStackTrace();    
11.         }    
12.         if(wwb!=null){    
13.             //创建一个可写入的工作表    
14.             //Workbook的createSheet方法有两个参数，第一个是工作表的名称，第二个是工作表在工作薄中的位置    
15.             WritableSheet ws = wwb.createSheet("sheet1", 0);    
16.                 
17.             //下面开始添加单元格    
18.             for(int i=0;i<10;i++){    
19.                 for(int j=0;j<5;j++){    
20.                     //这里需要注意的是，在Excel中，第一个参数表示列，第二个表示行    
21.                     Label labelC = new Label(j, i, "这是第"+(i+1)+"行，第"+(j+1)+"列");    
22.                     try {    
23.                         //将生成的单元格添加到工作表中    
24.                         ws.addCell(labelC);    
25.                     } catch (RowsExceededException e) {    
26.                         e.printStackTrace();    
27.                     } catch (WriteException e) {    
28.                         e.printStackTrace();    
29.                     }    
30.    
31.                 }    
32.             }    
33.    
34.             try {    
35.                 //从内存中写入文件中    
36.                 wwb.write();    
37.                 //关闭资源，释放内存    
38.                 wwb.close();    
39.             } catch (IOException e) {    
40.                 e.printStackTrace();    
41.             } catch (WriteException e) {    
42.                 e.printStackTrace();    
43.             }    
44.         }    
45.     }    

三.在一个Excel文件中查找是否包含某一个关键字

1. /**搜索某一个文件中是否包含某个关键字   
2.      * @param file  待搜索的文件   
3.      * @param keyWord  要搜索的关键字   
4.      * @return   
5.      */   
6.     public static boolean searchKeyWord(File file,String keyWord){    
7.         boolean res = false;    
8.             
9.         Workbook wb = null;    
10.         try {    
11.             //构造Workbook（工作薄）对象    
12.             wb=Workbook.getWorkbook(file);    
13.         } catch (BiffException e) {    
14.             return res;    
15.         } catch (IOException e) {    
16.             return res;    
17.         }    
18.             
19.         if(wb==null)    
20.             return res;    
21.             
22.         //获得了Workbook对象之后，就可以通过它得到Sheet（工作表）对象了    
23.         Sheet[] sheet = wb.getSheets();    
24.             
25.         boolean breakSheet = false;    
26.             
27.         if(sheet!=null&&sheet.length>0){    
28.             //对每个工作表进行循环    
29.             for(int i=0;i 
30.                 if(breakSheet)    
31.                     break;    
32.                     
33.                 //得到当前工作表的行数    
34.                 int rowNum = sheet[i].getRows();    
35.                     
36.                 boolean breakRow = false;    
37.                     
38.                 for(int j=0;j 
39.                     if(breakRow)    
40.                         break;    
41.                     //得到当前行的所有单元格    
42.                     Cell[] cells = sheet[i].getRow(j);    
43.                     if(cells!=null&&cells.length>0){    
44.                         boolean breakCell = false;    
45.                         //对每个单元格进行循环    
46.                         for(int k=0;k 
47.                             if(breakCell)    
48.                                 break;    
49.                             //读取当前单元格的值    
50.                             String cellValue = cells[k].getContents();    
51.                             if(cellValue==null)    
52.                                 continue;    
53.                             if(cellValue.contains(keyWord)){    
54.                                 res = true;    
55.                                 breakCell = true;    
56.                                 breakRow = true;    
57.                                 breakSheet = true;    
58.                             }    
59.                         }    
60.                     }    
61.                 }    
62.             }    
63.         }    
64.         //最后关闭资源，释放内存    
65.         wb.close();    
66.             
67.         return res;    
68.     }   

 

四.往Excel中插入图片图标

 

1. /**往Excel中插入图片   
2.  * @param dataSheet  待插入的工作表   
3.  * @param col 图片从该列开始   
4.  * @param row 图片从该行开始   
5.  * @param width 图片所占的列数   
6.  * @param height 图片所占的行数   
7.  * @param imgFile 要插入的图片文件   
8.  */   
9. public static void insertImg(WritableSheet dataSheet, int col, int row, int width,    
10.         int height, File imgFile){    
11.     WritableImage img = new WritableImage(col, row, width, height, imgFile);    
12.     dataSheet.addImage(img);    
13. }   

五.插入页眉页脚

 

一般的页眉页脚都分为三个部分,左,中,右三部分,利用如下代码可实现插入页眉页脚：

1. /**向Excel中加入页眉页脚   
2.  * @param dataSheet 待加入页眉的工作表   
3.  * @param left   
4.  * @param center   
5.  * @param right   
6.  */   
7. public static void setHeader(WritableSheet dataSheet,String left,String center,String right){    
8.     HeaderFooter hf = new HeaderFooter();    
9.     hf.getLeft().append(left);    
10.     hf.getCentre().append(center);    
11.     hf.getRight().append(right);    
12.     //加入页眉    
13.     dataSheet.getSettings().setHeader(hf);    
14.     //加入页脚    
15.     //dataSheet.getSettings().setFooter(hf);    
16. }   

 

 

★所有的测试

1. public static void main(String[] args) {
3.         /**
4.          * 测试读取excel
5.          */
6.         System.out.println(readExcel(new File("D:/test.xls")));
7.         /**
8.          * 测试写入文件
9.          */
10.         writeExcel("write.xls");
11.         /**
12.          * 测试该文件里是否有个这个词
13.          */
14.         System.out.println(searchKeyWord(new File("D:/test.xls"), "w"));
15.         /**
16.          *  测试页眉页脚
17.          */
18.         try {
19.             // 创建一个工作薄
20.             WritableWorkbook workbook = Workbook.createWorkbook(new File(
21.                     "D:/test1.xls"));
22.             // 待插入的工作表
23.             WritableSheet dataSheet = workbook.createSheet("加入页眉", 0);
24.             ExcelUtils.setHeader(dataSheet, "chb", "2007-03-06", "第1页,共3页");
25.             workbook.write();
26.             workbook.close();
27.         } catch (IOException e) {
28.             e.printStackTrace();
29.         } catch (WriteException e) {
30.             e.printStackTrace();
31.         }
32.         /**
33.          * 测试插入图片
34.          */
35.         try {
36.             // 创建一个工作薄
37.             WritableWorkbook workbook = Workbook.createWorkbook(new File(
38.                     "D:/test1.xls"));
39.             // 待插入的工作表
40.             WritableSheet imgSheet = workbook.createSheet("Images", 0);
41.             // 要插入的图片文件
42.             File imgFile = new File("D:/a.png");
43.             // 图片插入到第二行第一个单元格，长宽各占六个单元格
44.             insertImg(imgSheet, 0, 1, 6, 10, imgFile);
45.             workbook.write();
46.             workbook.close();
47.         } catch (IOException e) {
48.             e.printStackTrace();
49.         } catch (WriteException e) {
50.             e.printStackTrace();
51.         }
52.     }

 

 

分享到：

JfreeChart学习总结 | EJB3.0连接数据库

• 2008-11-05 15:38
• 浏览 836
• 评论(0)
• 查看更多