Java Excel 2007 POI 解析 已经各种格式的空白单元格

最新推荐文章于 2022-05-06 04:40:54 发布
最新推荐文章于 2022-05-06 04:40:54 发布
阅读量304 收藏
点赞数
文章标签： java python
原文链接：https://my.oschina.net/wliming/blog/819348
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

/**
 * 
 */
package com.use.prefecture.employees.util.change.common;

import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import org.apache.poi.openxml4j.opc.OPCPackage;
import org.apache.poi.ss.usermodel.BuiltinFormats;
import org.apache.poi.ss.usermodel.DataFormatter;
import org.apache.poi.xssf.eventusermodel.XSSFReader;
import org.apache.poi.xssf.model.SharedStringsTable;
import org.apache.poi.xssf.model.StylesTable;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.apache.poi.xssf.usermodel.XSSFRichTextString;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;

/**
 *
 * 自定义解析处理器 
 * See org.xml.sax.helpers.DefaultHandler javadocs  
 * @author 王   利   明
 * 		2016-12-21   下午3:20:34
 * ECP  com.use.prefecture.employees.util.change.card  CardChangeXxlsAnalyze
 */
public class CommonChangeAnalyzeXxlsExcel{
	   
    private static StylesTable stylesTable;  
      
    /** 
     * 处理一个sheet 
     * @param filename 
     * @throws Exception 
     */  
    public void processOneSheet(String filename) throws Exception {  
          
        OPCPackage pkg = OPCPackage.open(filename);  
        XSSFReader r = new XSSFReader( pkg );  
        stylesTable = r.getStylesTable();   
        SharedStringsTable sst = r.getSharedStringsTable();  
  
        XMLReader parser = fetchSheetParser(sst);  
        SheetHandler handler = new SheetHandler(sst);  
    	parser.setContentHandler(handler); 
        // Seems to either be rId# or rSheet#  
        InputStream sheet2 = r.getSheet("rId1");  
        InputSource sheetSource = new InputSource(sheet2);  
        parser.parse(sheetSource);  
        sheet2.close();  
    }  
  
    /** 
     * 处理所有sheet 
     * @param filename 
     * @return 
     * @throws Exception 
     */  
    public Map<Integer, List<String>> processAllSheets(String filename) throws Exception {  
          
    	OPCPackage pkg = OPCPackage.open(filename);  
    	XSSFReader r = new XSSFReader( pkg );  
    	stylesTable = r.getStylesTable();   
    	SharedStringsTable sst = r.getSharedStringsTable();  

    	//XMLReader parser = fetchSheetParser(sst);  

    	XMLReader parser = XMLReaderFactory.createXMLReader("org.apache.xerces.parsers.SAXParser");  
    	SheetHandler handler = new SheetHandler(sst);  
    	parser.setContentHandler(handler); 

    	Iterator<InputStream> sheets = r.getSheetsData();  
    	while(sheets.hasNext()) {  
    		System.out.println("Processing new sheet:\n");  
    		InputStream sheet = sheets.next();  
    		InputSource sheetSource = new InputSource(sheet);  
    		parser.parse(sheetSource);  
    		sheet.close();  
    		System.out.println("");  
    	}  
        
    	return handler.getExcelMap();
    }  
  
    /** 
     * 获取解析器 
     * @param sst 
     * @return 
     * @throws SAXException 
     */  
    public XMLReader fetchSheetParser(SharedStringsTable sst) throws SAXException {  
        XMLReader parser =  
            XMLReaderFactory.createXMLReader(  
                    "org.apache.xerces.parsers.SAXParser"  
            );  
        ContentHandler handler = new SheetHandler(sst);  
        parser.setContentHandler(handler);  
        return parser;  
    }  
  
    
    private static class SheetHandler extends DefaultHandler {  
          
        private SharedStringsTable sst;  
        private String lastContents;  
        private boolean nextIsString;  
          
        private List<String> rowlist = new ArrayList<String>();   
        private int curRow = 0;   
        private int curCol = 0;  
          
        //定义前一个元素和当前元素的位置，用来计算其中空的单元格数量，如A6和A8等  
        private String preRef = null, ref = null;  
       
        private List<String> refNames=new ArrayList<>();
        
        //定义该文档一行最大的单元格数，用来补全一行最后可能缺失的单元格  
        private String maxRef = null;  
          
