码迷，mamicode.com
首页 > 其他好文 > 详细

POI读写海量Excel

时间：2017-07-19 23:20:35      阅读：204      评论：0      收藏：0      [点我收藏+]

标签：block   color   tin   comm   精度   time   测试   font   att   

目前处理Excel的开源javaAPI主要有两种，一是Jxl（Java Excel API）,Jxl只支持Excel2003以下的版本。另外一种是Apache的Jakarta POI,相比于Jxl,POI对微软办公文档的支持更加强大，但是它使用复杂，上手慢。POI可支持更高的Excel版本2007。对Excel的读取，POI有两种模式，一是用户模式，这种方式同Jxl的使用很类似，使用简单，都是将文件一次性读到内存，文件小的时候，没有什么问题，当文件大的时候，就会出现OutOfMemory的内存溢出问题。第二种是事件驱动模式，拿Excel2007来说，其内容采用XML的格式来存储，所以处理excel就是解析XML，而目前使用事件驱动模式解析XML的API是SAX(Simple API for XML)，这种模型在读取XML文档时，并没有将整个文档读入内存，而是按顺序将整个文档解析完，在解析过程中，会主动产生事件交给程序中相应的处理函数来处理当前内容。因此这种方式对系统资源要求不高，可以处理海量数据。笔者曾经做过测试，这种方法处理一千万条，每条五列的数据花费大约11分钟。可见处理海量数据的文件事件驱动是一个很好的方式。而本文中用到的AbstractExcel2003Reader、AbstractExcel2007Reader对Excel的读取都是采用这种POI的事件驱动模式。至于Excel的写操作，对较高版本的Excel2007，POI提供了很好的支持，主要流程是第一步构建工作薄和电子表格对象，第二步在一个流中构建文本文件，第三步使用流中产生的数据替换模板中的电子表格。这种方式也可以处理海量数据文件。AbstractExcel2007Writer就是使用这种方式进行写操作。对于写入较低版本的Excel2003，POI使用了用户模式来处理，就是将整个文档加载进内存，如果数据量大的话就会出现内存溢出的问题，Excel2003Writer就是使用这种方式。据笔者的测试，如果数据量大于3万条，每条8列的话，就会报OutOfMemory的错误。Excel2003中每个电子表格的记录数必须在65536以下，否则就会发生异常。目前还没有好的解决方案，建议对于海量数据写入操作，尽量使用Excel2007。

