程序博客网 > axure软件下载

POI读取Excel 各种特殊数字和类型的转换。

来源：互联网 发布：axure软件下载 编辑：程序博客网 时间：2024/05/23 23:47

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

[java] view plain copy
  1. // 取值后会带一个E的问题   
  2. double cellValue = row.getCell(k).getNumericCellValue();   
  3. new DecimalFormat("#").format(cellValue);   
  4. //如874349394后台获取时会变成科学计数法的数字
  5. 自己的代码：private String getCellStrValue2(HSSFCell cell) {
    if (cell == null) {
    return "";
    }
    try {
    // 按照字符串格式读取
    log.debug("getCellStrValue:= |" + cell.getStringCellValue());
    return cell.getStringCellValue();
    } catch (Exception e) {
    // 读取出错，说明是数字格式
    String s = new DecimalFormat("#.##").format(cell.getNumericCellValue());
    log.debug("getCellStrValue:=" + s);
    return s;
    }
    }

DecimalFormat用法

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。

DecimalFormat 包含一个模式 和一组符号 


符号含义： 

0 一个数字 

# 一个数字，不包括 0 

. 小数的分隔符的占位符 

, 分组分隔符的占位符 

; 分隔格式。 

- 缺省负数前缀。 

% 乘以 100 和作为百分比显示 

? 乘以 1000 和作为千进制货币符显示；用货币符号代替；如果双写，用 

国际货币符号代替。如果出现在一个模式中，用货币十进制分隔符代 

替十进制分隔符。 

X 前缀或后缀中使用的任何其它字符，用来引用前缀或后缀中的特殊字符。 

例子： 

DecimalFormat df1 = new DecimalFormat("0.0"); 

DecimalFormat df2 = new DecimalFormat("#.#"); 

DecimalFormat df3 = new DecimalFormat("000.000"); 

DecimalFormat df4 = new DecimalFormat("###.###"); 

System.out.println(df1.format(12.34)); 

System.out.println(df2.format(12.34)); 

System.out.println(df3.format(12.34)); 

System.out.println(df4.format(12.34)); 

结果： 

12.3 

12.3 

012.340 

12.34


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

[java] view plain copy
  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 plain copy
  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 plain copy
  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 plain copy
  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

0 1
axure软件下载 axure软件下载
原创粉丝点击
热门IT博客
跳跃网络官方跳跃网络官方
软件上线报告软件上线报告
megadownloader mac
扬州大学怎么样 知乎
突破淘宝发布限制
淘宝管控记录可以几次
薛之谦淘宝店链接
鸟叔带你学linux
c ubuntu
red hat linux 下载
淘宝原单好店
谷阿莫 知乎
python如何使用idle
java 线程 static
做淘宝用的电脑配置
flume windows agent
im talk软件
php实现九九乘法表
阿里云服务器降低配置
旅行社 是 什么软件
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 锚杆长度检测 中空锚杆技术条件 手持式锚杆钻机 矿用锚杆价格 矿用锚杆钻机 矿用等强锚杆 锚杆生产厂家 矿用锚杆厂家 矿用锚杆生产厂家 锚杆支护图片 中空锚杆厂家 煤矿巷道锚杆支护技术 隧道锚杆支护 边坡支护锚杆 超前锚杆支护 边坡锚杆支护施工图 打锚杆多少钱一米 水泥砂浆锚杆 自进式锚杆价格 什么是锚杆支护 土层锚杆支护 中空锚杆图片 锚杆支护价格 边坡锚杆支护设计 基坑支护锚杆 砂浆锚杆厂家 25中空锚杆价格 锚杆支护原理 自钻式锚杆价格 锚杆无损检测仪 锚杆支护作用原理 煤矿锚杆价格 锚杆支护厂家 锚杆钻机价格 基坑锚杆支护施工方案 锚杆支护单价 土钉与锚杆的区别 锚杆支护质量 锚杆支护方式 隧道砂浆锚杆 锚杆支护设备

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里