        private CellDataType nextDataType = CellDataType.SSTINDEX;   
        private final DataFormatter formatter = new DataFormatter();   
        private short formatIndex;   
        private String formatString;   
          
        //用一个enum表示单元格可能的数据类型  
        enum CellDataType{   
            BOOL, ERROR, FORMULA, INLINESTR, SSTINDEX, NUMBER, DATE, NULL   
        }  
          
        private SheetHandler(SharedStringsTable sst) {  
            this.sst = sst;  
        }  
        /** 
         * 解析一个element的开始时触发事件 
         */  
        public void startElement(String uri, String localName, String name,  
                Attributes attributes) throws SAXException {  
              
            // c => cell  
            if(name.equals("c")) {  
                //前一个单元格的位置  
                if(preRef == null){  
                    preRef = attributes.getValue("r");  
                }else{  
                    preRef = ref;  
                }  
                //当前单元格的位置  
                ref = attributes.getValue("r");  
                
                if(curCol>0 && curRow>0 && !refNames.contains("v")){
                	rowlist.add(curCol, "");curCol++;
                }
                refNames=new ArrayList<>();  
                
                this.setNextDataType(attributes);   
                  
                // Figure out if the value is an index in the SST  
                String cellType = attributes.getValue("t");  
                if(cellType != null && cellType.equals("s")) {  
                    nextIsString = true;  
                } else {  
                    nextIsString = false;  
                }  
                  
            }  
            // Clear contents cache  
            lastContents = "";  
        }  
          
        /** 
         * 根据element属性设置数据类型 
         * @param attributes 
         */  
        public void setNextDataType(Attributes attributes){   
  
            nextDataType = CellDataType.NUMBER;   
            formatIndex = -1;   
            formatString = null;   
            String cellType = attributes.getValue("t");   
            String cellStyleStr = attributes.getValue("s");   
            if ("b".equals(cellType)){   
                nextDataType = CellDataType.BOOL;  
            }else if ("e".equals(cellType)){   
                nextDataType = CellDataType.ERROR;   
            }else if ("inlineStr".equals(cellType)){   
                nextDataType = CellDataType.INLINESTR;   
            }else if ("s".equals(cellType)){   
                nextDataType = CellDataType.SSTINDEX;   
            }else if ("str".equals(cellType)){   
                nextDataType = CellDataType.FORMULA;   
            }  
            if (cellStyleStr != null){   
                int styleIndex = Integer.parseInt(cellStyleStr);   
                XSSFCellStyle style = stylesTable.getStyleAt(styleIndex);   
                formatIndex = style.getDataFormat();   
                formatString = style.getDataFormatString();   
                if ("m/d/yy" == formatString){   
                    nextDataType = CellDataType.DATE;   
                    //full format is "yyyy-MM-dd hh:mm:ss.SSS";  
                    formatString = "yyyy-MM-dd";  
                }   
                if (formatString == null){   
                    nextDataType = CellDataType.NULL;   
                    formatString = BuiltinFormats.getBuiltinFormat(formatIndex);   
                }   
            }   
        }  
          
        /** 
         * 解析一个element元素结束时触发事件 
         */  
        public void endElement(String uri, String localName, String name)  
                throws SAXException {  
            // Process the last contents as required.  
            // Do now, as characters() may be called more than once  
            if(nextIsString) {  
                int idx = Integer.parseInt(lastContents);  
                lastContents = new XSSFRichTextString(sst.getEntryAt(idx)).toString();  
                nextIsString = false;  
            }  
  
            // v => contents of a cell  
            // Output after we've seen the string contents  
            if(curRow>0){
            	refNames.add(name);
            }
            if (name.equals("v")) {   
                String value = this.getDataValue(lastContents.trim(), "");  
                if(rowlist.size()==0){
                	int len = countNullCell(ref, "A"+curRow+1);
                	for(int i=0;i<len+1;i++){  
                        rowlist.add(curCol, "");  
                        curCol++;  
                    }
                }
                //补全单元格之间的空单元格  
                if(!ref.equals(preRef)){  
                    int len = countNullCell(ref, preRef);  
                    for(int i=0;i<len;i++){  
                        rowlist.add(curCol, "");  
                        curCol++;  
                    }  
                }  
                rowlist.add(curCol, value);  
                curCol++;   
            }else {   
                //如果标签名称为 row，这说明已到行尾，调用 optRows() 方法   
                if (name.equals("row")) {  
                    //默认第一行为表头，以该行单元格数目为最大数目  
                    if(curRow == 0){  
                        maxRef = ref;  
                    }  
                    //补全一行尾部可能缺失的单元格  
                    if(maxRef != null){  
                        int len = countNullCell(maxRef, ref);  
                        for(int i=0;i<=len;i++){  
                            rowlist.add(curCol, "");  
                            curCol++;  
                        }  
                    }  
                    optRows(sheetIndex,curRow,rowlist);
                    //拼接一行的数据  
                    /*for(int i=0;i<rowlist.size();i++){  
                        if(rowlist.get(i).contains(",")){  
                            value += "\""+rowlist.get(i)+"\",";  
                        }else{  
                            value += rowlist.get(i)+",";  
                        }  
                    } */ 
                    //加换行符  
                    /*value += "\n";  
                    try {  
                        writer.write(value);  
                    } catch (IOException e) {  
                        e.printStackTrace();  
                    }*/  
                    curRow++;  
                    //一行的末尾重置一些数据  
                    rowlist.clear();   
                    curCol = 0;   
                    preRef = null;  
                    ref = null;  
                }   
            }   
        }  
        private int sheetIndex = -1;
        //private int totalCurCol=1;
        private int rowIndex=0;
        private Map<Integer, List<String>> excelMap=new TreeMap<Integer, List<String>>();
        
