如何利用java的反射机制读取excel表格数据？这篇文章运用了实例代码展示，代码非常详细，可供感兴趣的小伙伴们参考借鉴，希望对大家有所帮助。
邢台网站制作公司哪家好，找创新互联公司！从网页设计、网站建设、微信开发、APP开发、响应式网站开发等网站项目制作，到程序开发，运营维护。创新互联公司从2013年开始到现在10年的时间，我们拥有了丰富的建站经验和运维经验，来保证我们的工作的顺利进行。专注于网站建设就选创新互联公司。
如下excel表格，按照表头名字读取数据，允许表头增加无意义空格，允许表头顺序交换。
| 序号 | 隧道左公里标 | 隧道右公里标 | 是否隧道 | | 1 | DK2291.416 | DK0 | 是 |
| 2 | DK7389.65 | DK2291.416 | 否 |
| 3 | ZK2277 | ZK0 | 是 |
| 4 | ZK5235.68 | ZK2277 | 否 |
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
*
*/
public class ExcelUtils {
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> read() throws Exception {
return read(0, 0, getRowCount(0) - 1);
}
/**
*
* 读取指定sheet 页所有数据
*
* @param sheetIx 指定 sheet 页，从 0 开始
* @return
* @throws Exception
*/
public List> read(int sheetIx) throws Exception {
return read(sheetIx, 0, getRowCount(sheetIx) - 1);
}
/**
*
* 读取指定sheet 页所有数据
*
* @param sheetIx 指定 sheet 页，从 0 开始
* @return
* @throws Exception
*/
public List> 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> read(int sheetIx, int start, int end) throws Exception {
Sheet sheet = workbook.getSheetAt(sheetIx);
List> list = new ArrayList>();
if (end > getRowCount(sheetIx)) {
end = getRowCount(sheetIx);
}
int cols = sheet.getRow(0).getLastCellNum(); // 第一行总列数
for (int i = start; i <= end; i++) {
List rowList = new ArrayList();
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 页指定行数据
*
* @param sheetIx 指定 sheet 页，从 0 开始
* @param start 指定开始行，从 0 开始
* @param end 指定结束行，从 0 开始
* @return
* @throws Exception
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public List> readGeneric(int sheetIx, int start, int end, T t) throws Exception {
Sheet sheet = workbook.getSheetAt(sheetIx);
List> list = new ArrayList>();
if (end > getRowCount(sheetIx)) {
end = getRowCount(sheetIx);
}
List colNums = new ArrayList();
for (int i = start; i <= end; i++) {
List rowList = new ArrayList();
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> read(int sheetIx, int startRow, int endRow, int startCol, int endCols) throws Exception {
Sheet sheet = workbook.getSheetAt(sheetIx);
List> list = new ArrayList>();
if (endRow > getRowCount(sheetIx)) {
endRow = getRowCount(sheetIx);
}
for (int i = startRow; i <= endRow; i++) {
List rowList = new ArrayList();
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> rowData) throws IOException {
return write(0, rowData, 0);
}
/**
*
* 将数据写入到 Excel 新创建的 Sheet 页
*
* @param rowData 数据
* @param sheetName 长度为1-31，不能包含后面任一字符: ：\ / ? * [ ]
* @return
* @throws IOException
*/
public boolean write(List> 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> 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> 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 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 getRowValue(int sheetIx, int rowIndex) {
Sheet sheet = workbook.getSheetAt(sheetIx);
Row row = sheet.getRow(rowIndex);
List list = new ArrayList();
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 getColumnValue(int sheetIx, int rowFrom, int colIndex) {
Sheet sheet = workbook.getSheetAt(sheetIx);
List list = new ArrayList();
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 默认的
* 默认的数据类型：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 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);
}
}
}
导入数据库表格数据如下：
| Idx | Tunnel_left_ZDK | Tunnel_right_ZDK | is_tunnel
| | 1 | DK2291.416 | DK0 | 是 |
| 2 | DK7389.65 | DK2291.416 | 否 |
| 3 | ZK2277 | ZK0 | 是 |
| 4 | ZK5235.68 | ZK2277 | 否 |
以上就是利用java的反射机制读取excel表格数据的方法，看完之后是否有所收获呢？如果想了解更多相关内容，欢迎关注创新互联行业资讯！
当前文章：如何利用java的反射机制读取excel表格数据
网页链接：
http://kswjz.com/article/gsjsgc.html
