java 使用 poi 解析excel

背景:

web應用經常需要上傳文件，有時候需要解析出excel中的數據，如果excel的格式沒有問題，那就可以直接解析數據入庫。

工具選擇:

目前jxl和poi可以解析excel，jxl很早就停止維護了，只支持excel-2003也就是xls格式的文件；

 

poi可支持xls和xlsx格式的文件，經過考察，poi的功能強大很多，所以選擇這個工具解析excel。文件上傳在之前的一個專題有所提及。

 

需要如下jar包，jar包見附件，也可在官網下載。

注意：

1. 不支持單元格合並的情況，默認表格格式規范，格式規范指：

從第一行第一列開始，第一行為表頭，后面全都是數據，每一個列代表一個字段。沒有中途斷掉的行或者列，允許單元格為空。

 

2. 代碼初步運用了重構中的方法抽取(extract method)和方法對象抽取(extract method object)技術，代碼行數前后沒有太大的變化，但是結構明顯要清楚一些。

只不過初步使用，有些抽取不是特別直觀，寫文件的兩個方法沒有使用重構技術，此外在單元格類型匹配，也還有深挖的空間，希望讀者根據自己的需要，自行定制。

關於重構技術和解析excel的api，請參考《重構改善既有代碼的設計》以及poi的源代碼

 

package com.test;
import org.apache.poi.hssf.usermodel.HSSFDataFormat;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import java.io.*;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.*;
/**
 * Created by tm on 2016/4/11.
 *
 * @author tm
 *         使用POI解析和生成excel，暫不支持單元格合並情況，默認是標准格式的excel
 *         實測同等的數據量（3張sheet超過2w條），xlsx的速度要遠慢於xls的解析速度。
 *         同等數據量：
 *         xls的解析，如果只取表頭，不超過500毫秒；如果取整個數據，時間不超過2000毫秒；
 *         而xlsx的解析，如果只取表頭，需要2000毫秒左右，如果取整個數據，則在3000毫秒以上。
 *         以上耗時不同系統不同硬件有不同結果，僅作為相對比較結果。
 * 這個類提供三個功能：
 *         1.獲得表格的表頭所有列,這個功能可以酌情去掉,因為獲得表格的所有數據也就獲得了所有列.
 *         2.獲得表格的所有數據
 *         3.傳入數據寫出來
 */