        public void optRows(int sheetIndex, int curRow, List<String> rowlist){
    		List<String> excelList=new ArrayList<>();
    		excelList.addAll(rowlist);
    		excelMap.put(rowIndex++, excelList);
    	}
        /*
    	 * @param 
    	 */
    	public Map<Integer, List<String>> getExcelMap() {
    		return excelMap;
    	}
        /** 
         * 根据数据类型获取数据 
         * @param value 
         * @param thisStr 
         * @return 
         */  
        public String getDataValue(String value, String thisStr)   
  
        {   
            switch (nextDataType)   
            {   
                //这几个的顺序不能随便交换，交换了很可能会导致数据错误   
                case BOOL:   
                char first = value.charAt(0);   
                thisStr = first == '0' ? "FALSE" : "TRUE";   
                break;   
                case ERROR:   
                thisStr = "\"ERROR:" + value.toString() + '"';   
                break;   
                case FORMULA:   
                thisStr = '"' + value.toString() + '"';   
                break;   
                case INLINESTR:   
                XSSFRichTextString rtsi = new XSSFRichTextString(value.toString());   
                thisStr = rtsi.toString();   
                rtsi = null;   
                break;   
                case SSTINDEX:   
                thisStr = value.toString();   
                break;   
                case NUMBER:   
                if (formatString != null){   
                    thisStr = formatter.formatRawCellContents(Double.parseDouble(value), formatIndex, formatString).trim();   
                }else{  
                    thisStr = value;   
                }   
                thisStr = thisStr.replace("_", "").trim();   
                break;   
                case DATE:   
                    try{  
                        thisStr = formatter.formatRawCellContents(Double.parseDouble(value), formatIndex, formatString);   
                    }catch(NumberFormatException ex){  
                        thisStr = value.toString();  
                    }  
                thisStr = thisStr.replace(" ", "");  
                break;   
                default:   
                thisStr = "";   
                break;   
            }   
            return thisStr;   
        }   
  
        /** 
         * 获取element的文本数据 
         */  
        public void characters(char[] ch, int start, int length)  
                throws SAXException {  
            lastContents += new String(ch, start, length);  
        }  
          
        /** 
         * 计算两个单元格之间的单元格数目(同一行) 
         * @param ref 
         * @param preRef 
         * @return 
         */  
        public int countNullCell(String ref, String preRef){  
            //excel2007最大行数是1048576，最大列数是16384，最后一列列名是XFD  
            String xfd = ref.replaceAll("\\d+", "");  
            String xfd_1 = preRef.replaceAll("\\d+", "");  
              
            xfd = fillChar(xfd, 3, '@', true);  
            xfd_1 = fillChar(xfd_1, 3, '@', true);  
              
            char[] letter = xfd.toCharArray();  
            char[] letter_1 = xfd_1.toCharArray();  
            int res = (letter[0]-letter_1[0])*26*26 + (letter[1]-letter_1[1])*26 + (letter[2]-letter_1[2]);  
            return res-1;  
        }  
        