[java] view plain copy
  1. /** 
  2.  * 抽象Excel2003读取器，通过实现HSSFListener监听器，采用事件驱动模式解析excel2003 
  3.  * 中的内容，遇到特定事件才会触发，大大减少了内存的使用。 
  4.  * 
  5.  */  
  6. public  class Excel2003Reader implements HSSFListener{  
  7.     private int minColumns = -1;  
  8.     private POIFSFileSystem fs;  
  9.     private int lastRowNumber;  
  10.     private int lastColumnNumber;  
  11.   
  12.     /** Should we output the formula, or the value it has? */  
  13.     private boolean outputFormulaValues = true;  
  14.   
  15.     /** For parsing Formulas */  
  16.     private SheetRecordCollectingListener workbookBuildingListener;  
  17.     //excel2003工作薄  
  18.     private HSSFWorkbook stubWorkbook;  
  19.   
  20.     // Records we pick up as we process  
  21.     private SSTRecord sstRecord;  
  22.     private FormatTrackingHSSFListener formatListener;  
  23.   
  24.     //表索引  
  25.     private int sheetIndex = -1;  
  26.     private BoundSheetRecord[] orderedBSRs;  
  27.     @SuppressWarnings("unchecked")  
  28.     private ArrayList boundSheetRecords = new ArrayList();  
  29.   
  30.     // For handling formulas with string results  
  31.     private int nextRow;  
  32.     private int nextColumn;  
  33.     private boolean outputNextStringRecord;  
  34.     //当前行  
  35.     private int curRow = 0;  
  36.     //存储行记录的容器  
  37.     private List<String> rowlist = new ArrayList<String>();;  
  38.     @SuppressWarnings( "unused")  
  39.     private String sheetName;  
  40.       
  41.     private IRowReader rowReader;  
  42.   
  43.       
  44.     public void setRowReader(IRowReader rowReader){  
  45.         this.rowReader = rowReader;  
  46.     }  
  47.       
  48.     /** 
  49.      * 遍历excel下所有的sheet 
  50.      * @throws IOException 
  51.      */  
  52.     public void process(String fileName) throws IOException {  
  53.         this.fs = new POIFSFileSystem(new FileInputStream(fileName));  
  54.         MissingRecordAwareHSSFListener listener = new MissingRecordAwareHSSFListener(  
  55.                 this);  
  56.         formatListener = new FormatTrackingHSSFListener(listener);  
  57.         HSSFEventFactory factory = new HSSFEventFactory();  
  58.         HSSFRequest request = new HSSFRequest();  
  59.         if (outputFormulaValues) {  
  60.             request.addListenerForAllRecords(formatListener);  
  61.         } else {  
  62.             workbookBuildingListener = new SheetRecordCollectingListener(  
  63.                     formatListener);  
  64.             request.addListenerForAllRecords(workbookBuildingListener);  
  65.         }  
  66.         factory.processWorkbookEvents(request, fs);  
  67.     }  
  68.       
  69.     /** 
  70.      * HSSFListener 监听方法，处理 Record 
  71.      */  
  72.     @SuppressWarnings("unchecked")  
  73.     public void processRecord(Record record) {  
  74.         int thisRow = -1;  
  75.         int thisColumn = -1;  
  76.         String thisStr = null;  
  77.         String value = null;  
  78.         switch (record.getSid()) {  
  79.             case BoundSheetRecord.sid:  
  80.                 boundSheetRecords.add(record);  
  81.                 break;  
  82.             case BOFRecord.sid:  
  83.                 BOFRecord br = (BOFRecord) record;  
  84.                 if (br.getType() == BOFRecord.TYPE_WORKSHEET) {  
  85.                     // 如果有需要，则建立子工作薄  
  86.                     if (workbookBuildingListener != null && stubWorkbook == null) {  
  87.                         stubWorkbook = workbookBuildingListener  
  88.                                 .getStubHSSFWorkbook();  
  89.                     }  
  90.                       
  91.                     sheetIndex++;  
  92.                     if (orderedBSRs == null) {  
  93.                         orderedBSRs = BoundSheetRecord  
  94.                                 .orderByBofPosition(boundSheetRecords);  
  95.                     }  
  96.                     sheetName = orderedBSRs[sheetIndex].getSheetname();  
  97.                 }  
  98.                 break;  
  99.       
  100.             case SSTRecord.sid:  
  101.                 sstRecord = (SSTRecord) record;  
  102.                 break;  
  103.       
  104.             case BlankRecord.sid:  
  105.                 BlankRecord brec = (BlankRecord) record;  
  106.                 thisRow = brec.getRow();  
  107.                 thisColumn = brec.getColumn();  
  108.                 thisStr = "";  
  109.                 rowlist.add(thisColumn, thisStr);  
  110.                 break;  
  111.             case BoolErrRecord.sid: //单元格为布尔类型  
  112.                 BoolErrRecord berec = (BoolErrRecord) record;  
  113.                 thisRow = berec.getRow();  
  114.                 thisColumn = berec.getColumn();  
  115.                 thisStr = berec.getBooleanValue()+"";  
  116.                 rowlist.add(thisColumn, thisStr);  
  117.                 break;  
  118.       
  119.             case FormulaRecord.sid: //单元格为公式类型  
  120.                 FormulaRecord frec = (FormulaRecord) record;  
  121.                 thisRow = frec.getRow();  
  122.                 thisColumn = frec.getColumn();  
  123.                 if (outputFormulaValues) {  
  124.                     if (Double.isNaN(frec.getValue())) {  
  125.                         // Formula result is a string  
  126.                         // This is stored in the next record  
  127.                         outputNextStringRecord = true;  
  128.                         nextRow = frec.getRow();  
  129.                         nextColumn = frec.getColumn();  
  130.                     } else {  
  131.                         thisStr = formatListener.formatNumberDateCell(frec);  
  132.                     }  
  133.                 } else {  
  134.                     thisStr = ‘"‘ + HSSFFormulaParser.toFormulaString(stubWorkbook,  
  135.                             frec.getParsedExpression()) + ‘"‘;  
  136.                 }  
  137.                 rowlist.add(thisColumn,thisStr);  
  138.                 break;  
  139.             case StringRecord.sid://单元格中公式的字符串  
  140.                 if (outputNextStringRecord) {  
  141.                     // String for formula  
  142.                     StringRecord srec = (StringRecord) record;  
  143.                     thisStr = srec.getString();  
  144.                     thisRow = nextRow;  
  145.                     thisColumn = nextColumn;  
  146.                     outputNextStringRecord = false;  
  147.                 }  
  148.                 break;  
  149.             case LabelRecord.sid:  
  150.                 LabelRecord lrec = (LabelRecord) record;  
  151.                 curRow = thisRow = lrec.getRow();  
  152.                 thisColumn = lrec.getColumn();  
  153.                 value = lrec.getValue().trim();  
  154.                 value = value.equals("")?" ":value;  
  155.                 this.rowlist.add(thisColumn, value);  
  156.                 break;  
  157.             case LabelSSTRecord.sid:  //单元格为字符串类型  
  158.                 LabelSSTRecord lsrec = (LabelSSTRecord) record;  
  159.                 curRow = thisRow = lsrec.getRow();  
  160.                 thisColumn = lsrec.getColumn();  
  161.                 if (sstRecord == null) {  
  162.                     rowlist.add(thisColumn, " ");  
  163.                 } else {  
  164.                     value =  sstRecord  
  165.                     .getString(lsrec.getSSTIndex()).toString().trim();  
  166.                     value = value.equals("")?" ":value;  
  167.                     rowlist.add(thisColumn,value);  
  168.                 }  
  169.                 break;  
  170.             case NumberRecord.sid:  //单元格为数字类型  
  171.                 NumberRecord numrec = (NumberRecord) record;  
  172.                 curRow = thisRow = numrec.getRow();  
  173.                 thisColumn = numrec.getColumn();  
  174.                 value = formatListener.formatNumberDateCell(numrec).trim();  
  175.                 value = value.equals("")?" ":value;  
  176.                 // 向容器加入列值  
  177.                 rowlist.add(thisColumn, value);  
  178.                 break;  
  179.             default:  
  180.                 break;  
  181.         }  
  182.   
  183.         // 遇到新行的操作  
  184.         if (thisRow != -1 && thisRow != lastRowNumber) {  
  185.             lastColumnNumber = -1;  
  186.         }  
  187.   
  188.         // 空值的操作  
  189.         if (record instanceof MissingCellDummyRecord) {  
  190.             MissingCellDummyRecord mc = (MissingCellDummyRecord) record;  
  191.             curRow = thisRow = mc.getRow();  
  192.             thisColumn = mc.getColumn();  
  193.             rowlist.add(thisColumn," ");  
  194.         }  
  195.   
  196.         // 更新行和列的值  
  197.         if (thisRow > -1)  
  198.             lastRowNumber = thisRow;  
  199.         if (thisColumn > -1)  
  200.             lastColumnNumber = thisColumn;  
  201.   
  202.         // 行结束时的操作  
  203.         if (record instanceof LastCellOfRowDummyRecord) {  
  204.             if (minColumns > 0) {  
  205.                 // 列值重新置空  
  206.                 if (lastColumnNumber == -1) {  
  207.                     lastColumnNumber = 0;  
  208.                 }  
  209.             }  
  210.             lastColumnNumber = -1;  
  211.                 // 每行结束时， 调用getRows() 方法  
  212.             rowReader.getRows(sheetIndex,curRow, rowlist);  
  213.               
  214.             // 清空容器  
  215.             rowlist.clear();  
  216.         }  
  217.     }  
  218.       
  219. }  
