POI-Excel数据解析------JAVA实现Excel表单数据解析功能（精简完整版）

最新推荐文章于 2024-07-05 14:30:10 发布

豢龙先生

最新推荐文章于 2024-07-05 14:30:10 发布

阅读量272

点赞数

本文链接：https://blog.csdn.net/sanjun333/article/details/100906158

版权

POI-Excel解析Excel表单数据

1、一些常量

package com.dsanjun.poi.constant;

/**
 * 常量
 * 
 * @author dyw
 * @date 2019年9月1日
 */
public class Constants {
    /**
	 * 所有日期和时间
	 */
	List<Short> ALL_EXCEL_FORMAT_INDEX = Arrays.asList(new Short[] { 14, 15, 16, 17, 18, 19, 20, 21, 22, 30, 31, 32, 33,
			45, 46, 47, 176, 177, 178, 179, 180, 181, 182, 55, 183, 56, 184, 185, 57, 186, 58, 187, 188, 189, 190, 191,
			192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208 });
	/**
	 * 07版excel后缀名
	 */
	public static String EXCEL_SUFFIX_07 = "xlsx";
	/**
	 * 03版excel后缀名
	 */
	public static String EXCEL_SUFFIX_03 = "xls";
	/**
	 * 数值NUMERIC格式单元格的formatStr
	 */
	public static String GENERAL = "General";
}

2、Excel表头对象

package com.dsanjun.poi.bean;

/**
 * 列标题单元格
 * 
 * @author dyw
 * @date 2019年9月3日
 */
public final class TitleCell {
	private Integer index;
	private String name;

	private TitleCell(Integer index, String name) {
		this.index = index;
		this.name = name;
	}

	public static TitleCell getInstance(Integer index, String name) {
		return new TitleCell(index, name);
	}

	public Integer getIndex() {
		return index;
	}

	public void setIndex(Integer index) {
		this.index = index;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public String toString() {
		return "Title [index=" + index + ", name=" + name + "]";
	}

}

3、Excel表格解析对象

package com.dsanjun.poi.parse;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.poi.EncryptedDocumentException;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.DateUtil;
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.usermodel.WorkbookFactory;
import com.dsanjun.poi.bean.TitleCell;
import com.dsanjun.poi.constant.Constants;

/**
 * Excel表格解析对象
 * 
 * @author dyw
 * @date 2019年9月11日
 */
public class ExcelParser {
	/** 表头对象列表 */
	private List<TitleCell> titleList;
	/** 工作簿 */
	private Workbook workbook;
	/** 标识是否存储sheet列表 */
	private Boolean haseSheetList;
	/** 工作簿所包含的sheet列表 */
	private List<Sheet> sheetList;

	/**
	 * 构造器
	 * 
	 * @param workbook      工作簿
	 * @param titleList     用户指定的表头
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 */
	public ExcelParser(Workbook workbook, List<TitleCell> titleList, boolean initSheetList) {
		this.workbook = workbook;
		this.haseSheetList = initSheetList;
		this.titleList = titleList;
		if (initSheetList) {
			initSheetList();
		}
	}

	/**
	 * 构造器
	 * 
	 * @param inp           文件输入流
	 * @param titleList     用户指定的表头
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 */
	public ExcelParser(InputStream inp, List<TitleCell> titleList, boolean initSheetList) {
		try {
			this.workbook = WorkbookFactory.create(inp);
			this.haseSheetList = initSheetList;
			this.titleList = titleList;
			if (initSheetList) {
				initSheetList();
			}
		} catch (EncryptedDocumentException | IOException e) {
			e.printStackTrace();
		}
	}

	/**
	 * 解析工作簿的数据
	 * 
	 * @return Map（键为sheet的索引）
	 */
	public Map<Integer, List<Map<String, Object>>> parseExcel() {
		Map<Integer, List<Map<String, Object>>> sheetDatas = new HashMap<Integer, List<Map<String, Object>>>();
		for (int i = 0; i < workbook.getNumberOfSheets(); i++) {
			List<Map<String, Object>> sheetData = parseExcel(i);
			if (sheetData != null) {
				sheetDatas.put(i, sheetData);
			}
		}
		return sheetDatas;
	}