        /** 
         * 字符串的填充 
         * @param str 
         * @param len 
         * @param let 
         * @param isPre 
         * @return 
         */  
        String fillChar(String str, int len, char let, boolean isPre){  
            int len_1 = str.length();  
            if(len_1 <len){  
                if(isPre){  
                    for(int i=0;i<(len-len_1);i++){  
                        str = let+str;  
                    }  
                }else{  
                    for(int i=0;i<(len-len_1);i++){  
                        str = str+let;  
                    }  
                }  
            }  
            return str;  
        }  
    }  
      
    static BufferedWriter writer = null;  
  
    public static void main(String[] args) throws Exception {  
    	CommonChangeAnalyzeXxlsExcel example = new CommonChangeAnalyzeXxlsExcel();  
        String str = "Book1";  
        String filename = "C:\\Users\\Administrator\\Desktop\\账号变更.xlsx";  
        System.out.println("-- 程序开始 --");  
        long time_1 = System.currentTimeMillis();  
        try{  
            writer = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\"+str+".csv")));  
            example.processAllSheets(filename);  
            Map<Integer, List<String>> map=example.processAllSheets(filename);
            System.err.println(map);
        }finally{  
            writer.close();  
        }  
        long time_2 = System.currentTimeMillis();  
        
        System.out.println("-- 程序结束 --");  
        System.out.println("-- 耗时 --"+(time_2 - time_1)+"ms");  
    }
}

 

转载于:https://my.oschina.net/wliming/blog/819348