[java] view plain copy
  1. /** 
  2.  * 抽象Excel2007读取器，excel2007的底层数据结构是xml文件，采用SAX的事件驱动的方法解析 
  3.  * xml，需要继承DefaultHandler，在遇到文件内容时，事件会触发，这种做法可以大大降低 
  4.  * 内存的耗费，特别使用于大数据量的文件。 
  5.  * 
  6.  */  
  7. public class Excel2007Reader extends DefaultHandler {  
  8.     //共享字符串表  
  9.     private SharedStringsTable sst;  
  10.     //上一次的内容  
  11.     private String lastContents;  
  12.     private boolean nextIsString;  
  13.   
  14.     private int sheetIndex = -1;  
  15.     private List<String> rowlist = new ArrayList<String>();  
  16.     //当前行  
  17.     private int curRow = 0;  
  18.     //当前列  
  19.     private int curCol = 0;  
  20.     //日期标志  
  21.     private boolean dateFlag;  
  22.     //数字标志  
  23.     private boolean numberFlag;  
  24.       
  25.     private boolean isTElement;  
  26.       
  27.     private IRowReader rowReader;  
  28.       
  29.     public void setRowReader(IRowReader rowReader){  
  30.         this.rowReader = rowReader;  
  31.     }  
  32.       
  33.     /**只遍历一个电子表格，其中sheetId为要遍历的sheet索引，从1开始，1-3 
  34.      * @param filename 
  35.      * @param sheetId 
  36.      * @throws Exception 
  37.      */  
  38.     public void processOneSheet(String filename,int sheetId) throws Exception {  
  39.         OPCPackage pkg = OPCPackage.open(filename);  
  40.         XSSFReader r = new XSSFReader(pkg);  
  41.         SharedStringsTable sst = r.getSharedStringsTable();  
  42.         XMLReader parser = fetchSheetParser(sst);  
  43.           
  44.         // 根据 rId# 或 rSheet# 查找sheet  
  45.         InputStream sheet2 = r.getSheet("rId"+sheetId);  
  46.         sheetIndex++;  
  47.         InputSource sheetSource = new InputSource(sheet2);  
  48.         parser.parse(sheetSource);  
  49.         sheet2.close();  
  50.     }  
  51.   
  52.     /** 
  53.      * 遍历工作簿中所有的电子表格 
  54.      * @param filename 
  55.      * @throws Exception 
  56.      */  
  57.     public void process(String filename) throws Exception {  
  58.         OPCPackage pkg = OPCPackage.open(filename);  
  59.         XSSFReader r = new XSSFReader(pkg);  
  60.         SharedStringsTable sst = r.getSharedStringsTable();  
  61.         XMLReader parser = fetchSheetParser(sst);  
  62.         Iterator<InputStream> sheets = r.getSheetsData();  
  63.         while (sheets.hasNext()) {  
  64.             curRow = 0;  
  65.             sheetIndex++;  
  66.             InputStream sheet = sheets.next();  
  67.             InputSource sheetSource = new InputSource(sheet);  
  68.             parser.parse(sheetSource);  
  69.             sheet.close();  
  70.         }  
  71.     }  
  72.   
  73.     public XMLReader fetchSheetParser(SharedStringsTable sst)  
  74.             throws SAXException {  
  75.         XMLReader parser = XMLReaderFactory  
  76.                 .createXMLReader("org.apache.xerces.parsers.SAXParser");  
  77.         this.sst = sst;  
  78.         parser.setContentHandler(this);  
  79.         return parser;  
  80.     }  
  81.   
  82.     public void startElement(String uri, String localName, String name,  
  83.             Attributes attributes) throws SAXException {  
  84.           
  85.         // c => 单元格  
  86.         if ("c".equals(name)) {  
  87.             // 如果下一个元素是 SST 的索引，则将nextIsString标记为true  
  88.             String cellType = attributes.getValue("t");  
  89.             if ("s".equals(cellType)) {  
  90.                 nextIsString = true;  
  91.             } else {  
  92.                 nextIsString = false;  
  93.             }  
  94.             //日期格式  
  95.             String cellDateType = attributes.getValue("s");  
  96.             if ("1".equals(cellDateType)){  
  97.                 dateFlag = true;  
  98.             } else {  
  99.                 dateFlag = false;  
  100.             }  
  101.             String cellNumberType = attributes.getValue("s");  
  102.             if("2".equals(cellNumberType)){  
  103.                 numberFlag = true;  
  104.             } else {  
  105.                 numberFlag = false;  
  106.             }  
  107.               
  108.         }  
  109.         //当元素为t时  
  110.         if("t".equals(name)){  
  111.             isTElement = true;  
  112.         } else {  
  113.             isTElement = false;  
  114.         }  
  115.           
  116.         // 置空  
  117.         lastContents = "";  
  118.     }  
  119.   
  120.     public void endElement(String uri, String localName, String name)  
  121.             throws SAXException {  
  122.           
  123.         // 根据SST的索引值的到单元格的真正要存储的字符串  
  124.         // 这时characters()方法可能会被调用多次  
  125.         if (nextIsString) {  
  126.             try {  
  127.                 int idx = Integer.parseInt(lastContents);  
  128.                 lastContents = new XSSFRichTextString(sst.getEntryAt(idx))  
  129.                         .toString();  
  130.             } catch (Exception e) {  
  131.   
  132.             }  
  133.         }   
  134.         //t元素也包含字符串  
  135.         if(isTElement){  
  136.             String value = lastContents.trim();  
  137.             rowlist.add(curCol, value);  
  138.             curCol++;  
  139.             isTElement = false;  
  140.             // v => 单元格的值，如果单元格是字符串则v标签的值为该字符串在SST中的索引  
  141.             // 将单元格内容加入rowlist中，在这之前先去掉字符串前后的空白符  
  142.         } else if ("v".equals(name)) {  
  143.             String value = lastContents.trim();  
  144.             value = value.equals("")?" ":value;  
  145.             //日期格式处理  
  146.             if(dateFlag){  
  147.                  Date date = HSSFDateUtil.getJavaDate(Double.valueOf(value));  
  148.                  SimpleDateFormat dateFormat = new SimpleDateFormat(  
  149.                  "dd/MM/yyyy");  
  150.                  value = dateFormat.format(date);  
  151.             }   
  152.             //数字类型处理  
  153.             if(numberFlag){  
  154.                 BigDecimal bd = new BigDecimal(value);  
  155.                 value = bd.setScale(3,BigDecimal.ROUND_UP).toString();  
  156.             }  
  157.             rowlist.add(curCol, value);  
  158.             curCol++;  
  159.         }else {  
  160.             //如果标签名称为 row ，这说明已到行尾，调用 optRows() 方法  
  161.             if (name.equals("row")) {  
  162.                 rowReader.getRows(sheetIndex,curRow,rowlist);  
  163.                 rowlist.clear();  
  164.                 curRow++;  
  165.                 curCol = 0;  
  166.             }  
  167.         }  
  168.           
  169.     }  
  170.   
  171.     public void characters(char[] ch, int start, int length)  
  172.             throws SAXException {  
  173.         //得到单元格内容的值  
  174.         lastContents += new String(ch, start, length);  
  175.     }  
  176. }  