	/**
	 * 解析指定索引sheet的不含表头的数据
	 * 
	 * @param sheetIndex sheet索引
	 * @return List（sheet中不含表头的所有数据）
	 */
	public List<Map<String, Object>> parseExcel(int sheetIndex) {
		if (haseSheetList) {
			return parseSheet(sheetList.get(sheetIndex));
		} else {
			return parseSheet(workbook.getSheetAt(sheetIndex));
		}
	}

	/**
	 * 初始化sheet列表
	 */
	protected void initSheetList() {
		if (workbook != null) {
			sheetList = new ArrayList<Sheet>();
			for (int i = 0; i < workbook.getNumberOfSheets(); i++) {
				sheetList.add(workbook.getSheetAt(i));
			}
		}
	}

	/**
	 * 解析sheet不含表头的所有行数据
	 * 
	 * @param sheet sheet对象
	 * @return List（所有行数据列表）
	 */
	protected List<Map<String, Object>> parseSheet(Sheet sheet) {
		List<Map<String, Object>> rowDatas = new ArrayList<Map<String, Object>>();
		if (sheet != null) {
			for (int i = sheet.getFirstRowNum() + 1; i <= sheet.getLastRowNum(); i++) {
				Map<String, Object> rowData = parseRow(sheet.getRow(i));
				rowDatas.add(rowData);
			}
		}
		return rowDatas;
	}

	/**
	 * 解析单行数据，返回Map
	 * 
	 * @param row 行对象
	 * @return Map（键是表头字段）
	 */
	protected Map<String, Object> parseRow(Row row) {
		Map<String, Object> map = new HashMap<String, Object>();
		for (int i = 0; i < titleList.size(); i++) {
			map.put(titleList.get(i).getName(), parseCell(row.getCell(i)));
		}
		return map;
	}

	public Object parseCell(Cell cell) {
		return getCellValue(cell);
	}

	/**
	 * 获取单元格的值
	 * 
	 * @param cell
	 * @return
	 */
	public Object getCellValue(Cell cell) {
		if (cell == null)
			return null;
		switch (cell.getCellType()) {
		case STRING:
			return cell.getStringCellValue();
		case FORMULA:
			return cell.getCellFormula();
		case NUMERIC:
			double value = cell.getNumericCellValue();
			if (Constants.ALL_EXCEL_FORMAT_INDEX.contains(cell.getCellStyle().getDataFormat())) {
				Date date = DateUtil.getJavaDate(value);
				return date;
			} else {
				return cell.getNumericCellValue();
			}
		case BOOLEAN:
			return cell.getBooleanCellValue();
		case BLANK:
			return null;
		case ERROR:
			return null;
		case _NONE:
			return null;
		default:
			return null;
		}
	}

	public Workbook getWorkbook() {
		return workbook;
	}

	public List<Sheet> getSheetList() {
		return sheetList;
	}
}

4、工具

package com.dsanjun.poi.parse;

import java.io.InputStream;
import java.util.List;
import java.util.Map;
import org.apache.poi.ss.usermodel.Workbook;
import com.dsanjun.poi.utils.TitleUtils;

/**
 * 工具
 * 
 * @author dyw
 * @date 2019年9月16日
 */
public class ExcelImport {
	/**
	 * 解析Excel表格的所有数据（不含表头）
	 * 
	 * @param inp           文件输入流
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @return
	 */
	public static Map<Integer, List<Map<String, Object>>> imports(InputStream inp, String[] titleNameArr,
			String[] keyNameArr, boolean initSheetList) {
		Map<Integer, List<Map<String, Object>>> map = new ExcelParser(inp, TitleUtils.convertToTitleList(titleNameArr),
				initSheetList).parseExcel();
		return ImportConvert.convertToListMap(titleNameArr, keyNameArr, map);
	}