public class ExcelUtil {
    public static final String SUFFIX_XLS = "xls";
    public static final String SUFFIX_XLSX = "xlsx";
    public static final String NO_FILE_NULL = "NO FILE NULL";
    public static final String NO_FILE_EMPTY = "NO FILE EMPTY";
    /**
     * 獲得表格的列
     * @param fileName
     * @return
     * @throws RuntimeException
     */
    public static List<Map<String, Object>> getTableSheetCol(String fileName) throws RuntimeException{
        if(!valid(fileName))
            return null;
        else{
            if(validExcelFormat(fileName,SUFFIX_XLS)){
                //是excel2003？
                return getXlsSheetItem(fileName);
            }
            if(validExcelFormat(fileName, SUFFIX_XLSX)){
                //是excel2007以后
                return getXlsxSheetItem(fileName);
            }else{
                print("nonsupport file format");
                print("fileFormat : " + getFileNameSuffix(fileName));
                throw new RuntimeException("nonsupport file format, please check input fileName again");
            }
        }
    }
    /**
     * getXlsSheetItem ： 讀取xls格式文件的所有sheet表的所有列名集合。
     *
     * @param fileName 文件名
     *                  默認表格格式規范，列名全部為字符串。
     */
    private static List<Map<String, Object>> getXlsSheetItem(String fileName) {
        TableObject tableObject = new TableObject(fileName).invoke();
        HSSFWorkbook book = tableObject.getHssfBook();
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        for (int i = 0; i < tableObject.getSheet_number(); i++) {
            Sheet sheet = book.getSheetAt(i);
            if (ifSheetNullOrEmpty(sheet)) continue;
            Row row = sheet.getRow(0);
            if (ifRowNullOrEmpty(row)) continue;
            result.add(packageColsWithSheetName(book, i, row));
        }
        return result;
    }
    /**
     * getXlsxSheetItem ： 讀取xlsx格式文件的所有sheet表的所有列名集合。
     *
     * @param fileName 文件名
     *                  默認表格格式規范，列名全部為字符串。
     * 方法還可以進一步化簡，可參考 getExcelData 進一步整合。
     */
    private static List<Map<String, Object>> getXlsxSheetItem(String fileName) {
        TableObject tableObject = new TableObject(fileName).invoke();
        XSSFWorkbook book = tableObject.getXssfBook();
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        for (int i = 0; i < tableObject.getSheet_number(); i++) {
            Sheet sheet = book.getSheetAt(i);
            if (ifSheetNullOrEmpty(sheet)) continue;
            Row row = sheet.getRow(0);
            if (ifRowNullOrEmpty(row)) continue;
            result.add(packageColsWithSheetName(book, i, row));
        }
        return result;
    }
    private static Map<String, Object> packageColsWithSheetName(Workbook book, int i, Row row) {
        Map<String, Object> map = new HashMap<String, Object>();
        String sheet_name = book.getSheetName(i);
        List<String> cols = getCols(row);
        map.put("sheet_name", sheet_name);
        map.put("cols", cols);
        return map;
    }
    private static List<String> getCols(Row row) {
        List<String> cols = new ArrayList<String>();
        System.out.println(row.getLastCellNum());
        for (int j = 0; j < row.getLastCellNum(); j++) {
            Object obj = row.getCell(j);
            cols.add(obj == null ? "" : obj.toString());
        }
        return cols;
    }
    private static boolean ifRowNullOrEmpty(Row row) {
        if (row == null || row.getLastCellNum() == 0 || row.getCell(0) == null) {
            return true;
        }
        return false;
    }
    private static boolean ifSheetNullOrEmpty(Sheet sheet) {
        if (sheet == null || sheet.getLastRowNum() == 0) {
            return true;
        }
        return false;
    }
    /**
     * 獲取表格的全部數據
     * @param fileName 文件名
     * @return
     * @throws RuntimeException
     */
    public static Map<String, List<Map<String, Object>>> getTableSheetData(String fileName) throws RuntimeException{
        if(!valid(fileName)) {
            print("文件名校驗失敗");
            return null;
        }
        else{
            return getExcelData(fileName);
        }
    }
    /**
     * 根據文件后綴格式，確定調用哪種Workbook，此處運用了多態，具體的解析操作都用的是接口。
     * @param fileName
     * @return
     */
    private static Map<String, List<Map<String, Object>>> getExcelData(String fileName) {
        TableObject tableObject = new TableObject(fileName).invoke();
        Workbook book = null;
        if(validExcelFormat(fileName,SUFFIX_XLS)){
            //是excel2003？
            book = tableObject.getHssfBook();
        }
        else if(validExcelFormat(fileName, SUFFIX_XLSX)){
            //是excel2007以后
            book = tableObject.getXssfBook();
        }else{
            print("nonsupport file format");
            throw new RuntimeException("nonsupport file format, please check input fileName again");
        }
        Map<String, List<Map<String, Object>>> result = new HashMap<String, List<Map<String, Object>>>();
        for (int i = 0; i < tableObject.getSheet_number(); i++) {
            List<Map<String, Object>> sheet_data = new ArrayList<Map<String, Object>>();
            Sheet sheet = book.getSheetAt(i);
            if (ifSheetNullOrEmpty(sheet)) continue;
            String sheet_name = book.getSheetName(i);
            System.out.println(sheet.getLastRowNum());
            for (int j = 1; j <= sheet.getLastRowNum(); j++) {
                Row row = sheet.getRow(j);
                if (ifRowNullOrEmpty(row)) continue;
                Map<String, Object> record = new HashMap<String, Object>();
                Row first = sheet.getRow(0);
                getRowData(row, record, first);
                sheet_data.add(record);
            }
            result.put(sheet_name, sheet_data);
        }
        return result;
    }
    