[java] view plain copy
  1. public class ExcelReaderUtil {  
  2.       
  3.     //excel2003扩展名  
  4.     public static final String EXCEL03_EXTENSION = ".xls";  
  5.     //excel2007扩展名  
  6.     public static final String EXCEL07_EXTENSION = ".xlsx";  
  7.       
  8.     /** 
  9.      * 读取Excel文件，可能是03也可能是07版本 
  10.      * @param excel03 
  11.      * @param excel07 
  12.      * @param fileName 
  13.      * @throws Exception  
  14.      */  
  15.     public static void readExcel(IRowReader reader,String fileName) throws Exception{  
  16.         // 处理excel2003文件  
  17.         if (fileName.endsWith(EXCEL03_EXTENSION)){  
  18.             Excel2003Reader excel03 = new Excel2003Reader();  
  19.             excel03.setRowReader(reader);  
  20.             excel03.process(fileName);  
  21.         // 处理excel2007文件  
  22.         } else if (fileName.endsWith(EXCEL07_EXTENSION)){  
  23.             Excel2007Reader excel07 = new Excel2007Reader();  
  24.             excel07.setRowReader(reader);  
  25.             excel07.process(fileName);  
  26.         } else {  
  27.             throw new  Exception("文件格式错误，fileName的扩展名只能是xls或xlsx。");  
  28.         }  
  29.     }  
  30. }  