	/**
	 * 解析Excel表格的所有数据（不含表头）
	 * 
	 * @param workbook      工作簿
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @return
	 */
	public static Map<Integer, List<Map<String, Object>>> imports(Workbook workbook, String[] titleNameArr,
			String[] keyNameArr, boolean initSheetList) {
		Map<Integer, List<Map<String, Object>>> map = new ExcelParser(workbook,
				TitleUtils.convertToTitleList(titleNameArr), initSheetList).parseExcel();
		return ImportConvert.convertToListMap(titleNameArr, keyNameArr, map);
	}

	/**
	 * 解析Excel表格的指定Sheet的数据（不含表头）
	 * 
	 * @param inp           文件输入流
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @param sheetIndex    sheet索引
	 * @return
	 */
	public static List<Map<String, Object>> imports(InputStream inp, String[] titleNameArr, String[] keyNameArr,
			boolean initSheetList, int sheetIndex) {
		List<Map<String, Object>> map = new ExcelParser(inp, TitleUtils.convertToTitleList(titleNameArr), initSheetList)
				.parseExcel(sheetIndex);
		return ImportConvert.convertToMapList(titleNameArr, keyNameArr, map);
	}

	/**
	 * 解析Excel表格的指定Sheet的数据（不含表头）
	 * 
	 * @param workbook      工作簿
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @param sheetIndex    sheet索引
	 * @return
	 */
	public static List<Map<String, Object>> imports(Workbook workbook, String[] titleNameArr, String[] keyNameArr,
			boolean initSheetList, int sheetIndex) {
		List<Map<String, Object>> map = new ExcelParser(workbook, TitleUtils.convertToTitleList(titleNameArr),
				initSheetList).parseExcel(sheetIndex);
		return ImportConvert.convertToMapList(titleNameArr, keyNameArr, map);
	}
}

5、转换器

package com.dsanjun.poi.parse;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import com.dsanjun.poi.utils.TitleUtils;

/**
 * 转换器
 * 
 * @author dyw
 * @date 2019年9月16日
 */
public class ImportConvert {
	/**
	 * 转换单个Sheet数据
	 * 
	 * @param titleNameArr 用户指定的Excel表头数组
	 * @param keyNameArr   Excel表头对应Map的key
	 * @param list
	 * @return
	 */
	public static List<Map<String, Object>> convertToMapList(String[] titleNameArr, String[] keyNameArr,
			List<Map<String, Object>> list) {
		return doConvertToMapList(TitleUtils.titleMapFile(titleNameArr, keyNameArr), list);
	}

	/**
	 * 转换整个Excel表单数据
	 * 
	 * @param titleNameArr 用户指定的Excel表头数组
	 * @param keyNameArr   Excel表头对应Map的key
	 * @param map
	 * @return
	 */
	public static Map<Integer, List<Map<String, Object>>> convertToListMap(String[] titleNameArr, String[] keyNameArr,
			Map<Integer, List<Map<String, Object>>> map) {
		Set<Integer> keySet = map.keySet();
		for (Integer key : keySet) {
			map.put(key, convertToMapList(titleNameArr, keyNameArr, map.get(key)));
		}
		return map;
	}

	/**
	 * 转换数据
	 * 
	 * @param titleMapFile 表头和属性（或key）的映射关系
	 * @param list
	 * @return
	 */
	private static List<Map<String, Object>> doConvertToMapList(Map<String, String> titleMapFile,
			List<Map<String, Object>> list) {
		List<Map<String, Object>> resultList = new ArrayList<Map<String, Object>>();
		for (Map<String, Object> map : list) {
			resultList.add(doConvertToMap(titleMapFile, map));
		}
		return resultList;
	}

