如何利用java的反射機制讀取excel表格數據

如何利用java的反射機制讀取excel表格數據？這篇文章運用了實例代碼展示，代碼非常詳細，可供感興趣的小伙伴們參考借鑒，希望對大家有所幫助。

如下excel表格，按照表頭名字讀取數據，允許表頭增加無意義空格，允許表頭順序交換。

excel導入工具類，提取配置表格文件順序，模糊動態匹配表頭名字和順序。

/**
 * 
 */
package com.crscd.config.service.cbtc2.atp.excel;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFDateUtil;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.util.HSSFColor;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.DataFormat;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFColor;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.springframework.util.StringUtils;

import jcifs.smb.SmbFileInputStream;

/**
 * @author ZhaoAnan
 * @param <T>
 *
 */
public class ExcelUtils<T> {

	private Workbook workbook;
	private OutputStream os;
	private String pattern;// 日期格式
	private final static String excel2003L = ".xls"; // 2003- 版本的excel
	private final static String excel2007U = ".xlsx"; // 2007+ 版本的excel

	public void setPattern(String pattern) {
		this.pattern = pattern;
	}

	public void ExcelUtil(Workbook workboook) {
		this.workbook = workboook;
	}

	/**
	 * 描述：根據文件后綴，自適應上傳文件的版本
	 * 
	 * @param inStr    將file.getInputStream()獲取的輸入流
	 * @param fileName file.getOriginalFilename()獲取的原文件名
	 */
	public static Workbook getWorkbook(InputStream inStr, String fileName) throws Exception {
		Workbook wb = null;
		String fileType = fileName.substring(fileName.lastIndexOf("."));
		if (excel2003L.equals(fileType)) {
			wb = new HSSFWorkbook(inStr); // 2003-
		} else if (excel2007U.equals(fileType)) {
			wb = new XSSFWorkbook(inStr); // 2007+
		} else {
			throw new Exception("解析的文件格式有誤！");
		}
		return wb;
	}

	@Override
	public String toString() {

		return "共有 " + getSheetCount() + "個sheet 頁！";
	}

	public String toString(int sheetIx) throws IOException {

		return "第 " + (sheetIx + 1) + "個sheet 頁，名稱： " + getSheetName(sheetIx) + "，共 " + getRowCount(sheetIx) + "行！";
	}

	/**
	 * 
	 * 根據后綴判斷是否為 Excel 文件，后綴匹配xls和xlsx
	 * 
	 * @param pathname
	 * @return
	 * 
	 */
	public static boolean isExcel(String pathname) {
		if (pathname == null) {
			return false;
		}
		return pathname.endsWith(".xls") || pathname.endsWith(".xlsx");
	}

	/**
	 * 
	 * 讀取 Excel 第一頁所有數據
	 * 
	 * @return
	 * @throws Exception
	 * 
	 */
	public List<List<String>> read() throws Exception {
		return read(0, 0, getRowCount(0) - 1);
	}

	/**
	 * 
	 * 讀取指定sheet 頁所有數據
	 * 
	 * @param sheetIx 指定 sheet 頁，從 0 開始
	 * @return
	 * @throws Exception
	 */
	public List<List<String>> read(int sheetIx) throws Exception {
		return read(sheetIx, 0, getRowCount(sheetIx) - 1);
	}
	
	/**
	 * 
	 * 讀取指定sheet 頁所有<T>數據
	 * 
	 * @param sheetIx 指定 sheet 頁，從 0 開始
	 * @return
	 * @throws Exception
	 */
	public List<List<T>> readGeneric(int sheetIx, T t) throws Exception {
		return readGeneric(sheetIx, 0, getRowCount(sheetIx) - 1, t);
	}