    /**
     * 此處有個點要注意,getLastCellNum,下標是從1開始,有多少列,這里就是這個值.而getLastRowNum,下標是從0開始,也就是21行的表格,這里獲得的值是20.用戶可自行驗證.
     * @param row 該行記錄
     * @param record 返回值
     * @param first 表頭
     */
    private static void getRowData(Row row, Map<String, Object> record, Row first) {
        for (int k = 0; k < row.getLastCellNum(); k++) {
            String value;
            if (row.getCell(k) == null) {
                value = "";
            } else {
                value = parseDate(row.getCell(k));
                if (value.endsWith("00:00:00")) {
                    value = value.substring(0, value.lastIndexOf("00:00:00"));
                }
            }
            record.put(first.getCell(k).toString(), value);
        }
    }
    /**
     * 判斷單元格格式，轉化日期格式,日期在poi里保存的是數字,所以這里要轉化一下.
     * @param cell 單元格
     * @return
     */
    private static String parseDate(Cell cell) {
        String result = "";
        switch (cell.getCellType()) {
            case Cell.CELL_TYPE_NUMERIC:// 數字類型
                if (DateUtil.isCellDateFormatted(cell)) {// 處理日期格式、時間格式
                    SimpleDateFormat sdf = null;
                    if (cell.getCellStyle().getDataFormat() == HSSFDataFormat
                            .getBuiltinFormat("yyyy/MM/dd")) {
                        sdf = new SimpleDateFormat("yyyy/MM/dd");
                    } else {// 日期
                        sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
                    }
                    Date date = cell.getDateCellValue();
                    result = sdf.format(date);
                } else if (cell.getCellStyle().getDataFormat() == 58) {
                    // 處理自定義日期格式：m月d日(通過判斷單元格的格式id解決，id的值是58)
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                    double value = cell.getNumericCellValue();
                    Date date = org.apache.poi.ss.usermodel.DateUtil
                            .getJavaDate(value);
                    result = sdf.format(date);
                } else {
                    double value = cell.getNumericCellValue();
                    CellStyle style = cell.getCellStyle();
                    DecimalFormat format = new DecimalFormat();
                    String temp = style.getDataFormatString();
                    // 單元格設置成常規
                    if (temp.equals("General")) {
                        format.applyPattern("#");
                    }
                    result = format.format(value);
                }
                break;
            case Cell.CELL_TYPE_STRING:// String類型
                result = cell.getRichStringCellValue().toString();
                break;
            case Cell.CELL_TYPE_BLANK:
                result = "";
                break;
            default:
                result = "";
                break;
        }
        return result;
    }
    /**
     * ifXls：判斷是否為 xls 文件
     *
     * @param fileName 包含后綴的文件名
     */
    private static boolean validExcelFormat(String fileName,String type) {
        if(getOS().contains("win")){
            return valid(fileName) && getFileNameSuffix(fileName).equalsIgnoreCase(type);
        }else if(getOS().contains("linux")){
            return valid(fileName) && getFileNameSuffix(fileName).equals(type);
        }else{
            print("System OS is not windows or linux");
            throw new RuntimeException("System OS is not windows or linux , if you use this class in another sys,please implement yourself");
        }
    }
    private static String getOS() { return System.getProperty("os.name").toLowerCase(); }
    private static void print(String msg) {
        System.out.println(msg);
    }
    private static String getFileNameSuffix(String fileName) {
        return fileName.substring(fileName.lastIndexOf(".") + 1, fileName.length());
    }
    /**
     * valid :判斷文件是否存在
     *
     * @param fileName fileName 文件名。
     *                 區分為文件名為null，或者為空。
     */
    private static boolean valid(String fileName) {
        return !ifNull(fileName) && !ifEmpty(fileName);
    }
    private static boolean ifEmpty(String fileName) {
        if (fileName.equals("")) {
            print(NO_FILE_EMPTY);
            return true;
        }
        return false;
    }
    private static boolean ifNull(String fileName) {
        if (fileName == null) {
            print(NO_FILE_NULL);
            return true;
        }
        return false;
    }
    /**
     * 將excel文件寫出成txt格式
     * 此處沒有指定輸出格式
     * @param filePath 輸入文件路徑
     * @param destFilePath 輸出文件路徑
     * @throws Exception
     */
    public static void writeExcel2Txt(String filePath,String destFilePath) throws Exception {
        BufferedWriter bufferedWriter = null;
        try {
            FileWriter fw = new FileWriter(destFilePath);
            bufferedWriter = new BufferedWriter(fw);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }
        Map<String, List<Map<String, Object>>> data = getTableSheetData(filePath);
        System.out.println(data.toString());
        if(data==null){
            throw new Exception("解析數據失敗");
        }
        for (int i = 0; i < data.size(); i++) {
            try {
                bufferedWriter.write(DataTransformUtil.mapGetKeyList(data).get(i));
                System.out.println(DataTransformUtil.mapGetKeyList(data).get(i));
                bufferedWriter.newLine();
                bufferedWriter.write("===========================================================");
                bufferedWriter.newLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            System.out.println("==========================================");
            List<Map<String, Object>> sheet = data.get(DataTransformUtil.mapGetKeyList(data).get(i));
            for (Map map : sheet) {
                System.out.println(map.toString());
                bufferedWriter.write(map.toString());
                bufferedWriter.newLine();
            }
            System.out.println();
            bufferedWriter.newLine();
        }
        bufferedWriter.flush();
        bufferedWriter.close();
    }
    /***
     * writeXlsxFile：將指定數據集生成為excel文件。
     *
     * @param data 一個包含record的List集合
     * @param name 文件名【帶后綴】
     * @param path 路徑名
     *             只是簡單輸出，尚未設置樣式，單元格格式也未深究。
     */
    public static String writeXlsxFile(List<Map<String, Object>> data, String path, String name) {
        // 創建Excel的工作書冊 Workbook,對應到一個excel文檔
        Workbook book = null;
        if(validExcelFormat(name,SUFFIX_XLS)){
            book = new HSSFWorkbook();
        }else if(validExcelFormat(name,SUFFIX_XLSX)){
            book = new XSSFWorkbook();
        }else {
            print("nonsupport file format");
            throw new RuntimeException("nonsupport file format, please check input fileName again");
        }
        // 創建Excel的工作sheet,對應到一個excel文檔的tab
        Sheet sheet = book.createSheet("sheet1");
        sheet.setColumnWidth(0, 4000);
        sheet.setColumnWidth(1, 3500);
        // 創建Excel的sheet的一行
        int c = data.get(0).size();
        List cols = DataTransformUtil.mapGetKeyList(data.get(0));
        Row head = sheet.createRow(0);
        for (int j = 0; j < cols.size(); j++) {
            Cell cell = head.createCell(j, 1);
            cell.setCellValue(cols.get(j).toString());
        }
        for (int i = 0; i < data.size(); i++) {
            Row row = sheet.createRow(i + 1);
            for (int j = 0; j < c; j++) {
                Cell cell = row.createCell(j, 1);
                cell.setCellValue(data.get(i).get(cols.get(j).toString()).toString());
            }
        }
        FileOutputStream os = null;
        try {
            os = new FileOutputStream(new File(new File(path), name));
            book.write(os);
            os.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return name ;
    }
    public static void main(String[] args) throws Exception {
//        String str="[{'name':'zhang3','age':33,'gender':'f'}," +
//                "{'name':'li4','age':44,'gender':'m'}," +
//                "{'name':'wang5','age':55,'gender':'m'}," +
//                "{'name':'wang5','age':55,'gender':'m'}," +
//                "{'name':'wang5','age':55,'gender':'m'}]";
//        List<Map<String,Object>> list=DataTransformUtil.nestJsonArrayString2List(str);
//        System.out.println(list.toString());
//        writeXlsxFile(list,"F:\\","test");
        long start = System.currentTimeMillis();
        System.out.println("start ：" + System.currentTimeMillis());
       // writeExcel2Txt("F:\\152657884.xls","F:\\123.txt");
        //System.out.println(getTableSheetCol("F:\\需要本地開發功能列表.xlsx"));
        System.out.println(getTableSheetData("F:\\需要本地開發功能列表.xlsx"));
    }
    /**
     * extract method object
     */
    private static class TableObject {
        private String fileName;
        private XSSFWorkbook xssfBook;
        private HSSFWorkbook hssfBook;
        private int sheet_number;
        public TableObject(String fileName) {
            this.fileName = fileName;
        }
        public XSSFWorkbook getXssfBook() {
            return xssfBook;
        }
        public HSSFWorkbook getHssfBook() {
            return hssfBook;
        }
        public int getSheet_number() {
            return sheet_number;
        }
        public TableObject invoke() {
            xssfBook = null;
            hssfBook = null;
            sheet_number = 0;
            try {
                FileInputStream is = new FileInputStream(new File(fileName));
                if(validExcelFormat(fileName,SUFFIX_XLS)){
                    hssfBook = new HSSFWorkbook(is);
                    sheet_number = hssfBook.getNumberOfSheets();
                }else if(validExcelFormat(fileName,SUFFIX_XLSX)){
                    xssfBook = new XSSFWorkbook(is);
                    sheet_number = xssfBook.getNumberOfSheets();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            return this;
        }
    }
}

發現有個WorkBookFactory的api方法,可以直接拿到對應的HSSFWorkbook或XSSFWorkbook

所以說,研究清楚api才是正道啊……

大牛博客傳送門：http://blog.csdn.net/lovesomnus/article/details/23843549