weixin_34194317
关注
使用poi库解析excel时需要注意的一些点（处理不固定列信息、空单元格处理）
swyNB1的博客
12-05 1379
使用poi库解析excel碰到的一些问题：列不固定处理、处理不固定列信息、空单元格处理。
java读取excel忽略空格行,读取Excel文件2010的Apache POI忽略空白单元格
weixin_36410904的博客
02-25 1239
I am having an problem, while java application reading Excel file .xlsx extention, The application is working normally, but in the workbook has many sheets, 1, 2 sheets reading correctly , but when re...
Java poi基于事件驱动读取excel 2007海量数据 处理空单元格
03-24
该工具类是poi基于事件驱动去读取海量excel数据，解决内存溢出以及空单元格的问题。 该压缩包里面有两个文件，TestExcel.java主要是原始的处理方法，操作简单，适合小数据量的读取。 ExampleEventUserModelUtil.java是处理大数据量的。users40.xlsx是测试文件，里面有40万条数据。 jar包都在jar文件夹里面。
Java POI 读取带有空单元格或者缺失单元格的excel文件
Inner peace
11-27 3817
参考文档:[url]http://poi.apache.org/spreadsheet/quick-guide.html#Iterator[/url] 请注意MissingCellPolicy定义了如何处理缺失的单元格/空单元格: [code="java"] /** Missing cells are returned as null, Blank cells are retur...
Java Excel 97-2003 POI 解析 已经各种格式的空白单元格
weixin_33755847的博客
01-05 165
2019独角兽企业重金招聘Python工程师标准>>> ...
java poi excel读取为空的解决
蔚蓝海域的博客
01-05 5764
excel里面有内容，但是读取的时候却空了
POI以SAX方式解析Excel2007大文件(包含空单元格的处理)
l081307114的博客
05-26 2万+
1. Office2007与Office Open XML     在Office 2007之前，Office一直都是以二进制位的方式存储，但这种格式不易被其它软件拿来使用，在各界的压力下，MicroSoft于2005年发布了基于XML的ooxml开放文档标准。ooxml的xml schema强调减少load time，增快parsing speed，将child elements分开存储，而不
使用POI解析Excel
God_00的博客
07-07 5452
使用POI解析Excel 1、OpenXML标准 Word、Excel、PPT是Office办公套件中最常用的三个组件。早期的Office套件使用二进制格式，这里面包括以.doc、.xls、.ppt为后缀的文件；直到07这个划时代的版本将基于XML的压缩格式作为默认文件格式，也就是相应以.docx、.xlsx、.pptx为后缀的文件。 这个结合了XML与Zip压缩技术的新文件格式使用的是OpenXML标准。微软从2000年开始酝酿这项技术标准，到2006年申请成为ECMA-376，然后在Office2007
poi excel电子表格java解析工具
07-25
Excel文件主要有两种格式：.xls（BIFF格式，适用于Excel 97-2007）和.xlsx（OOXML格式，适用于Excel 2007及以上）。Apache POI支持这两种格式的处理。 四、读取Excel文件 1. 打开工作簿：使用`WorkbookFactory`的...
java对execl的操作
hyhanyu的博客
07-16 748
HSSFWorkbook 对应操作的execl的文件格式为xls,需要注 意的是在导出execl文件时，一个sheet最多导出65535 ,并且会消耗内存。 XSSFWorkbook 对应操作的execl的文件格式为xlsx，最多可以 导出 104 万行，不过当导出大量数据时，会消耗大量内存，并占用大量cpu。 SXSSFWorkbook是streaming版本的XSSFWorkbook,它...
java poi 空_Apache poi空白单元问题
weixin_42510924的博客
02-23 513
我的解释有点复杂，所以我道歉，但这是我在部署之前的最后一个错误 .我的程序迭代到excel文档的最后一行并重新计算，直到找到除“”或“null”之外的其他内容，因为我需要获取列的最后6个数据点，并且这样做会跳过不可见的垃圾数据并且空白细胞 .使用一些较旧的Excel工作表(在excel 2003中创建，或者可能更早)，我的程序可以找到最后一个单元格(我在运行时打印坐标，所以我知道它的发现是什么)但...
java excel空格怎么表示_java导入excel中的空格问题
weixin_34637138的博客
02-28 1536
最近项目需要，首先第一步就是要导入excel的数据 ， 待一切代码写好后却发现总有部分数据被忽略。仔细查了原因后才发现java中的trim()没有起作用，于是我看了下trim()的源码。 (图一) 首先知道空格所对应的ascii码为32 ，源码中显示如果为小于等于 "32"的则被认为是空格给去掉。但是经过测试发现excel中的空格(其实并不是空格，而是莫名的符号，我们这里姑且称之为空格)的asci...
poi空单元格格式_如何使用Apache POI读取空的，但是格式化的Excel单元格？
weixin_39637370的博客
02-09 297
我有一个使用Apache POI读取Excel单元格的方法，它工作正常 . 嗯......几乎没问题 .public static ArrayList readXLsXFile() throws FileNotFoundException, IOException {ArrayList outListaExcel = new ArrayList();FileInputStream fis;ptxf...
Java 去除excel表格内容中的空格
wangmj518的专栏
05-06 1951
从excel表格中读取数据 int i=1; Sheet sheet; Workbook book; Cell cell1,cell2; try { //in.xls为要读取的excel文件名 book= Workbook.getWorkbook(new File("E://in.xls")); //获得第一个工
POI事件模式读取Excel 2007（三） - 解析步骤
热门推荐
李平安
12-11 2万+
一. 解析步骤二. OPCPackage当使用POI事件模式解析Excel XLSX文档时： POI根据xlsx文档的路径path获取到文件File - file 使用java.util.zip.ZipFile打开file文件 - zip 从zip中获取到[Content_Types].xml 解析[Content_Types].xml，记录解析出Excel各个xml名称：ArrayList Exc
POI解析Excel【poi的坑——空行处理】
码农的世界
08-21 2万+
// 遍历行 Row row = null; int rowCnt = 0; while((row = sheet.getRow(rowCnt++)) != null){ List rowData = new ArrayList(); int colCnt = 0
Java使用poi读取excel数据（excel可能很大，先转换为csv再读取）
Eason的博客
07-26 2万+
————————————配置————————————   jdbc.properties中加入： excelUrl=/……xlsx文件目录路径/ (excelUrl + “xxxx.xlsx” 为完整路径)       导入poi-3.16下的6个jar包，poi-3.16/lib下的5个jar包，poi-3.16/ooxml-lib下的2个jar包
如何在导入数据前去掉excel 的空格和换行符
better Life
06-03 6161
1、先检查是否有空格      (Ctrl+F，输入空格，看看是否有，如果有的话，就用null值替换掉) 2、检查是否有换行符 （这个不好检查，只能通过替换，替换公式为：SUBSTITUTE(A1,CHAR(10),"") ） 以上两步多执行几次，这样才能将重叠的空格和换行符都去掉
Java POI 操作Excel：单元格与表格绘制
Apache POI 是一个流行的开源库，允许Java开发者读取、写入和操作Microsoft Office格式的文件，包括Excel。本篇内容将深入讲解如何使用POI进行Excel的基本操作，如单元格操作、画线、矩形、圆形以及表格的处理。 1....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值