	/**
	 * 
	 * 讀取指定sheet 頁指定行數據
	 * 
	 * @param sheetIx 指定 sheet 頁，從 0 開始
	 * @param start   指定開始行，從 0 開始
	 * @param end     指定結束行，從 0 開始
	 * @return
	 * @throws Exception
	 */
	public List<List<String>> read(int sheetIx, int start, int end) throws Exception {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		List<List<String>> list = new ArrayList<List<String>>();

		if (end > getRowCount(sheetIx)) {
			end = getRowCount(sheetIx);
		}

		int cols = sheet.getRow(0).getLastCellNum(); // 第一行總列數

		for (int i = start; i <= end; i++) {
			List<String> rowList = new ArrayList<String>();
			Row row = sheet.getRow(i);
			for (int j = 0; j < cols; j++) {
				if (row == null) {
					rowList.add(null);
					continue;
				}
				try {
			        if (row.getCell(j).getCellTypeEnum() == CellType.FORMULA) {
			        	row.getCell(j).setCellType(CellType.STRING);
			            rowList.add(row.getCell(j).getStringCellValue());
			        }else {
			        	rowList.add(getCellValueToString(row.getCell(j)));
			        }
				}catch(Exception e) {
					rowList.add(getCellValueToString(row.getCell(j)));
				}
			}
			list.add(rowList);
		}

		return list;
	}

	
	/**
	 * 獲取某sheet某行的數據
	 * 
	 * @param sheetIx
	 * @param rowNum
	 * @param colNum
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public List getRowdata(Row row) throws Exception {
		List list = new ArrayList();
		int cols = row.getLastCellNum();
		for (int j = 0; j < cols; j++) {
			//list.add(getCellValueToString(row.getCell(j)));
			//取excel表中公式數據 add by gaofan 20190618
			try {
		        if (row.getCell(j).getCellTypeEnum() == CellType.FORMULA) {
		        	row.getCell(j).setCellType(CellType.STRING);
		        	list.add(getCellValueToString(row.getCell(j)));
		        }else {
		        	list.add(getCellValueToString(row.getCell(j)));
		        }
			}catch(Exception e) {
				list.add(getCellValueToString(row.getCell(j)));
			}
		}
		return list;
	}
	/**
	 * 
	 * 讀取指定sheet 頁指定行<T>數據
	 * 
	 * @param sheetIx 指定 sheet 頁，從 0 開始
	 * @param start   指定開始行，從 0 開始
	 * @param end     指定結束行，從 0 開始
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	public List<List<T>> readGeneric(int sheetIx, int start, int end, T t) throws Exception {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		List<List<T>> list = new ArrayList<List<T>>();

		if (end > getRowCount(sheetIx)) {
			end = getRowCount(sheetIx);
		}
		List<Integer> colNums = new ArrayList<Integer>();
		for (int i = start; i <= end; i++) {
			List<T> rowList = new ArrayList<T>();
			Row row = sheet.getRow(i);
			List rowdata = getRowdata(row);
			Class clazz = t.getClass();
			Object fa= clazz.newInstance();
			Method method = t.getClass().getMethod("getLdcode", new Class[]{});
			String[] ldcode = (String[])method.invoke(fa, new Object[]{});
			

			//處理從0行開始取得請求
			if(0 == start)
			{
				//處理請求的第0行，即表頭
				if(i == 0)
				{
					//通過反射獲取模板類的實例
					try {
						String simpleName = t.getClass().getSimpleName();
						String StrEnumClass = simpleName.substring(0, simpleName.length()-5) + "Enum";
						Class EnumClass = Class.forName("com.crscd.config.service.cbtc2.atp.excel.enums."+StrEnumClass);
						//Object enumInstance = EnumClass.newInstance();
						
						for(int j = 0; j < rowdata.size(); j++)
						{
							//去除表頭上空格、回車、換行符、制表符
							if(null != rowdata.get(j) && !"".equals(rowdata.get(j))) {
								Pattern p = Pattern.compile("\\s*|\t|\r|\n");
								String str = (String)rowdata.get(j);
					            Matcher m = p.matcher(str);
					            String excelData =  m.replaceAll("");
					            //獲取表頭對應的工具類中ldcode位置
					            Method met = EnumClass.getMethod("getStatus", String.class);
					            int col = (int) met.invoke(Object.class, excelData);
								colNums.add(col);
							}else
							{
								colNums.add(-1);
							}
						}
					}catch(ClassNotFoundException e) {
						//e.printStackTrace();
					}
					
				}
			}
				
			for(int j = 0; j < colNums.size(); j++) {
				int k = j;
				//如果映射表頭列和數據列不匹配，當數據列小于映射表頭列時，說明excel有無效列，則不足的列用空串補足
				if (colNums.size() > rowdata.size() ) {
					rowdata.add("");
				}
				if(0 == start && !colNums.isEmpty())
				{
					k = colNums.get(j);
				}
				if(k == -1) {
					continue;
				}else {
					try {
						method = t.getClass().getMethod("set"+ldcode[k], String.class);
						method.invoke(fa, rowdata.get(j));
					//如果映射表頭列和數據列不匹配，是excel多余無效行列,則越界，仍保留未越界之前的全部數據。
					}catch(IndexOutOfBoundsException e) {
						continue;
					}
				}
			}
			rowList.add((T) fa);
			list.add(rowList);
		}

		return list;
	}
	
	/**
	 * 
	 * 讀取指定sheet 頁指定行數據
	 * 
	 * @param sheetIx  指定 sheet 頁，從 0 開始
	 * @param startRow 指定開始行，從 0 開始
	 * @param endRow   指定結束行，從 0 開始 start=end=0 就是第一行
	 * @param startCol 指定開始列
	 * @param startCol 指定結束列
	 * @return
	 * @throws Exception
	 */
	public List<List<String>> read(int sheetIx, int startRow, int endRow, int startCol, int endCols) throws Exception {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		List<List<String>> list = new ArrayList<List<String>>();

		if (endRow > getRowCount(sheetIx)) {
			endRow = getRowCount(sheetIx);
		}

		for (int i = startRow; i <= endRow; i++) {
			List<String> rowList = new ArrayList<String>();
			Row row = sheet.getRow(i);
			for (int j = startCol; j <= endCols; j++) {
				if (row == null) {
					rowList.add(null);
					continue;
				}
				//rowList.add(getCellValue(row.getCell(j)));
				//取excel表中公式數據 add by gaofan 20190618
				try {
			        if (row.getCell(j).getCellTypeEnum() == CellType.FORMULA) {
			        	row.getCell(j).setCellType(CellType.STRING);
			            rowList.add(row.getCell(j).getStringCellValue());
			        }else {
			        	rowList.add(getCellValueToString(row.getCell(j)));
			        }
				}catch(Exception e) {
					rowList.add(getCellValueToString(row.getCell(j)));
				}
			}
			list.add(rowList);
		}
		return list;
	}

