java 讀取Excel數據（POI）

1、添加依賴

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-ooxml</artifactId>
    <version>3.13</version>
</dependency>

<dependency>
    <groupId>org.apache.poi</groupId>
    <artifactId>poi-scratchpad</artifactId>
    <version>3.13</version>
</dependency>

2、支持只讀一個sheet的工具類

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * POI解析Excel---只讀一個sheet
 * 注意：1、若單元格爲空時，讀出爲""空字符串；列數爲按最後一列計算；
 * 2、如果在最後一列前單元格合併數據個數還是按合併前列數算，但是合併後單元格只有左上單元格有數據；
 * 3、如果是最後一列合併單元格，則算最前面一列 ，後面列不計算 在其中，也沒數據（不是""空串）
 */
public class ExcelReader {

    /**
     * 根據fileType不同讀取excel文件
     *
     * @param path
     * @param path
     * @throws IOException
     */
    public static List<List<String>> readExcel(String path) {
        String fileType = path.substring(path.lastIndexOf(".") + 1);
        // return a list contains many list
        List<List<String>> lists = new ArrayList<List<String>>();
        //讀取excel文件
        InputStream is = null;
        try {
            is = new FileInputStream(path);
            //獲取工作薄
            Workbook wb = null;
            if (fileType.equals("xls")) {
                wb = new HSSFWorkbook(is);
            } else if (fileType.equals("xlsx")) {
                wb = new XSSFWorkbook(is);
            } else {
                return null;
            }

            //讀取第一個工作頁sheet
            Sheet sheet = wb.getSheetAt(0);
            //第一行爲標題
            for (Row row : sheet) {
                ArrayList<String> list = new ArrayList<String>();
                int flag = 0;
                System.out.println(">>>>>>>>>>>"+row.getLastCellNum());
                for (int i = 0; i < row.getLastCellNum(); i++) {
                    Cell cell = row.getCell(i);
                    //根據不同類型轉化成字符串
                    //如果單元格是空（列）的跳過-----------合併的單元格值優先屬於左上單元格
                    if(cell == null){
                        list.add("");
                    }else if(cell.getCellType() ==3){
                        list.add("");
                    }else if(cell.getCellType() ==0){
                        list.add(handleNumber(String.valueOf(cell.getNumericCellValue())));
                        flag = 1;
                    }else if(cell.getCellType() ==1){
                        cell.setCellType(Cell.CELL_TYPE_STRING);
                        list.add(cell.getStringCellValue());
                        flag = 1;
                    }else {
                        list.add("");
                    }
                }
                //如果整行都沒有值，跳過整行
                if(list.size() != 0 && flag == 1){
                    lists.add(list);
                }

            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return lists;
    }

    /**
     * <b> 去掉數字字符串小數點後面無效的領，或者去掉小數點
     * </b><br><br><i>Description</i> :
     * @param number String
     * @return java.lang.String
     * <br><br>Date: 2019/11/14 11:17     <br>Author : dxl
     */
    public static String handleNumber(String number){

        if(number.contains(".") && number.substring(number.indexOf(".")+1,number.length()).length() == 16){
            if(number.substring(number.length()-1,number.length()).equals("1")){
                number = number.substring(0,number.length()-1);
            }else if(number.substring(number.length()-1,number.length()).equals("9")){
                Double tem = Double.valueOf(number) + 0.0000000000000002;
                number = tem.toString();
            }
        }
        if(!number.contains(".")){
            return number;
        }else if(number.lastIndexOf(".") == number.length()-1){
            number = number.substring(0,number.length()-1);
            return number;
        }else if(number.substring(number.length()-1,number.length()).equals("0")){
            number = number.substring(0,number.length()-1);
            number = handleNumber(number);
        }else {
            return number;
        }
        return number;
    }

    /**
     * 創建Excel.xls
     * @param lists 需要寫入xls的數據
     * @param titles 列標題
     * @param name 文件名
     * @return
     * @throws IOException
     */
    public static Workbook creatExcel(List<List<String>> lists, String[] titles, String name) throws IOException {
        System.out.println(lists);
        //創建新的工作薄
        Workbook wb = new HSSFWorkbook();
        // 創建第一個sheet（頁），並命名
        Sheet sheet = wb.createSheet(name);
        // 手動設置列寬。第一個參數表示要爲第幾列設；，第二個參數表示列的寬度，n爲列高的像素數。
        for(int i=0;i<titles.length;i++){
            sheet.setColumnWidth((short) i, (short) (35.7 * 150));
        }

        // 創建第一行
        Row row = sheet.createRow((short) 0);

        // 創建兩種單元格格式
        CellStyle cs = wb.createCellStyle();
        CellStyle cs2 = wb.createCellStyle();

        // 創建兩種字體
        Font f = wb.createFont();
        Font f2 = wb.createFont();

        // 創建第一種字體樣式（用於列名）
        f.setFontHeightInPoints((short) 10);
        f.setColor(IndexedColors.BLACK.getIndex());
        f.setBoldweight(Font.BOLDWEIGHT_BOLD);

        // 創建第二種字體樣式（用於值）
        f2.setFontHeightInPoints((short) 10);
        f2.setColor(IndexedColors.BLACK.getIndex());

        // 設置第一種單元格的樣式（用於列名）
        cs.setFont(f);
        cs.setBorderLeft(CellStyle.BORDER_THIN);
        cs.setBorderRight(CellStyle.BORDER_THIN);
        cs.setBorderTop(CellStyle.BORDER_THIN);
        cs.setBorderBottom(CellStyle.BORDER_THIN);
        cs.setAlignment(CellStyle.ALIGN_CENTER);

        // 設置第二種單元格的樣式（用於值）
        cs2.setFont(f2);
        cs2.setBorderLeft(CellStyle.BORDER_THIN);
        cs2.setBorderRight(CellStyle.BORDER_THIN);
        cs2.setBorderTop(CellStyle.BORDER_THIN);
        cs2.setBorderBottom(CellStyle.BORDER_THIN);
        cs2.setAlignment(CellStyle.ALIGN_CENTER);
        //設置列名
        for(int i=0;i<titles.length;i++){
            Cell cell = row.createCell(i);
            cell.setCellValue(titles[i]);
            cell.setCellStyle(cs);
        }
        if(lists == null || lists.size() == 0){
            return wb;
        }
        //設置每行每列的值
        for (short i = 1; i <= lists.size(); i++) {
            // Row 行,Cell 方格 , Row 和 Cell 都是從0開始計數的
            // 創建一行，在頁sheet上
            Row row1 = sheet.createRow((short)i);
            for(short j=0;j<titles.length;j++){
                // 在row行上創建一個方格
                Cell cell = row1.createCell(j);
                cell.setCellValue(lists.get(i-1).get(j));
                cell.setCellStyle(cs2);
            }
        }
        return wb;
    }

    public static void main(String[] args) {
        double ii = (double)10/(double)3;
        System.out.println(">>>>ii>>>>"+ii);
        String path = "D:/111.xls";
        List<List<String>> lists = readExcel(path);

        for (List<String> list : lists) {
            System.out.println(">>"+list);
            System.out.println("--------------------------");
            for (String strs : list) {
                System.out.println(strs);
            }
        }
    }
}

3、支持多個sheet數據讀取工具類

import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.*;
import java.text.DecimalFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

/**
 * 讀取Excel數據工具類----可以讀取多個sheet
 *  注意：1、若單元格爲空時，讀出爲""空字符串；列數爲按最後一列計算；
 * 2、如果在最後一列前單元格合併數據個數還是按合併前列數算，但是合併後單元格只有左上單元格有數據；
 * 3、如果是最後一列合併單元格，則算最前面一列 ，後面列不計算 在其中，也沒數據（不是""空串）
 * @time 2017-06-03
 */
public class ExcelReaderPlus {
    private static HSSFWorkbook wb;
    private static HSSFSheet sheet;
    private static HSSFRow row;
    private static XSSFWorkbook wbx;
    private static XSSFSheet sheetx;
    private static XSSFRow rowx;

    /**
     * 獲取多個sheetExcel表格數據
     * 注意：1、若單元格爲空時，讀出爲""空字符串；列數爲按最後一列計算；
     * 2、如果在最後一列前單元格合併還是數據個數還是按合併前列數算，但是合併後單元格只有左上單元格有數據；
     * 3、如果是最後一列合併單元格，則算最前面一列 ，後面列不計算 在其中，也沒數據（不是""空串）
     * @param filePath Excel路徑
     * @return
     */
    public ExcelData readExcel(String filePath) {
        InputStream is = null;
        File file = new File(filePath);
        try {
            is = new FileInputStream(file);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }

        ExcelData excelData = new ExcelData();
        try {
            if(filePath.substring(filePath.length()-5,filePath.length()).equals(".xlsx")){
                wbx = new XSSFWorkbook(is);
               return readExcelx(wbx,file.getName());
            }
            wb = new HSSFWorkbook(is);
        } catch (IOException e) {
            e.printStackTrace();
        }
        Integer sheetNum = wb.getNumberOfSheets();
        excelData.setSheetSum(sheetNum);
        excelData.setFileName(file.getName());

        //循環獲取所有sheet數據
        List<ExcelSheetData> sheetDatas = new ArrayList<>();
        for (int i = 0; i < sheetNum; i++) {
            ExcelSheetData sheetData = new ExcelSheetData();
            sheet = wb.getSheetAt(i);
            sheetData.setLineSum(sheet.getPhysicalNumberOfRows());
            sheetData.setSheetName(sheet.getSheetName());

            List<ExcelLineData> lineDatas = readExcelContentBySheet(sheet);
            sheetData.setLineData(lineDatas);
            sheetDatas.add(sheetData);
        }
        excelData.setSheetData(sheetDatas);
        return excelData;
    }

    private ExcelData readExcelx(XSSFWorkbook wbx,String fileName) {

        ExcelData excelData = new ExcelData();
        Integer sheetNum = wbx.getNumberOfSheets();
        excelData.setSheetSum(sheetNum);
        excelData.setFileName(fileName);

        //循環獲取所有sheet數據
        List<ExcelSheetData> sheetDatas = new ArrayList<>();
        for (int i = 0; i < sheetNum; i++) {
            ExcelSheetData sheetData = new ExcelSheetData();
            sheetx = wbx.getSheetAt(i);
            sheetData.setSheetName(sheetx.getSheetName());
            sheetData.setLineSum(sheetx.getPhysicalNumberOfRows());
            List<ExcelLineData> lineDatas = readExcelContentBySheetx(sheetx);
            sheetData.setLineData(lineDatas);
            sheetDatas.add(sheetData);
        }
        excelData.setSheetData(sheetDatas);
        return excelData;
    }



    private List<ExcelLineData> readExcelContentBySheet(HSSFSheet sheet) {
        List<ExcelLineData> lineDatas = new ArrayList<>();
        // 得到總行數
        int rowNum = sheet.getLastRowNum();
        for (int i = 0; i <= rowNum; i++) {
            int j = 0;
            row = sheet.getRow(i);
            if (Objects.isNull(row)) {
                continue;
            }

            int colNum = row.getLastCellNum();
            ExcelLineData lineData = new ExcelLineData();
            List<String> colData = new ArrayList<>();
            lineData.setColSum(colNum);
            while (j < colNum) {
                String value = getCellValue(row.getCell(j)).trim();
                colData.add(value);
                j++;
            }
            lineData.setColData(colData);
            lineDatas.add(lineData);
        }

        return lineDatas;
    }
    private List<ExcelLineData> readExcelContentBySheetx(XSSFSheet sheetx) {
        List<ExcelLineData> lineDatas = new ArrayList<>();
        // 得到總行數
        int rowNum = sheetx.getLastRowNum();
        for (int i = 0; i <= rowNum; i++) {
            int j = 0;
            rowx = sheetx.getRow(i);
            if (Objects.isNull(rowx)) {
                continue;
            }

            int colNum = rowx.getLastCellNum();
            ExcelLineData lineData = new ExcelLineData();
            List<String> colData = new ArrayList<>();
            lineData.setColSum(colNum);
            while (j < colNum) {
                String value = getCellValuex(rowx.getCell(j)).trim();
                colData.add(value);
                j++;
            }
            lineData.setColData(colData);
            lineDatas.add(lineData);
        }

        return lineDatas;
    }

    /**
     * 獲取單元格數據
     *
     * @param cell Excel單元格
     * @return String 單元格數據內容
     */
    private String getCellValue(HSSFCell cell) {
        if (Objects.isNull(cell)) {
            return "";
        }

        String value = "";
        switch (cell.getCellType()) {
            case HSSFCell.CELL_TYPE_NUMERIC: // 數字
                //如果爲時間格式的內容
                if (HSSFDateUtil.isCellDateFormatted(cell)) {
                    //注：format格式 yyyy-MM-dd hh:mm:ss 中小時爲12小時制，若要24小時制，則把小h變爲H即可，yyyy-MM-dd HH:mm:ss
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                    value = sdf.format(HSSFDateUtil.getJavaDate(cell.getNumericCellValue())).toString();
                    break;
                } else {
                    value = new DecimalFormat("0").format(cell.getNumericCellValue());
                }
                break;
            case HSSFCell.CELL_TYPE_STRING: // 字符串
                value = cell.getStringCellValue();
                break;
            case HSSFCell.CELL_TYPE_BOOLEAN: // Boolean
                value = cell.getBooleanCellValue() + "";
                break;
            case HSSFCell.CELL_TYPE_FORMULA: // 公式
                value = cell.getCellFormula() + "";
                break;
            case HSSFCell.CELL_TYPE_BLANK: // 空值
                value = "";
                break;
            case HSSFCell.CELL_TYPE_ERROR: // 故障
                value = "非法字符";
                break;
            default:
                value = "未知類型";
                break;
        }
        return value;
    }

    private String getCellValuex(XSSFCell cellx) {
        if (Objects.isNull(cellx)) {
            return "";
        }

        String value = "";
        switch (cellx.getCellType()) {
            case XSSFCell.CELL_TYPE_NUMERIC: // 數字
                //如果爲時間格式的內容
                if (HSSFDateUtil.isCellDateFormatted(cellx)) {
                    //注：format格式 yyyy-MM-dd hh:mm:ss 中小時爲12小時制，若要24小時制，則把小h變爲H即可，yyyy-MM-dd HH:mm:ss
                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
                    value = sdf.format(HSSFDateUtil.getJavaDate(cellx.getNumericCellValue())).toString();
                    break;
                } else {
                    value = new DecimalFormat("0").format(cellx.getNumericCellValue());
                }
                break;
            case XSSFCell.CELL_TYPE_STRING: // 字符串
                value = cellx.getStringCellValue();
                break;
            case XSSFCell.CELL_TYPE_BOOLEAN: // Boolean
                value = cellx.getBooleanCellValue() + "";
                break;
            case XSSFCell.CELL_TYPE_FORMULA: // 公式
                value = cellx.getCellFormula() + "";
                break;
            case XSSFCell.CELL_TYPE_BLANK: // 空值
                value = "";
                break;
            case XSSFCell.CELL_TYPE_ERROR: // 故障
                value = "非法字符";
                break;
            default:
                value = "未知類型";
                break;
        }
        return value;
    }


    public static void main(String[] args) {
        ExcelReaderPlus excelReader = new ExcelReaderPlus();
        ExcelData excelData = excelReader.readExcel("D:\\111.xls");
        System.out.println(excelData.toString());
        for(ExcelSheetData excelSheetData:excelData.getSheetData()){
            System.out.println("**********************"+excelSheetData.getSheetName());
            for(ExcelLineData excelLineData :excelSheetData.getLineData()){
                System.out.println("----------------"+excelLineData.getColSum());
                System.out.println(">>>>>>>"+excelLineData.getColData());
            }
        }

    }


    public class ExcelData {
        private int sheetSum;
        private String fileName;
        private List<ExcelSheetData> sheetData;

        public int getSheetSum() {
            return sheetSum;
        }

        public void setSheetSum(int sheetSum) {
            this.sheetSum = sheetSum;
        }

        public String getFileName() {
            return fileName;
        }

        public void setFileName(String fileName) {
            this.fileName = fileName;
        }

        public List<ExcelSheetData> getSheetData() {
            return sheetData;
        }

        public void setSheetData(List<ExcelSheetData> sheetData) {
            this.sheetData = sheetData;
        }
    }

    public class ExcelSheetData {
        /**
         * 工作簿名稱
         */
        private String sheetName;
        /**
         * 表格總行數
         */
        private int lineSum;
        /**
         * 行數據集合
         */
        private List<ExcelLineData> lineData;

        public String getSheetName() {
            return sheetName;
        }

        public void setSheetName(String sheetName) {
            this.sheetName = sheetName;
        }

        public int getLineSum() {
            return lineSum;
        }

        public void setLineSum(int lineSum) {
            this.lineSum = lineSum;
        }

        public List<ExcelLineData> getLineData() {
            return lineData;
        }

        public void setLineData(List<ExcelLineData> lineData) {
            this.lineData = lineData;
        }
    }
    public class ExcelLineData {
        /**
         * 行編號
         */
        private int lineNumber;
        /**
         * 行總列數
         */
        private int colSum;
        /**
         * 列數據集合
         */
        private List<String> colData;

        public int getLineNumber() {
            return lineNumber;
        }

        public void setLineNumber(int lineNumber) {
            this.lineNumber = lineNumber;
        }

        public int getColSum() {
            return colSum;
        }

        public void setColSum(int colSum) {
            this.colSum = colSum;
        }

        public List<String> getColData() {
            return colData;
        }

        public void setColData(List<String> colData) {
            this.colData = colData;
        }
    }

}