	/**
	 * 转换数据
	 * 
	 * @param titleMapFile
	 * @param map
	 * @return
	 */
	private static Map<String, Object> doConvertToMap(Map<String, String> titleMapFile, Map<String, Object> map) {
		Map<String, Object> resultMap = new HashMap<String, Object>();
		Set<String> titleKeySet = titleMapFile.keySet();
		for (String title : titleKeySet) {
			resultMap.put(titleMapFile.get(title), map.get(title));
		}
		return resultMap;
	}
}

6、表头映射工具

package com.dsanjun.poi.utils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import com.dsanjun.poi.bean.TitleCell;
/**
 * 表头映射工具
 * 
 * @author dyw
 * @date 2019年9月16日
 */
public class TitleUtils {
	/**
	 * 获取用户指定表头和属性字段（或map的key）的映射关系
	 * 
	 * @param titleNameArr 用户指定的Excel表头数组
	 * @param nameArr      Excel表头对应的实体类的属性名或Excel表头对应Map的key
	 * @return 表头和属性（或key）的映射关系
	 */
	public static Map<String, String> titleMapFile(String[] titleNameArr, String[] nameArr) {
		Map<String, String> map = new HashMap<String, String>();
		for (int i = 0; i < titleNameArr.length; i++) {
			map.put(titleNameArr[i], nameArr[i]);
		}
		return map;
	}

	/**
	 * 用户指定的Excel表头数组转换成TitleCell列表
	 * 
	 * @param titleNameArr 用户指定的Excel表头数组
	 * @return TitleCell对象列表
	 */
	public static List<TitleCell> convertToTitleList(String[] titleNameArr) {
		List<TitleCell> titleList = new ArrayList<TitleCell>();
		for (int i = 0; i < titleNameArr.length; i++) {
			titleList.add(TitleCell.getInstance(i, titleNameArr[i]));
		}
		return titleList;
	}
}

7、表单数据解析对外工具

package com.dsanjun.poi;

import java.io.InputStream;
import java.util.List;
import java.util.Map;
import org.apache.poi.ss.usermodel.Workbook;
import com.dsanjun.poi.parse.ExcelImport;

/**
 * 表单数据解析对外工具
 * 
 * @author dyw
 * @date 2019年9月16日
 */
public class POIParseExcelUtils {
	/**
	 * 解析Excel表格的所有数据（不含表头）
	 * 
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param workbook      工作簿
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @return
	 */
	public static Map<Integer, List<Map<String, Object>>> importExcelToMap(String[] titleNameArr, String[] keyNameArr,
			Workbook workbook, boolean initSheetList) {
		return ExcelImport.imports(workbook, titleNameArr, keyNameArr, initSheetList);
	}

	/**
	 * 解析Excel表格的所有数据（不含表头）
	 * 
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param inp           文件输入流
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @return
	 */
	public static Map<Integer, List<Map<String, Object>>> importExcelToMap(String[] titleNameArr, String[] keyNameArr,
			InputStream inp, boolean initSheetList) {
		return ExcelImport.imports(inp, titleNameArr, keyNameArr, initSheetList);
	}

	/**
	 * 解析Excel表格的指定Sheet的数据（不含表头）
	 * 
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param workbook      工作簿
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @param sheetIndex    sheet索引
	 * @return
	 */
	public static List<Map<String, Object>> importExcelToMapList(String[] titleNameArr, String[] keyNameArr,
			Workbook workbook, boolean initSheetList, int sheetIndex) {
		return ExcelImport.imports(workbook, titleNameArr, keyNameArr, initSheetList, sheetIndex);
	}

	/**
	 * 解析Excel表格的指定Sheet的数据（不含表头）
	 * 
	 * @param titleNameArr  Excel表头数组
	 * @param keyNameArr    map的key数组
	 * @param inp           文件输入流
	 * @param initSheetList 是否在ExcelParser的实例中初始化一个Sheet列表集合
	 * @param sheetIndex    sheet索引
	 * @return
	 */
	public static List<Map<String, Object>> importExcelToMapList(String[] titleNameArr, String[] keyNameArr,
			InputStream inp, boolean initSheetList, int sheetIndex) {
		return ExcelImport.imports(inp, titleNameArr, keyNameArr, initSheetList, sheetIndex);
	}
}