	/**
	 * 獲取某sheet某行某列的數據
	 * 
	 * @param sheetIx
	 * @param rowNum
	 * @param colNum
	 * @return
	 * @throws Exception
	 */
	@SuppressWarnings("deprecation")
	public String readCell(int sheetIx, int rowNum, int colNum) throws Exception {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		Row row = sheet.getRow(rowNum);
		if (row == null) {
			return null;
		}
		row.getCell(colNum).setCellType(Cell.CELL_TYPE_STRING);
		Cell cell = row.getCell(colNum);
		if (cell == null) {
			return null;
		}
		return cell.getStringCellValue();
	}

	/**
	 * 
	 * 將數據寫入到 Excel 默認第一頁中，從第1行開始寫入
	 * 
	 * @param rowData 數據
	 * @return
	 * @throws IOException
	 * 
	 */
	public boolean write(List<List<String>> rowData) throws IOException {
		return write(0, rowData, 0);
	}

	/**
	 * 
	 * 將數據寫入到 Excel 新創建的 Sheet 頁
	 * 
	 * @param rowData   數據
	 * @param sheetName 長度為1-31，不能包含后面任一字符: ：\ / ? * [ ]
	 * @return
	 * @throws IOException
	 */
	public boolean write(List<List<String>> rowData, String sheetName, boolean isNewSheet) throws IOException {
		Sheet sheet = null;
		if (isNewSheet) {
			sheet = workbook.createSheet(sheetName);
		} else {
			sheet = workbook.createSheet();
		}
		int sheetIx = workbook.getSheetIndex(sheet);
		return write(sheetIx, rowData, 0);
	}

	/**
	 * 
	 * 將數據追加到sheet頁最后
	 * 
	 * @param rowData  數據
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param isAppend 是否追加,true 追加，false 重置sheet再添加
	 * @return
	 * @throws IOException
	 */
	public boolean write(int sheetIx, List<List<String>> rowData, boolean isAppend) throws IOException {
		if (isAppend) {
			return write(sheetIx, rowData, getRowCount(sheetIx));
		} else {// 清空再添加
			clearSheet(sheetIx);
			return write(sheetIx, rowData, 0);
		}
	}

