`

POI读取Excel 各种特殊数字和类型的转换。取值带一个E

 
阅读更多

1, 对于类似电话号码或手机一类的大数值读取问题 

 

[java] view plaincopyprint?
 
  1. // 取值后会带一个E的问题   
  2. double cellValue = row.getCell(k).getNumericCellValue();   
  3. fieldValues[k] = new DecimalFormat("#").format(cellValue);   


2, 对于数值型单元的纯数值和日期型的处理 

 

 

[java] view plaincopyprint?
 
  1. case HSSFCell.CELL_TYPE_NUMERIC: // 数值型     
  2.     if (HSSFDateUtil.isCellDateFormatted(cell)) {     
  3.         //  如果是date类型则 ，获取该cell的date值     
  4.         value = HSSFDateUtil.getJavaDate(cell.getNumericCellValue()).toString();     
  5.     } else { // 纯数字     
  6.         value = String.valueOf(cell.getNumericCellValue());     
  7. }  


转： POI读取Excel浅谈 
先看代码，挨句解释： 
一般遍历使用两种方式，1：得到总的行数和每行的列数，然后循环。2：使用迭代 
先看第一种： 

 

 

[java] view plaincopyprint?
 
  1. Java代码    
  2. package com.golden.test;     
  3.     
  4. import java.io.File;     
  5. import java.io.FileInputStream;     
  6.     
  7. import org.apache.poi.hssf.usermodel.HSSFCell;     
  8. import org.apache.poi.hssf.usermodel.HSSFRow;     
  9. import org.apache.poi.hssf.usermodel.HSSFSheet;     
  10. import org.apache.poi.hssf.usermodel.HSSFWorkbook;     
  11.     
  12. /**   
  13. *    
  14. * @author 崔素强   
  15. *    
  16. */    
  17. public class PoiReadXls2 {     
  18.     public static void main(String[] args) {     
  19.         File f = new File("c:\\a.xls");     
  20.         try {     
  21.             FileInputStream is = new FileInputStream(f);     
  22.             HSSFWorkbook wbs = new HSSFWorkbook(is);     
  23.             HSSFSheet childSheet = wbs.getSheetAt(0);     
  24.             // System.out.println(childSheet.getPhysicalNumberOfRows());     
  25.             System.out.println("有行数" + childSheet.getLastRowNum());     
  26.             for (int j = 0; j < childSheet.getLastRowNum(); j++) {     
  27.                 HSSFRow row = childSheet.getRow(j);     
  28.                 // System.out.println(row.getPhysicalNumberOfCells());     
  29.                 // System.out.println("有列数" + row.getLastCellNum());     
  30.                 if (null != row) {     
  31.                     for (int k = 0; k < row.getLastCellNum(); k++) {     
  32.   
  33.                         HSSFCell cell = row.getCell(k);     
  34.                         if (null != cell) {     
  35.                             switch (cell.getCellType()) {     
  36.                             case HSSFCell.CELL_TYPE_NUMERIC: // 数字     
  37.                                 System.out.print(cell.getNumericCellValue()     
  38.                                         + "   ");     
  39.                                 break;     
  40.                             case HSSFCell.CELL_TYPE_STRING: // 字符串     
  41.                                 System.out.print(cell.getStringCellValue()     
  42.                                         + "   ");     
  43.                                 break;     
  44.                             case HSSFCell.CELL_TYPE_BOOLEAN: // Boolean     
  45.                                 System.out.println(cell.getBooleanCellValue()     
  46.                                         + "   ");     
  47.                                 break;     
  48.                             case HSSFCell.CELL_TYPE_FORMULA: // 公式     
  49.                                 System.out.print(cell.getCellFormula() + "   ");     
  50.                                 break;     
  51.                             case HSSFCell.CELL_TYPE_BLANK: // 空值     
  52.                                 System.out.println(" ");     
  53.                                 break;     
  54.                             case HSSFCell.CELL_TYPE_ERROR: // 故障     
  55.                                 System.out.println(" ");     
  56.                                 break;     
  57.                             default:     
  58.                                 System.out.print("未知类型   ");     
  59.                                 break;     
  60.                             }     
  61.                         } else {     
  62.                             System.out.print("-   ");     
  63.                         }     
  64.                     }     
  65.                 }     
  66.                 System.out.println();     
  67.             }     
  68.         } catch (Exception e) {     
  69.             e.printStackTrace();     
  70.         }     
  71.     }     
  72. }    
  73.   
  74. package com.golden.test;   
  75.   
  76. import java.io.File;   
  77. import java.io.FileInputStream;   
  78.   
  79. import org.apache.poi.hssf.usermodel.HSSFCell;   
  80. import org.apache.poi.hssf.usermodel.HSSFRow;   
  81. import org.apache.poi.hssf.usermodel.HSSFSheet;   
  82. import org.apache.poi.hssf.usermodel.HSSFWorkbook;   
  83.   
  84. /**  
  85. *  
  86. * @author 崔素强  
  87. *  
  88. */   
  89. public class PoiReadXls2 {   
  90.         public static void main(String[] args) {   
  91.                 File f = new File("c:\\a.xls");   
  92.                 try {   
  93.                         FileInputStream is = new FileInputStream(f);   
  94.                         HSSFWorkbook wbs = new HSSFWorkbook(is);   
  95.                         HSSFSheet childSheet = wbs.getSheetAt(0);   
  96.                         // System.out.println(childSheet.getPhysicalNumberOfRows());   
  97.                         System.out.println("有行数" + childSheet.getLastRowNum());   
  98.                         for (int j = 0; j < childSheet.getLastRowNum(); j++) {   
  99.                                 HSSFRow row = childSheet.getRow(j);   
  100.                                 // System.out.println(row.getPhysicalNumberOfCells());   
  101.                                 // System.out.println("有列数" + row.getLastCellNum());   
  102.                                 if (null != row) {   
  103.                                         for (int k = 0; k < row.getLastCellNum(); k++) {   
  104.                                                 HSSFCell cell = row.getCell(k);   
  105.                                                 if (null != cell) {   
  106.                                                         switch (cell.getCellType()) {   
  107.                                                         case HSSFCell.CELL_TYPE_NUMERIC: // 数字   
  108.                                                                 System.out.print(cell.getNumericCellValue()   
  109.                                                                                 + "   ");   
  110.                                                                 break;   
  111.                                                         case HSSFCell.CELL_TYPE_STRING: // 字符串   
  112.                                                                 System.out.print(cell.getStringCellValue()   
  113.                                                                                 + "   ");   
  114.                                                                 break;   
  115.                                                         case HSSFCell.CELL_TYPE_BOOLEAN: // Boolean   
  116.                                                                 System.out.println(cell.getBooleanCellValue()   
  117.                                                                                 + "   ");   
  118.                                                                 break;   
  119.                                                         case HSSFCell.CELL_TYPE_FORMULA: // 公式   
  120.                                                                 System.out.print(cell.getCellFormula() + "   ");   
  121.                                                                 break;   
  122.                                                         case HSSFCell.CELL_TYPE_BLANK: // 空值   
  123.                                                                 System.out.println(" ");   
  124.                                                                 break;   
  125.                                                         case HSSFCell.CELL_TYPE_ERROR: // 故障   
  126.                                                                 System.out.println(" ");   
  127.                                                                 break;   
  128.                                                         default:   
  129.                                                                 System.out.print("未知类型   ");   
  130.                                                                 break;   
  131.                                                         }   
  132.                                                 } else {   
  133.                                                         System.out.print("-   ");   
  134.                                                 }   
  135.                                         }   
  136.                                 }   
  137.                                 System.out.println();   
  138.                         }   
  139.                 } catch (Exception e) {   
  140.                         e.printStackTrace();   
  141.                 }   
  142.         }   
  143. }  

得到Excel的文件然后读取，这个很简单。关键有两个地方，也许在网上会看到有的这样使用有的那样使用。 
System.out.println("有行数" + childSheet.getLastRowNum()); 
System.out.println(childSheet.getPhysicalNumberOfRows()); 
System.out.println("有列数" + row.getLastCellNum()); 
System.out.println(row.getPhysicalNumberOfCells()); 
如果人都拷贝代码进行使用了，不知道有什么区别。太多的区别不知道，但是有一点我发现了，那就是如果中间各行或者隔列的话getPhysicalNumberOfRows和getPhysicalNumberOfCells就不能读取到所有的行和列了。 
再者，一定要对单元格的格式进行判断switch (cell.getCellType())，不同的单元格格式使用不同的方法。最后加上为止类型，以防万一。 
而且在数字类型里，又分为了纯数字和时间格式： 

 

 

[java] view plaincopyprint?
 
  1. case HSSFCell.CELL_TYPE_NUMERIC: // 数值型     
  2.     if (HSSFDateUtil.isCellDateFormatted(cell)) {     
  3.         //  如果是date类型则 ，获取该cell的date值     
  4.         value = HSSFDateUtil.getJavaDate(cell.getNumericCellValue()).toString();     
  5.     } else { // 纯数字     
  6.         value = String.valueOf(cell.getNumericCellValue());     
  7. }    
  8.   
  9. case HSSFCell.CELL_TYPE_NUMERIC: // 数值型   
  10.         if (HSSFDateUtil.isCellDateFormatted(cell)) {   
  11.                 //  如果是date类型则 ，获取该cell的date值   
  12.                 value = HSSFDateUtil.getJavaDate(cell.getNumericCellValue()).toString();   
  13.         } else { // 纯数字   
  14.                 value = String.valueOf(cell.getNumericCellValue());   
  15. }  


还有一种迭代的方法： 

 

 

[java] view plaincopyprint?
 
  1. package com.golden.test;     
  2.     
  3. import java.io.File;     
  4. import java.io.FileInputStream;     
  5. import java.io.IOException;     
  6. import java.io.InputStream;     
  7. import java.util.Iterator;     
  8. import org.apache.poi.hssf.usermodel.HSSFCell;     
  9. import org.apache.poi.hssf.usermodel.HSSFRow;     
  10. import org.apache.poi.hssf.usermodel.HSSFSheet;     
  11. import org.apache.poi.hssf.usermodel.HSSFWorkbook;     
  12. import org.apache.poi.poifs.filesystem.POIFSFileSystem;     
  13.     
  14. /**   
  15. *    
  16. * @author 崔素强   
  17. *    
  18. */    
  19. public class PoiReadXls {     
  20.     @SuppressWarnings( { "unchecked", "deprecation" })     
  21.     public static void main(String[] args) {     
  22.         File f = new File("c:\\a.xls");     
  23.         try {     
  24.             InputStream input = new FileInputStream(f);     
  25.             POIFSFileSystem fs = new POIFSFileSystem(input);     
  26.             HSSFWorkbook wb = new HSSFWorkbook(fs);     
  27.             HSSFSheet sheet = wb.getSheetAt(0);     
  28.             Iterator rows = sheet.rowIterator();     
  29.             while (rows.hasNext()) {     
  30.                 HSSFRow row = (HSSFRow) rows.next();     
  31.                 // System.out.print("行：" + row.getRowNum() + " ");     
  32.                 Iterator cells = row.cellIterator();     
  33.                 while (cells.hasNext()) {     
  34.                     HSSFCell cell = (HSSFCell) cells.next();     
  35.                     // System.out.println("列：" + cell.getCellNum());     
  36.                     switch (cell.getCellType()) {     
  37.                     case HSSFCell.CELL_TYPE_NUMERIC: // 数字     
  38.                         System.out.print(cell.getNumericCellValue() + "   ");     
  39.                         break;     
  40.                     case HSSFCell.CELL_TYPE_STRING: // 字符串     
  41.                         System.out.print(cell.getStringCellValue() + "   ");     
  42.                         break;     
  43.                     case HSSFCell.CELL_TYPE_BOOLEAN: // Boolean     
  44.                         System.out.println(cell.getBooleanCellValue() + "   ");     
  45.                         break;     
  46.                     case HSSFCell.CELL_TYPE_FORMULA: // 公式     
  47.                         System.out.print(cell.getCellFormula() + "   ");     
  48.                         break;     
  49.                     case HSSFCell.CELL_TYPE_BLANK: // 空值     
  50.                         System.out.println(" ");     
  51.                         break;     
  52.                     case HSSFCell.CELL_TYPE_ERROR: // 故障     
  53.                         System.out.println(" ");     
  54.                         break;     
  55.                     default:     
  56.                         System.out.print("未知类型   ");     
  57.                         break;     
  58.                     }     
  59.                 }     
  60.                 System.out.println();     
  61.             }     
  62.         } catch (IOException ex) {     
  63.             ex.printStackTrace();     
  64.         }     
  65.     }     
  66. }    
  67.   
  68. package com.golden.test;   
  69.   
  70. import java.io.File;   
  71. import java.io.FileInputStream;   
  72. import java.io.IOException;   
  73. import java.io.InputStream;   
  74. import java.util.Iterator;   
  75. import org.apache.poi.hssf.usermodel.HSSFCell;   
  76. import org.apache.poi.hssf.usermodel.HSSFRow;   
  77. import org.apache.poi.hssf.usermodel.HSSFSheet;   
  78. import org.apache.poi.hssf.usermodel.HSSFWorkbook;   
  79. import org.apache.poi.poifs.filesystem.POIFSFileSystem;   
  80.   
  81. /**  
  82. *  
  83. * @author 崔素强  
  84. *  
  85. */   
  86. public class PoiReadXls {   
  87.         @SuppressWarnings( { "unchecked", "deprecation" })   
  88.         public static void main(String[] args) {   
  89.                 File f = new File("c:\\a.xls");   
  90.                 try {   
  91.                         InputStream input = new FileInputStream(f);   
  92.                         POIFSFileSystem fs = new POIFSFileSystem(input);   
  93.                         HSSFWorkbook wb = new HSSFWorkbook(fs);   
  94.                         HSSFSheet sheet = wb.getSheetAt(0);   
  95.                         Iterator rows = sheet.rowIterator();   
  96.                         while (rows.hasNext()) {   
  97.                                 HSSFRow row = (HSSFRow) rows.next();   
  98.                                 // System.out.print("行：" + row.getRowNum() + " ");   
  99.                                 Iterator cells = row.cellIterator();   
  100.                                 while (cells.hasNext()) {   
  101.                                         HSSFCell cell = (HSSFCell) cells.next();   
  102.                                         // System.out.println("列：" + cell.getCellNum());   
  103.                                         switch (cell.getCellType()) {   
  104.                                         case HSSFCell.CELL_TYPE_NUMERIC: // 数字   
  105.                                                 System.out.print(cell.getNumericCellValue() + "   ");   
  106.                                                 break;   
  107.                                         case HSSFCell.CELL_TYPE_STRING: // 字符串   
  108.                                                 System.out.print(cell.getStringCellValue() + "   ");   
  109.                                                 break;   
  110.                                         case HSSFCell.CELL_TYPE_BOOLEAN: // Boolean   
  111.                                                 System.out.println(cell.getBooleanCellValue() + "   ");   
  112.                                                 break;   
  113.                                         case HSSFCell.CELL_TYPE_FORMULA: // 公式   
  114.                                                 System.out.print(cell.getCellFormula() + "   ");   
  115.                                                 break;   
  116.                                         case HSSFCell.CELL_TYPE_BLANK: // 空值   
  117.                                                 System.out.println(" ");   
  118.                                                 break;   
  119.                                         case HSSFCell.CELL_TYPE_ERROR: // 故障   
  120.                                                 System.out.println(" ");   
  121.                                                 break;   
  122.                                         default:   
  123.                                                 System.out.print("未知类型   ");   
  124.                                                 break;   
  125.                                         }   
  126.                                 }   
  127.                                 System.out.println();   
  128.                         }   
  129.                 } catch (IOException ex) {   
  130.                         ex.printStackTrace();   
  131.                 }   
  132.         }   
  133. }  


这种方法，如果数据的紧凑的，使用还是方便的，但是我发现，如果是空行或者是空列，他就会隔过去。具体的自己试试就知道了。 
另外，也能看到这里得到Excel文件的方式是通过File，如果要引用到Struts2里，这是很简单的，因为Struts2上传时Action里定义的就是File或者File数组。 

 

原文章地址：http://jammy-zhou.iteye.com/blog/850240

分享到：
| poi导入excel判断单元格类型及转换
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    利用POI读取excel写入到word

    在IT行业中，Apache POI是一个广泛使用的开源库，专门用于处理Microsoft Office格式的文件，如Excel、Word和PowerPoint。本篇文章将详细讲解如何利用Apache POI库来读取Excel数据并将其写入到Word文档中。 首先，...

    POI读取excel的内容.zip

    在Java编程领域，Apache POI库是一个非常重要的工具，它允许开发者处理Microsoft Office格式的文件，包括Excel（.xlsx和.xls）文档。本教程将详细讲解如何使用Apache POI库来读取Excel文件的内容。 首先，为了在...

    POI读取Excel带格式数据

    总之，Apache POI是Java开发人员处理Excel文件的强大工具，通过理解其API结构和工作原理，我们可以方便地读取和处理Excel中的带格式数据。无论是简单的数据导出还是复杂的业务逻辑，POI都能胜任。在阅读这篇博客...

    poi读取excel文件

    在Java编程环境中，Apache POI库是一个非常重要的工具，它允许开发者读取、写入以及修改Microsoft Office格式的文件，包括Excel的.xls和.xlsx格式。标题提到的"poi读取excel文件"，指的是使用Apache POI库来处理...

    POI读取EXCEL教程

    Apache POI 是一个流行的开源库，主要用于处理Microsoft Office格式的文件，尤其是Excel。在Java编程环境中，如果你需要读取或写入Excel文件，POI 提供了强大的支持。本教程将深入讲解如何使用POI的HSSF组件来处理...

    poi读取excel文件实例（兼容excel2007）

    Apache POI 是一个开源项目，专门用于处理Microsoft Office格式的文件，包括Excel。在Java世界里，当你需要处理Excel 2007及以上版本（即XLSX格式）的文件时，Apache POI是一个非常实用的库。由于JXL库不支持XLSX...

    android5使用poi读取excel

    android5使用poi读取excel,android5使用poi读取excel,android5使用poi读取excel,android5使用poi读取excel

    POI读取excel的例子

    POI读取excel的例子

    poi读取excel并输出到jsp页面

    Apache POI 是一个开源项目，它允许开发者创建、修改和显示MS Office格式的文件，其中就包括Excel。 在Java开发中，Apache POI库提供了API来读取、写入和操作Excel文件。读取Excel文件时，主要涉及到的工作包括打开...

    poi 读取excel小实例

    实现了JAVA 窗口，读取EXCEL文件，用poi读取EXCEL内容只是一个小例子

    POI生成Excel POI操作Excel POI读取Excel POI类库

    Apache POI是一个强大的Java库，专门用于处理Microsoft Office格式的文件，尤其是Excel。在这个场景中，我们关注的是如何使用POI来创建、读取和操作Excel文档。在Web项目中，这种功能通常用于数据导入导出，报表生成...

    android POI 读取excel 精简jar

    Apache POI是一个流行的开源项目，它允许程序员创建、修改和显示Microsoft Office格式的文件，包括Excel（.xls和.xlsx）。在这个“android POI 读取excel 精简jar”中，我们看到了几个关键的库文件，它们是专门为...

    apache POI 读取 Excel

    apache poi 读取 Excel 的 jar 包 博文链接：https://wxinpeng.iteye.com/blog/231895

    POI读取Excel合并单元格并储存

    Apache POI是一个强大的库，允许程序员使用Java来创建、修改和显示Microsoft Office格式的文件，包括Excel（XLS和XLSX）。在我们的场景中，我们将关注如何读取Excel文件，尤其是处理那些合并了单元格的行与列，因为...

    poi读取excel2007和2003兼容工具例子

    7. **代码示例**：在提供的"读取excel2007和2003兼容例子"中，应包含一个Factory类，如`WorkbookFactory`，它有一个静态方法`getWorkbook(String filePath)`。这个方法会检查文件扩展名，并返回相应的`Workbook`实例...

    poi excel 模板读取并导出带公式的excel文档

    ### POI Excel 模板读取并导出带公式的Excel文档 #### 一、概述 在实际工作中，经常需要批量处理数据，并将其导出到Excel文件中，特别是在需要复杂计算的情况下，例如工资单、统计数据汇总等场景。利用Apache POI...

    java 读取excel表格数据 poi

    java读取excel 表格数据。 public static void main(String[] args) { String[][] content=POIExcelUtils.read("E:\\1.xlsx"); for(int i=0;i;i++) { if(content[i]!=null){ for(int j=0;j[i].length;j...

    poi 读取EXCEL所需要的JAR

    Apache POI 是一个开源项目，专门用于处理Microsoft Office格式的文件，如Excel、Word和PowerPoint。在Java环境中，如果你需要使用POI库来读取、写入或操作Excel文件，你需要确保你的项目中包含了正确的JAR文件。在...

    poi读取Excel用到的jar包

    在Java编程环境中，Apache POI库是...总的来说，Apache POI是一个强大的Java库，它使得开发者能够方便地在Java程序中处理Excel文件，无论是读取数据还是生成报告。正确地引入和使用这些jar包，可以极大地提高开发效率。

    java POI读取excel文件数据

    Java POI库是Apache软件基金会开发的一个开源项目，专门用于处理Microsoft Office格式的文件，如Word、PowerPoint和尤其在本场景中提到的Excel。它提供了API，使得开发者能够使用Java来读取、写入和修改Excel文件。...

Magicbox
Global site tag (gtag.js) - Google Analytics