[java] view plain copy
  1. public interface IRowReader {  
  2.       
  3.     /**业务逻辑实现方法 
  4.      * @param sheetIndex 
  5.      * @param curRow 
  6.      * @param rowlist 
  7.      */  
  8.     public  void getRows(int sheetIndex,int curRow, List<String> rowlist);  
  9. }  



[java] view plain copy
  1. public class RowReader implements IRowReader{  
  2.   
  3.   
  4.     /* 业务逻辑实现方法 
  5.      * @see com.eprosun.util.excel.IRowReader#getRows(int, int, java.util.List) 
  6.      */  
  7.     public void getRows(int sheetIndex, int curRow, List<String> rowlist) {  
  8.         // TODO Auto-generated method stub  
  9.         System.out.print(curRow+" ");  
  10.         for (int i = 0; i < rowlist.size(); i++) {  
  11.             System.out.print(rowlist.get(i) + " ");  
  12.         }  
  13.         System.out.println();  
  14.     }  
  15.   
  16. }  

 

[java] view plain copy
  1. public class Main {  
  2.       
  3.     public static void main(String[] args) throws Exception {  
  4.         IRowReader reader = new RowReader();  
  5.         //ExcelReaderUtil.readExcel(reader, "F://te03.xls");  
  6.         ExcelReaderUtil.readExcel(reader, "F://test07.xlsx");  
  7.     }  
  8. }  



[java] view plain copy
  1. public class Excel2003Writer {  
  2.   
  3.     /** 
  4.      * @param args 
  5.      */  
  6.     public static void main(String[] args) {  
  7.         try{      
  8.             System.out.println("开始写入excel2003....");  
  9.             writeExcel("tes2003.xls");  
  10.             System.out.println("写完xcel2003");  
  11.         } catch (IOException e) {  
  12.           
  13.         }  
  14.     }  
  15.       
  16.       
  17.     /** 
  18.      * 写入excel并填充内容,一个sheet只能写65536行以下，超出会报异常，写入时建议使用AbstractExcel2007Writer 
  19.      * @param fileName 
  20.      * @throws IOException 
  21.      */  
  22.     public static void writeExcel(String fileName) throws IOException{  
  23.               
  24.             // 创建excel2003对象  
  25.             Workbook wb = new HSSFWorkbook();  
  26.               
  27.             // 设置文件放置路径和文件名  
  28.             FileOutputStream fileOut = new FileOutputStream(fileName);  
  29.             // 创建新的表单  
  30.             Sheet sheet = wb.createSheet("newsheet");  
  31.             // 创建新行  
  32.             for(int i=0;i<20000;i++){  
  33.                 Row row = sheet.createRow(i);  
  34.                 // 创建单元格  
  35.                 Cell cell = row.createCell(0);  
  36.                 // 设置单元格值  
  37.                 cell.setCellValue(1);  
  38.                 row.createCell(1).setCellValue(1+i);  
  39.                 row.createCell(2).setCellValue(true);  
  40.                 row.createCell(3).setCellValue(0.43d);  
  41.                 row.createCell(4).setCellValue(‘d‘);  
  42.                 row.createCell(5).setCellValue("");  
  43.                 row.createCell(6).setCellValue("第七列"+i);  
  44.                 row.createCell(7).setCellValue("第八列"+i);  
  45.             }  
  46.             wb.write(fileOut);  
  47.             fileOut.close();  
  48.     }  
  49.   
  50.   
  51. }  