	/**
	 * 
	 * 將數據寫入到 Excel 指定 Sheet 頁指定開始行中,指定行后面數據向后移動
	 * 
	 * @param rowData  數據
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param startRow 指定開始行，從 0 開始
	 * @return
	 * @throws IOException
	 */
	public boolean write(int sheetIx, List<List<String>> rowData, int startRow) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		int dataSize = rowData.size();
		if (getRowCount(sheetIx) > 0) {// 如果小于等于0，則一行都不存在
			sheet.shiftRows(startRow, getRowCount(sheetIx), dataSize);
		}
		for (int i = 0; i < dataSize; i++) {
			Row row = sheet.createRow(i + startRow);
			for (int j = 0; j < rowData.get(i).size(); j++) {
				Cell cell = row.createCell(j);
				cell.setCellValue(rowData.get(i).get(j) + "");
			}
		}
		return true;
	}

	/**
	 * 
	 * 設置cell 樣式
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param colIndex 指定列，從 0 開始
	 * @return
	 * @throws IOException
	 */
	public boolean setStyle(int sheetIx, int rowIndex, int colIndex, CellStyle style) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		// sheet.autoSizeColumn(colIndex, true);// 設置列寬度自適應
		sheet.setColumnWidth(colIndex, 4000);

		Cell cell = sheet.getRow(rowIndex).getCell(colIndex);
		cell.setCellStyle(style);

		return true;
	}

	/**
	 * 
	 * 設置樣式
	 * 
	 * @param type 1：標題 2：第一行
	 * @return
	 */
	public CellStyle makeStyle(int type) {
		CellStyle style = workbook.createCellStyle();

		DataFormat format = workbook.createDataFormat();
		style.setDataFormat(format.getFormat("@"));// // 內容樣式 設置單元格內容格式是文本
		style.setAlignment(HorizontalAlignment.CENTER);// 內容居中

		// style.setBorderTop(CellStyle.BORDER_THIN);// 邊框樣式
		// style.setBorderRight(CellStyle.BORDER_THIN);
		// style.setBorderBottom(CellStyle.BORDER_THIN);
		// style.setBorderLeft(CellStyle.BORDER_THIN);

		Font font = workbook.createFont();// 文字樣式

		if (type == 1) {
			// style.setFillForegroundColor(HSSFColor.LIGHT_BLUE.index);//顏色樣式
			// 前景顏色
			// style.setFillBackgroundColor(HSSFColor.LIGHT_BLUE.index);//背景色
			// style.setFillPattern(CellStyle.ALIGN_FILL);// 填充方式
			font.setBold(true);
			font.setFontHeight((short) 500);
		}

		if (type == 2) {
			font.setBold(true);
			font.setFontHeight((short) 300);
		}

		style.setFont(font);

		return style;
	}

	/**
	 * 
	 * 合并單元格
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param firstRow 開始行
	 * @param lastRow  結束行
	 * @param firstCol 開始列
	 * @param lastCol  結束列
	 */
	public void region(int sheetIx, int firstRow, int lastRow, int firstCol, int lastCol) {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		sheet.addMergedRegion(new CellRangeAddress(firstRow, lastRow, firstCol, lastCol));
	}

	/**
	 * 
	 * 指定行是否為空
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定開始行，從 0 開始
	 * @return true 不為空，false 不行為空
	 * @throws IOException
	 */
	public boolean isRowNull(int sheetIx, int rowIndex) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		return sheet.getRow(rowIndex) == null;
	}

	/**
	 * 判斷行的內容是否為空
	 * 
	 * @return
	 */
	public boolean isRowEmpty(int sheetIx, int rowIndex) {
		Row row = this.workbook.getSheetAt(sheetIx).getRow(rowIndex);
		if (row != null) {
			for (int c = row.getFirstCellNum(); c < row.getLastCellNum(); c++) {
				Cell cell = row.getCell(c);
				if (cell != null && cell.getStringCellValue() != "" && cell.getCellTypeEnum() != CellType.BLANK)
					return false;
			}
		}
		return true;
	}

	/**
	 * 
	 * 創建行，若行存在，則清空
	 * 
	 * @param sheetIx 指定 sheet 頁，從 0 開始 指定創建行，從 0 開始
	 * @return
	 * @throws IOException
	 */
	public boolean createRow(int sheetIx, int rowIndex) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		sheet.createRow(rowIndex);
		return true;
	}

	/**
	 * 
	 * 指定單元格是否為空
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定開始行，從 0 開始
	 * @param colIndex 指定開始列，從 0 開始
	 * @return true 行不為空，false 行為空
	 * @throws IOException
	 */
	public boolean isCellNull(int sheetIx, int rowIndex, int colIndex) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		if (!isRowNull(sheetIx, rowIndex)) {
			return false;
		}
		Row row = sheet.getRow(rowIndex);
		return row.getCell(colIndex) == null;
	}

	/**
	 * 
	 * 創建單元格
	 * 
	 * @param sheetIx  指定 sheet 頁，從 0 開始
	 * @param rowIndex 指定行，從 0 開始
	 * @param colIndex 指定創建列，從 0 開始
	 * @return true 列為空，false 行不為空
	 * @throws IOException
	 */
	public boolean createCell(int sheetIx, int rowIndex, int colIndex) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		Row row = sheet.getRow(rowIndex);
		row.createCell(colIndex);
		return true;
	}

	/**
	 * 返回sheet 中的行數
	 * 
	 * 
	 * @param sheetIx 指定 Sheet 頁，從 0 開始
	 * @return
	 */
	public int getRowCount(int sheetIx) {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		if (sheet.getPhysicalNumberOfRows() == 0) {
			return 0;
		}
		return sheet.getLastRowNum() + 1;

	}

	/**
	 * 獲取有數據的行數
	 * 
	 * @param sheetIx
	 * @return
	 */
	public int getRealRowCount(int sheetIx) {
		int rowCount = getRowCount(sheetIx);
		int n = 0;
		for (int i = 0; i < rowCount; i++) {
			if (!isRowEmpty(sheetIx, i)) {
				n++;
			}
		}
		return n;
	}

	/**
	 * 
	 * 返回所在行的列數
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定行，從0開始
	 * @return 返回-1 表示所在行為空
	 */
	public int getColumnCount(int sheetIx, int rowIndex) {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		Row row = sheet.getRow(rowIndex);
		return row == null ? -1 : row.getLastCellNum();

	}

	/**
	 * 
	 * 設置row 和 column 位置的單元格值
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定行，從0開始
	 * @param colIndex 指定列，從0開始
	 * @param value    值
	 * @return
	 * @throws IOException
	 */
	public boolean setValueAt(int sheetIx, int rowIndex, int colIndex, String value) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		sheet.getRow(rowIndex).getCell(colIndex).setCellValue(value);
		return true;
	}

	/**
	 * 
	 * 返回 row 和 column 位置的單元格值
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定行，從0開始
	 * @param colIndex 指定列，從0開始
	 * @return
	 * 
	 */
	public String getValueAt(int sheetIx, int rowIndex, int colIndex) {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		return getCellValueToString(sheet.getRow(rowIndex).getCell(colIndex));
	}

	public String getCellValue(Cell cell) {
		int cellType = cell.getCellType();
		String cellValue = "";
		switch (cellType) {
		case HSSFCell.CELL_TYPE_NUMERIC:
			cellValue = String.valueOf(cell.getNumericCellValue());
			break;

		case HSSFCell.CELL_TYPE_FORMULA:
			try {
				cellValue = cell.getStringCellValue();
			} catch (IllegalStateException e) {
				cellValue = String.valueOf(cell.getNumericCellValue());
			}
			break;

		default:
			cellValue = cell.getStringCellValue();
		}

		return cellValue.trim();
	}

	/**
	 * 
	 * 重置指定行的值
	 * 
	 * @param rowData  數據
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定行，從0開始
	 * @return
	 * @throws IOException
	 */
	public boolean setRowValue(int sheetIx, List<String> rowData, int rowIndex) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		Row row = sheet.getRow(rowIndex);
		for (int i = 0; i < rowData.size(); i++) {
			row.getCell(i).setCellValue(rowData.get(i));
		}
		return true;
	}

	/**
	 * 
	 * 返回指定行的值的集合
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定行，從0開始
	 * @return
	 */
	public List<String> getRowValue(int sheetIx, int rowIndex) {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		Row row = sheet.getRow(rowIndex);
		List<String> list = new ArrayList<String>();
		if (row == null) {
			list.add(null);
		} else {
			for (int i = 0; i < row.getLastCellNum(); i++) {
				list.add(getCellValueToString(row.getCell(i)));
			}
		}
		return list;
	}

	/**
	 * 
	 * 返回列的值的集合
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowFrom  從指定行數開始
	 * @param colIndex 指定列，從0開始
	 * @return
	 */
	public List<String> getColumnValue(int sheetIx, int rowFrom, int colIndex) {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		List<String> list = new ArrayList<String>();
		for (int i = rowFrom; i < getRowCount(sheetIx); i++) {
			Row row = sheet.getRow(i);
			if (row == null) {
				list.add(null);
				continue;
			}
			list.add(getCellValueToString(sheet.getRow(i).getCell(colIndex)));
		}
		return list;
	}

	/**
	 * 
	 * 獲取excel 中sheet 總頁數
	 * 
	 * @return
	 */
	public int getSheetCount() {
		return workbook.getNumberOfSheets();
	}

	public void createSheet() {
		workbook.createSheet();
	}

	/**
	 * 
	 * 設置sheet名稱，長度為1-31，不能包含后面任一字符: ：\ / ? * [ ]
	 * 
	 * @param sheetIx 指定 Sheet 頁，從 0 開始，//
	 * @param name
	 * @return
	 * @throws IOException
	 */
	public boolean setSheetName(int sheetIx, String name) throws IOException {
		workbook.setSheetName(sheetIx, name);
		return true;
	}

	/**
	 * 
	 * 獲取 sheet名稱
	 * 
	 * @param sheetIx 指定 Sheet 頁，從 0 開始
	 * @return
	 * @throws IOException
	 */
	public String getSheetName(int sheetIx) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		return sheet.getSheetName();
	}

	/**
	 * 獲取sheet的索引，從0開始
	 * 
	 * @param name sheet 名稱
	 * @return -1表示該未找到名稱對應的sheet
	 */
	public int getSheetIndex(String name) {
		return workbook.getSheetIndex(name);
	}

	/**
	 * 
	 * 刪除指定sheet
	 * 
	 * @param sheetIx 指定 Sheet 頁，從 0 開始
	 * @return
	 * @throws IOException
	 */
	public boolean removeSheetAt(int sheetIx) throws IOException {
		workbook.removeSheetAt(sheetIx);
		return true;
	}

	/**
	 * 
	 * 刪除指定sheet中行，改變該行之后行的索引
	 * 
	 * @param sheetIx  指定 Sheet 頁，從 0 開始
	 * @param rowIndex 指定行，從0開始
	 * @return
	 * @throws IOException
	 */
	public boolean removeRow(int sheetIx, int rowIndex) throws IOException {
		Sheet sheet = workbook.getSheetAt(sheetIx);
		sheet.shiftRows(rowIndex + 1, getRowCount(sheetIx), -1);
		Row row = sheet.getRow(getRowCount(sheetIx) - 1);
		sheet.removeRow(row);
		return true;
	}

	/**
	 * 
	 * 設置sheet 頁的索引
	 * 
	 * @param sheetname Sheet 名稱 Sheet 索引，從0開始
	 */
	public void setSheetOrder(String sheetname, int sheetIx) {
		workbook.setSheetOrder(sheetname, sheetIx);
	}

	/**
	 * 
	 * 清空指定sheet頁（先刪除后添加并指定sheetIx）
	 * 
	 * @param sheetIx 指定 Sheet 頁，從 0 開始
	 * @return
	 * @throws IOException
	 */
	public boolean clearSheet(int sheetIx) throws IOException {
		String sheetname = getSheetName(sheetIx);
		removeSheetAt(sheetIx);
		workbook.createSheet(sheetname);
		setSheetOrder(sheetname, sheetIx);
		return true;
	}

	public Workbook getWorkbook() {
		return workbook;
	}

	/**
	 * 
	 * 關閉流
	 * 
	 * @throws IOException
	 */
	public void close() throws IOException {
		if (os != null) {
			os.close();
		}
		workbook.close();
	}

	/**
	 * 
	 * 轉換單元格的類型為String 默認的 <br>
	 * 默認的數據類型：CELL_TYPE_BLANK(3), CELL_TYPE_BOOLEAN(4),
	 * CELL_TYPE_ERROR(5),CELL_TYPE_FORMULA(2), CELL_TYPE_NUMERIC(0),
	 * CELL_TYPE_STRING(1)
	 * 
	 * @param cell
	 * @return
	 * 
	 */
	@SuppressWarnings("deprecation")
	private String getCellValueToString(Cell cell) {
		String strCell = "";
		if (cell == null) {
			return null;
		}
		switch (cell.getCellType()) {
		case Cell.CELL_TYPE_BOOLEAN:
			strCell = String.valueOf(cell.getBooleanCellValue());
			break;
		case Cell.CELL_TYPE_NUMERIC:
			if (HSSFDateUtil.isCellDateFormatted(cell)) {
				Date date = cell.getDateCellValue();
				if (pattern != null) {
					SimpleDateFormat sdf = new SimpleDateFormat(pattern);
					strCell = sdf.format(date);
				} else {
					strCell = date.toString();
				}
				break;
			}
			// 不是日期格式，則防止當數字過長時以科學計數法顯示
			cell.setCellType(HSSFCell.CELL_TYPE_STRING);
			strCell = cell.toString();
			break;
		case Cell.CELL_TYPE_STRING:
			strCell = cell.getStringCellValue();
			break;
		default:
			break;
		}
		return strCell;
	}

	/**
	 * 獲取cell
	 * 
	 * @param sheetId
	 * @param rowId
	 * @param colId
	 * @return
	 * @author zgd
	 * @time 2018年6月27日14:54:53
	 */
	public Cell getCell(int sheetId, int rowId, int colId) {
		Sheet sheet = workbook.getSheetAt(sheetId);
		Row row = sheet.getRow(rowId);
		if (row == null) {
			return null;
		}
		return row.getCell(colId);
	}

	/**
	 * 前景色是否為空,是否沒有填充任何顏色
	 * 
	 * @return
	 * @author zgd
	 * @time 2018年6月27日14:54:53
	 */
	public boolean isForeColorEmpty(int sheetId, int rowId, int colId) {
		if (this.workbook instanceof HSSFWorkbook) {
			HSSFCell cell = (HSSFCell) getCell(sheetId, rowId, colId);
			HSSFColor color = cell.getCellStyle().getFillForegroundColorColor();
			return "0:0:0".equals(color.getHexString());
		}
		if (this.workbook instanceof XSSFWorkbook) {
			XSSFCell cell = (XSSFCell) getCell(sheetId, rowId, colId);
			if (cell != null) {
				XSSFColor color = cell.getCellStyle().getFillForegroundColorColor();
				return color == null;
			}
		}
		return true;
	}

	/**
	 * 設置列寬
	 * 
	 * @param sheetId     sheet的索引
	 * @param mxiWidthRow 確保最小值列寬的行
	 * @param colb        從哪一列開始設置
	 * @param cole        到哪一行結束
	 * @author zgd
	 * @time 2018年6月27日14:54:53
	 */
	public void setColumnWidth(Sheet sheet, Row mxiWidthRow, int sheetId, int colb, int cole) {
		// 設置列寬
		for (int i = colb; i <= cole; i++) {
			int length = 0;
			if (mxiWidthRow.getCell(i) != null && !StringUtils.isEmpty(mxiWidthRow.getCell(i).getStringCellValue())) {
				length = mxiWidthRow.getCell(i).getStringCellValue().trim().getBytes().length * 256 + 200;
			}

			List<String> columnValue = this.getColumnValue(sheetId, 0, i);
			for (String s : columnValue) {
				if (s != null) {
					int l = s.trim().getBytes().length * 256 + 200;
					length = Math.max(l, length);
				}
			}
			if (length > 15000) {
				length = 15000;
			}
			sheet.setColumnWidth(i, length);
		}
	}
}	

導入數據庫表格數據如下：

以上就是利用java的反射機制讀取excel表格數據的方法，看完之后是否有所收獲呢？如果想了解更多相關內容，歡迎關注億速云行業資訊！