[java] view plain copy







    

  1. /** 
    2. 

  2.  * 抽象excel2007读入器，先构建.xlsx一张模板，改写模板中的sheet.xml,使用这种方法 
    3. 

  3.  * 写入.xlsx文件，不需要太大的内存 
    4. 

  4.  * 
    5. 

  5.  */  
    6. 

  6. public abstract class AbstractExcel2007Writer {  
    7. 

  7.       
    8. 

  8.     private SpreadsheetWriter sw;  
    9. 

  9.   
    10. 

  10.     /** 
    11. 

  11.      * 写入电子表格的主要流程 
    12. 

  12.      * @param fileName 
    13. 

  13.      * @throws Exception 
    14. 

  14.      */  
    15. 

  15.     public void process(String fileName) throws Exception{  
    16. 

  16.         // 建立工作簿和电子表格对象  
    17. 

  17.         XSSFWorkbook wb = new XSSFWorkbook();  
    18. 

  18.         XSSFSheet sheet = wb.createSheet("sheet1");  
    19. 

  19.         // 持有电子表格数据的xml文件名 例如 /xl/worksheets/sheet1.xml  
    20. 

  20.         String sheetRef = sheet.getPackagePart().getPartName().getName();  
    21. 

  21.   
    22. 

  22.         // 保存模板  
    23. 

  23.         FileOutputStream os = new FileOutputStream("template.xlsx");  
    24. 

  24.         wb.write(os);  
    25. 

  25.         os.close();  
    26. 

  26.           
    27. 

  27.         // 生成xml文件  
    28. 

  28.         File tmp = File.createTempFile("sheet", ".xml");  
    29. 

  29.         Writer fw = new FileWriter(tmp);  
    30. 

  30.         sw = new SpreadsheetWriter(fw);  
    31. 

  31.         generate();  
    32. 

  32.         fw.close();  
    33. 

  33.           
    34. 

  34.         // 使用产生的数据替换模板  
    35. 

  35.         File templateFile = new File("template.xlsx");  
    36. 

  36.         FileOutputStream out = new FileOutputStream(fileName);  
    37. 

  37.         substitute(templateFile, tmp, sheetRef.substring(1), out);  
    38. 

  38.         out.close();  
    39. 

  39.         //删除文件之前调用一下垃圾回收器，否则无法删除模板文件  
    40. 

  40.         System.gc();  
    41. 

  41.         // 删除临时模板文件  
    42. 

  42.         if (templateFile.isFile()&&templateFile.exists()){  
    43. 

  43.             templateFile.delete();  
    44. 

  44.         }  
    45. 

  45.     }  
    46. 

  46.   
    47. 

  47.     /** 
    48. 

  48.      * 类使用者应该使用此方法进行写操作 
    49. 

  49.      * @throws Exception 
    50. 

  50.      */  
    51. 

  51.     public abstract void generate() throws Exception;  
    52. 

  52.   
    53. 

  53.     public void beginSheet() throws IOException {  
    54. 

  54.         sw.beginSheet();  
    55. 

  55.     }  
    56. 

  56.   
    57. 

  57.     public void insertRow(int rowNum) throws IOException {  
    58. 

  58.         sw.insertRow(rowNum);  
    59. 

  59.     }  
    60. 

  60.   
    61. 

  61.     public void createCell(int columnIndex, String value) throws IOException {  
    62. 

  62.         sw.createCell(columnIndex, value, -1);  
    63. 

  63.     }  
    64. 

  64.   
    65. 

  65.     public void createCell(int columnIndex, double value) throws IOException {  
    66. 

  66.         sw.createCell(columnIndex, value, -1);  
    67. 

  67.     }  
    68. 

  68.   
    69. 

  69.     public void endRow() throws IOException {  
    70. 

  70.         sw.endRow();  
    71. 

  71.     }  
    72. 

  72.   
    73. 

  73.     public void endSheet() throws IOException {  
    74. 

  74.         sw.endSheet();  
    75. 

  75.     }  
    76. 

  76.   
    77. 

  77.     /** 
    78. 

  78.      * 
    79. 

  79.      * @param zipfile the template file 
    80. 

  80.      * @param tmpfile the XML file with the sheet data 
    81. 

  81.      * @param entry the name of the sheet entry to substitute, e.g. xl/worksheets/sheet1.xml 
    82. 

  82.      * @param out the stream to write the result to 
    83. 

  83.      */  
    84. 

  84.     private static void substitute(File zipfile, File tmpfile, String entry,  
    85. 

  85.             OutputStream out) throws IOException {  
    86. 

  86.         ZipFile zip = new ZipFile(zipfile);  
    87. 

  87.         ZipOutputStream zos = new ZipOutputStream(out);  
    88. 

  88.   
    89. 

  89.         @SuppressWarnings("unchecked")  
    90. 

  90.         Enumeration<ZipEntry> en = (Enumeration<ZipEntry>) zip.entries();  
    91. 

  91.         while (en.hasMoreElements()) {  
    92. 

  92.             ZipEntry ze = en.nextElement();  
    93. 

  93.             if (!ze.getName().equals(entry)) {  
    94. 

  94.                 zos.putNextEntry(new ZipEntry(ze.getName()));  
    95. 

  95.                 InputStream is = zip.getInputStream(ze);  
    96. 

  96.                 copyStream(is, zos);  
    97. 

  97.                 is.close();  
    98. 

  98.             }  
    99. 

  99.         }  
    100. 

  100.         zos.putNextEntry(new ZipEntry(entry));  
    101. 

  101.         InputStream is = new FileInputStream(tmpfile);  
    102. 

  102.         copyStream(is, zos);  
    103. 

  103.         is.close();  
    104. 

  104.         zos.close();  
    105. 

  105.     }  
    106. 

  106.   
    107. 

  107.     private static void copyStream(InputStream in, OutputStream out)  
    108. 

  108.             throws IOException {  
    109. 

  109.         byte[] chunk = new byte[1024];  
    110. 

  110.         int count;  
    111. 

  111.         while ((count = in.read(chunk)) >= 0) {  
    112. 

  112.             out.write(chunk, 0, count);  
    113. 

  113.         }  
    114. 

  114.     }  
    115. 

  115.   
    116. 

  116.     /** 
    117. 

  117.      * 在写入器中写入电子表格 
    118. 

  118.      *  
    119. 

  119.      */  
    120. 

  120.     public static class SpreadsheetWriter {  
    121. 

  121.         private final Writer _out;  
    122. 

  122.         private int _rownum;  
    123. 

  123.         private static String LINE_SEPARATOR = System.getProperty("line.separator");  
    124. 

  124.   
    125. 

  125.         public SpreadsheetWriter(Writer out) {  
    126. 

  126.             _out = out;  
    127. 

  127.         }  
    128. 

  128.   
    129. 

  129.         public void beginSheet() throws IOException {  
    130. 

  130.             _out.write("<?xml version=\"1.0\" encoding=\"GB2312\"?>"  
    131. 

  131.                             + "<worksheet xmlns=\"http://schemas.openxmlformats.org/spreadsheetml/2006/main\">");  
    132. 

  132.             _out.write("<sheetData>"+LINE_SEPARATOR);  
    133. 

  133.         }  
    134. 

  134.   
    135. 

  135.         public void endSheet() throws IOException {  
    136. 

  136.             _out.write("</sheetData>");  
    137. 

  137.             _out.write("</worksheet>");  
    138. 

  138.         }  
    139. 

  139.   
    140. 

  140.         /** 
    141. 

  141.          * 插入新行 
    142. 

  142.          * 
    143. 

  143.          * @param rownum 以0开始 
    144. 

  144.          */  
    145. 

  145.         public void insertRow(int rownum) throws IOException {  
    146. 

  146.             _out.write("<row r=\"" + (rownum + 1) + "\">"+LINE_SEPARATOR);  
    147. 

  147.             this._rownum = rownum;  
    148. 

  148.         }  
    149. 

  149.   
    150. 

  150.         /** 
    151. 

  151.          * 插入行结束标志 
    152. 

  152.          */  
    153. 

  153.         public void endRow() throws IOException {  
    154. 

  154.             _out.write("</row>"+LINE_SEPARATOR);  
    155. 

  155.         }  
    156. 

  156.   
    157. 

  157.         /** 
    158. 

  158.          * 插入新列 
    159. 

  159.          * @param columnIndex 
    160. 

  160.          * @param value 
    161. 

  161.          * @param styleIndex 
    162. 

  162.          * @throws IOException 
    163. 

  163.          */  
    164. 

  164.         public void createCell(int columnIndex, String value, int styleIndex)  
    165. 

  165.                 throws IOException {  
    166. 

  166.             String ref = new CellReference(_rownum, columnIndex)  
    167. 

  167.                     .formatAsString();  
    168. 

  168.             _out.write("<c r=\"" + ref + "\" t=\"inlineStr\"");  
    169. 

  169.             if (styleIndex != -1)  
    170. 

  170.                 _out.write(" s=\"" + styleIndex + "\"");  
    171. 

  171.             _out.write(">");  
    172. 

  172.             _out.write("<is><t>"+XMLEncoder.encode(value)+"</t></is>");  
    173. 

  173.             _out.write("</c>");  
    174. 

  174.         }  
    175. 

  175.   
    176. 

  176.         public void createCell(int columnIndex, String value)  
    177. 

  177.                 throws IOException {  
    178. 

  178.             createCell(columnIndex, value, -1);  
    179. 

  179.         }  
    180. 

  180.   
    181. 

  181.         public void createCell(int columnIndex, double value, int styleIndex)  
    182. 

  182.                 throws IOException {  
    183. 

  183.             String ref = new CellReference(_rownum, columnIndex)  
    184. 

  184.                     .formatAsString();  
    185. 

  185.             _out.write("<c r=\"" + ref + "\" t=\"n\"");  
    186. 

  186.             if (styleIndex != -1)  
    187. 

  187.                 _out.write(" s=\"" + styleIndex + "\"");  
    188. 

  188.             _out.write(">");  
    189. 

  189.             _out.write("<v>" + value + "</v>");  
    190. 

  190.             _out.write("</c>");  
    191. 

  191.         }  
    192. 

  192.   
    193. 

  193.         public void createCell(int columnIndex, double value)  
    194. 

  194.                 throws IOException {  
    195. 

  195.             createCell(columnIndex, value, -1);  
    196. 

  196.         }  
    197. 

  197.   
    198. 

  198.         public void createCell(int columnIndex, Calendar value, int styleIndex)  
    199. 

  199.                 throws IOException {  
    200. 

  200.             createCell(columnIndex, DateUtil.getExcelDate(value, false),  
    201. 

  201.                     styleIndex);  
    202. 

  202.         }  
    203. 

  203.     }  
    204. 

  204. }  
    205. 



 






[java] view plain copy









    

  1. public class Excel2007WriterImpl extends AbstractExcel2007Writer{  
    2. 

  2.   
    3. 

  3.       
    4. 

  4.     /** 
    5. 

  5.      * @param args 
    6. 

  6.      * @throws Exception 
    7. 

  7.      */  
    8. 

  8.     public static void main(String[] args) throws Exception {  
    9. 

  9.         // TODO Auto-generated method stub  
    10. 

  10.         System.out.println("............................");  
    11. 

  11.         long start = System.currentTimeMillis();  
    12. 

  12.         //构建excel2007写入器  
    13. 

  13.         AbstractExcel2007Writer excel07Writer = new Excel2007WriterImpl();  
    14. 

  14.         //调用处理方法  
    15. 

  15.         excel07Writer.process("F://test07.xlsx");  
    16. 

  16.         long end = System.currentTimeMillis();  
    17. 

  17.         System.out.println("....................."+(end-start)/1000);  
    18. 

  18.     }  
    19. 

  19.   
    20. 

  20.       
    21. 

  21.     /*  
    22. 

  22.      * 可根据需求重写此方法，对于单元格的小数或者日期格式，会出现精度问题或者日期格式转化问题，建议使用字符串插入方法 
    23. 

  23.      * @see com.excel.ver2.AbstractExcel2007Writer#generate() 
    24. 

  24.      */  
    25. 

  25.     @Override  
    26. 

  26.     public void generate()throws Exception {  
    27. 

  27.         //电子表格开始  
    28. 

  28.         beginSheet();  
    29. 

  29.         for (int rownum = 0; rownum < 100; rownum++) {  
    30. 

  30.             //插入新行  
    31. 

  31.             insertRow(rownum);  
    32. 

  32.             //建立新单元格,索引值从0开始,表示第一列  
    33. 

  33.             createCell(0, "中国<" + rownum + "!");  
    34. 

  34.             createCell(1, 34343.123456789);  
    35. 

  35.             createCell(2, "23.67%");  
    36. 

  36.             createCell(3, "12:12:23");  
    37. 

  37.             createCell(4, "2010-10-11 12:12:23");  
    38. 

  38.             createCell(5, "true");  
    39. 

  39.             createCell(6, "false");  
    40. 

  40.             
    41. 

  41.             //结束行  
    42. 

  42.             endRow();  
    43. 

  43.         }  
    44. 

  44.         //电子表格结束  
    45. 

  45.         endSheet();  
    46. 

  46.     }  
    47. 

  47.   
    48. 

  48. }  
    49. 













[java] view plain copy









    

  1. public class XMLEncoder {  
    2. 

  2.   
    3. 

  3.     private static final String[] xmlCode = new String[256];  
    4. 

  4.   
    5. 

  5.     static {  
    6. 

  6.         // Special characters  
    7. 

  7.         xmlCode[‘\‘‘] = "‘";  
    8. 

  8.         xmlCode[‘\"‘] = """; // double quote  
    9. 

  9.         xmlCode[‘&‘] = "&"; // ampersand  
    10. 

  10.         xmlCode[‘<‘] = "<"; // lower than  
    11. 

  11.         xmlCode[‘>‘] = ">"; // greater than  
    12. 

  12.     }  
    13. 

  13.   
    14. 

  14.     /** 
    15. 

  15.      * <p> 
    16. 

  16.      * Encode the given text into xml. 
    17. 

  17.      * </p> 
    18. 

  18.      *  
    19. 

  19.      * @param string the text to encode 
    20. 

  20.      * @return the encoded string 
    21. 

  21.      */  
    22. 

  22.     public static String encode(String string) {  
    23. 

  23.         if (string == null) return "";  
    24. 

  24.         int n = string.length();  
    25. 

  25.         char character;  
    26. 

  26.         String xmlchar;  
    27. 

  27.         StringBuffer buffer = new StringBuffer();  
    28. 

  28.         // loop over all the characters of the String.  
    29. 

  29.         for (int i = 0; i < n; i++) {  
    30. 

  30.             character = string.charAt(i);  
    31. 

  31.             // the xmlcode of these characters are added to a StringBuffer one by one  
    32. 

  32.             try {  
    33. 

  33.                 xmlchar = xmlCode[character];  
    34. 

  34.                 if (xmlchar == null) {  
    35. 

  35.                     buffer.append(character);  
    36. 

  36.                 } else {  
    37. 

  37.                     buffer.append(xmlCode[character]);  
    38. 

  38.                 }  
    39. 

  39.             } catch (ArrayIndexOutOfBoundsException aioobe) {  
    40. 

  40.                 buffer.append(character);  
    41. 

  41.             }  
    42. 

  42.         }  
    43. 

  43.         return buffer.toString();  
    44. 

  44.     }  
    45. 

  45.   
    46. 

  46. }  
    47. 


POI读写海量Excel
标签：block   color   tin   comm   精度   time   测试   font   att   
原文地址：http://www.cnblogs.com/yangmengdx3/p/7208484.html

                

                

                    

                        

                            

                                

                                    踩

                                

                                    (0)

                            

                            

                                

                                    赞

                                

                                    (0)

                            

                        

                        

                            

                                    
                                
                            

                        

                    

                    

                        举报
                    

                    
                    

                        

                            评论 一句话评论（0）
                        

                        

                            
                            

                                
                            

                        

                        

                            

                            

                                

                                

                                

                                    
                                

                            

                            

                                登录后才能评论！
                                
                            

                            

                        

                    

                

                
            

        

        

            
            





            
            


    

        

            分享档案

        

            更多>
        

    

    

        
                
                    2021年07月29日
                    (22)

            
                
                    2021年07月28日
                    (40)

            
                
                    2021年07月27日
                    (32)

            
                
                    2021年07月26日
                    (79)

            
                
                    2021年07月23日
                    (29)

            
                
                    2021年07月22日
                    (30)

            
                
                    2021年07月21日
                    (42)

            
                
                    2021年07月20日
                    (16)

            
                
                    2021年07月19日
                    (90)

            
                
                    2021年07月16日
                    (35)

            
    




            


    

        
周排行

        

            mamicode.com排行更多图片

        

            更多

    

    

        
    




            
        

        

        

    

    
    

    

        

            友情链接
        

        

            兰亭集智  
			国之画  
			百度统计   
			 站长统计  
			阿里云  
			chrome插件  
			新版天听网
        

    





    

        

            关于我们 - 联系我们 - 留言反馈
        

        

            © 2014 mamicode.com
            版权所有   联系我们:gaon5@hotmail.com
        

        

            迷上了代码！