自己封装的poi操作Excel工具类

2023-02-11 07:14:12

自己封装的poi操作Excel工具类

在上一篇文章《使用poi读写Excel》中分享了一下poi操作Excel的简单示例，这次要分享一下我封装的一个Excel操作的工具类。

该工具类主要完成的功能是：读取Excel、汇总Excel的功能。在读取时，可以设定开始和结束读取的位置、设定是否读取多个sheet、设定读取那个或者那些sheet等。在汇总时，如设定是否覆盖目标文件、设定是否比较检查重复内容、设定检查重复的列索引等功能。具体来演示一下吧：

工具类源码：

package com.tgb.ccl.excel.util;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
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.XSSFWorkbook;
/**
* Excel文件操作工具类，包括读、写、合并等功能
*
* @author : 龙轩
* @group : tgb8
* @Version : 1.00
* @Date : 2014-10-29 上午12:40:44
*/
public class ExcelUtil {
//%%%%%%%%-------常量部分开始----------%%%%%%%%%
/**
* 默认的开始读取的行位置为第一行（索引值为0）
*/
private final static int READ_START_POS = 0;
/**
* 默认结束读取的行位置为最后一行（索引值=0，用负数来表示倒数第n行）
*/
private final static int READ_END_POS = 0;
/**
* 默认Excel内容的开始比较列位置为第一列（索引值为0）
*/
private final static int COMPARE_POS = 0;
/**
* 默认多文件合并的时需要做内容比较（相同的内容不重复出现）
*/
private final static boolean NEED_COMPARE = true;
/**
* 默认多文件合并的新文件遇到名称重复时，进行覆盖
*/
private final static boolean NEED_OVERWRITE = true;
/**
* 默认只操作一个sheet
*/
private final static boolean ONLY_ONE_SHEET = true;
/**
* 默认读取第一个sheet中（只有当ONLY_ONE_SHEET = true时有效）
*/
private final static int SELECTED_SHEET = 0;
/**
* 默认从第一个sheet开始读取（索引值为0）
*/
private final static int READ_START_SHEET= 0;
/**
* 默认在最后一个sheet结束读取（索引值=0，用负数来表示倒数第n行）
*/
private final static int READ_END_SHEET = 0;
/**
* 默认打印各种信息
*/
private final static boolean PRINT_MSG = true;
//%%%%%%%%-------常量部分结束----------%%%%%%%%%
//%%%%%%%%-------字段部分开始----------%%%%%%%%%
/**
* Excel文件路径
*/
private String excelPath = "data.xlsx";
/**
* 设定开始读取的位置，默认为0
*/
private int startReadPos = READ_START_POS;
/**
* 设定结束读取的位置，默认为0，用负数来表示倒数第n行
*/
private int endReadPos = READ_END_POS;
/**
* 设定开始比较的列位置，默认为0
*/
private int comparePos = COMPARE_POS;
/**
* 设定汇总的文件是否需要替换，默认为true
*/
private boolean isOverWrite = NEED_OVERWRITE;
/**
* 设定是否需要比较，默认为true(仅当不覆写目标内容是有效，即isOverWrite=false时有效)
*/
private boolean isNeedCompare = NEED_COMPARE;
/**
* 设定是否只操作第一个sheet
*/
private boolean onlyReadOneSheet = ONLY_ONE_SHEET;
/**
* 设定操作的sheet在索引值
*/
private int selectedSheetIdx =SELECTED_SHEET;
/**
* 设定操作的sheet的名称
*/
private String selectedSheetName = "";
/**
* 设定开始读取的sheet，默认为0
*/
private int startSheetIdx = READ_START_SHEET;
/**
* 设定结束读取的sheet，默认为0，用负数来表示倒数第n行
*/
private int endSheetIdx = READ_END_SHEET;
/**
* 设定是否打印消息
*/
private boolean printMsg = PRINT_MSG;
//%%%%%%%%-------字段部分结束----------%%%%%%%%%
public static void main(String[] args) {
ExcelUtil eu = new ExcelUtil();
//从第一行开始读取
eu.setStartReadPos(1);
String src_xlspath = "D:\\2.xls";
String dist_xlsPath = "D:\\1.xls";
List<Row> rowList;
try {
rowList = eu.readExcel(src_xlspath);
//eu.writeExcel_xls(rowList, src_xlspath, dist_xlsPath);
} catch (IOException e) {
e.printStackTrace();
}
}
public ExcelUtil(){
}
public ExcelUtil(String excelPath){
this.excelPath = excelPath;
}
/**
* 还原设定（其实是重新new一个新的对象并返回）
* @return
*/
public ExcelUtil RestoreSettings(){
ExcelUtil instance = new ExcelUtil(this.excelPath);
return instance;
}
/**
* 自动根据文件扩展名，调用对应的读取方法
*
* @Title: writeExcel
* @Date : 2014-9-11 下午01:50:38
* @param xlsPath
* @throws IOException
*/
public List<Row> readExcel() throws IOException{
return readExcel(this.excelPath);
}
/**
* 自动根据文件扩展名，调用对应的读取方法
*
* @Title: writeExcel
* @Date : 2014-9-11 下午01:50:38
* @param xlsPath
* @throws IOException
*/
public List<Row> readExcel(String xlsPath) throws IOException{
//扩展名为空时，
if (xlsPath.equals("")){
throw new IOException("文件路径不能为空！");
}else{
File file = new File(xlsPath);
if(!file.exists()){
throw new IOException("文件不存在！");
}
}
//获取扩展名
String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);
try {
if("xls".equals(ext)){ //使用xls方式读取
return readExcel_xls(xlsPath);
}else if("xlsx".equals(ext)){ //使用xlsx方式读取
return readExcel_xlsx(xlsPath);
}else{ //依次尝试xls、xlsx方式读取
out("您要操作的文件没有扩展名，正在尝试以xls方式读取...");
try{
return readExcel_xls(xlsPath);
} catch (IOException e1) {
out("尝试以xls方式读取，结果失败！，正在尝试以xlsx方式读取...");
try{
return readExcel_xlsx(xlsPath);
} catch (IOException e2) {
out("尝试以xls方式读取，结果失败！\n请您确保您的文件是Excel文件，并且无损，然后再试。");
throw e2;
}
}
}
} catch (IOException e) {
throw e;
}
}
/**
* 自动根据文件扩展名，调用对应的写入方法
*
* @Title: writeExcel
* @Date : 2014-9-11 下午01:50:38
* @param rowList
* @throws IOException
*/
public void writeExcel(List<Row> rowList) throws IOException{
writeExcel(rowList,excelPath);
}
/**
* 自动根据文件扩展名，调用对应的写入方法
*
* @Title: writeExcel
* @Date : 2014-9-11 下午01:50:38
* @param rowList
* @param xlsPath
* @throws IOException
*/
public void writeExcel(List<Row> rowList, String xlsPath) throws IOException {
//扩展名为空时，
if (xlsPath.equals("")){
throw new IOException("文件路径不能为空！");
}
//获取扩展名
String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);
try {
if("xls".equals(ext)){ //使用xls方式写入
writeExcel_xls(rowList,xlsPath);
}else if("xlsx".equals(ext)){ //使用xlsx方式写入
writeExcel_xlsx(rowList,xlsPath);
}else{ //依次尝试xls、xlsx方式写入
out("您要操作的文件没有扩展名，正在尝试以xls方式写入...");
try{
writeExcel_xls(rowList,xlsPath);
} catch (IOException e1) {
out("尝试以xls方式写入，结果失败！，正在尝试以xlsx方式读取...");
try{
writeExcel_xlsx(rowList,xlsPath);
} catch (IOException e2) {
out("尝试以xls方式写入，结果失败！\n请您确保您的文件是Excel文件，并且无损，然后再试。");
throw e2;
}
}
}
} catch (IOException e) {
throw e;
}
}
/**
* 修改Excel（97-03版，xls格式）
*
* @Title: writeExcel_xls
* @Date : 2014-9-11 下午01:50:38
* @param rowList
* @param dist_xlsPath
* @throws IOException
*/
public void writeExcel_xls(List<Row> rowList, String dist_xlsPath) throws IOException {
writeExcel_xls(rowList, excelPath,dist_xlsPath);
}
/**
* 修改Excel（97-03版，xls格式）
*
* @Title: writeExcel_xls
* @Date : 2014-9-11 下午01:50:38
* @param rowList
* @param src_xlsPath
* @param dist_xlsPath
* @throws IOException
*/
public void writeExcel_xls(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {
// 判断文件路径是否为空
if (dist_xlsPath == null || dist_xlsPath.equals("")) {
out("文件路径不能为空");
throw new IOException("文件路径不能为空");
}
// 判断文件路径是否为空
if (src_xlsPath == null || src_xlsPath.equals("")) {
out("文件路径不能为空");
throw new IOException("文件路径不能为空");
}
// 判断列表是否有数据，如果没有数据，则返回
if (rowList == null || rowList.size() == 0) {
out("文档为空");
return;
}
try {
HSSFWorkbook wb = null;
// 判断文件是否存在
File file = new File(dist_xlsPath);
if (file.exists()) {
// 如果复写，则删除后
if (isOverWrite) {
file.delete();
// 如果文件不存在，则创建一个新的Excel
// wb = new HSSFWorkbook();
// wb.createSheet("Sheet1");
wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
} else {
// 如果文件存在，则读取Excel
wb = new HSSFWorkbook(new FileInputStream(file));
}
} else {
// 如果文件不存在，则创建一个新的Excel
// wb = new HSSFWorkbook();
// wb.createSheet("Sheet1");
wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
}
// 将rowlist的内容写到Excel中
writeExcel(wb, rowList, dist_xlsPath);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* 修改Excel（97-03版，xls格式）
*
* @Title: writeExcel_xls
* @Date : 2014-9-11 下午01:50:38
* @param rowList
* @param dist_xlsPath
* @throws IOException
*/
public void writeExcel_xlsx(List<Row> rowList, String dist_xlsPath) throws IOException {
writeExcel_xls(rowList, excelPath , dist_xlsPath);
}
/**
* 修改Excel（2007版，xlsx格式）
*
* @Title: writeExcel_xlsx
* @Date : 2014-9-11 下午01:50:38
* @param rowList
* @param xlsPath
* @throws IOException
*/
public void writeExcel_xlsx(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {
// 判断文件路径是否为空
if (dist_xlsPath == null || dist_xlsPath.equals("")) {
out("文件路径不能为空");
throw new IOException("文件路径不能为空");
}
// 判断文件路径是否为空
if (src_xlsPath == null || src_xlsPath.equals("")) {
out("文件路径不能为空");
throw new IOException("文件路径不能为空");
}
// 判断列表是否有数据，如果没有数据，则返回
if (rowList == null || rowList.size() == 0) {
out("文档为空");
return;
}
try {
// 读取文档
XSSFWorkbook wb = null;
// 判断文件是否存在
File file = new File(dist_xlsPath);
if (file.exists()) {
// 如果复写，则删除后
if (isOverWrite) {
file.delete();
// 如果文件不存在，则创建一个新的Excel
// wb = new XSSFWorkbook();
// wb.createSheet("Sheet1");
wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
} else {
// 如果文件存在，则读取Excel
wb = new XSSFWorkbook(new FileInputStream(file));
}
} else {
// 如果文件不存在，则创建一个新的Excel
// wb = new XSSFWorkbook();
// wb.createSheet("Sheet1");
wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
}
// 将rowlist的内容添加到Excel中
writeExcel(wb, rowList, dist_xlsPath);
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* //读取Excel 2007版，xlsx格式
*
* @Title: readExcel_xlsx
* @Date : 2014-9-11 上午11:43:11
* @return
* @throws IOException
*/
public List<Row> readExcel_xlsx() throws IOException {
return readExcel_xlsx(excelPath);
}
/**
* //读取Excel 2007版，xlsx格式
*
* @Title: readExcel_xlsx
* @Date : 2014-9-11 上午11:43:11
* @return
* @throws Exception
*/
public List<Row> readExcel_xlsx(String xlsPath) throws IOException {
// 判断文件是否存在
File file = new File(xlsPath);
if (!file.exists()) {
throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");
}
XSSFWorkbook wb = null;
List<Row> rowList = new ArrayList<Row>();
try {
FileInputStream fis = new FileInputStream(file);
// 去读Excel
wb = new XSSFWorkbook(fis);
// 读取Excel 2007版，xlsx格式
rowList = readExcel(wb);
} catch (IOException e) {
e.printStackTrace();
}
return rowList;
}
/***
* 读取Excel(97-03版，xls格式)
*
* @throws IOException
*
* @Title: readExcel
* @Date : 2014-9-11 上午09:53:21
*/
public List<Row> readExcel_xls() throws IOException {
return readExcel_xls(excelPath);
}
/***
* 读取Excel(97-03版，xls格式)
*
* @throws Exception
*
* @Title: readExcel
* @Date : 2014-9-11 上午09:53:21
*/
public List<Row> readExcel_xls(String xlsPath) throws IOException {
// 判断文件是否存在
File file = new File(xlsPath);
if (!file.exists()) {
throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");
}
HSSFWorkbook wb = null;// 用于Workbook级的操作，创建、删除Excel
List<Row> rowList = new ArrayList<Row>();
try {
// 读取Excel
wb = new HSSFWorkbook(new FileInputStream(file));
// 读取Excel 97-03版，xls格式
rowList = readExcel(wb);
} catch (IOException e) {
e.printStackTrace();
}
return rowList;
}
/***
* 读取单元格的值
*
* @Title: getCellValue
* @Date : 2014-9-11 上午10:52:07
* @param cell
* @return
*/
private String getCellValue(Cell cell) {
Object result = "";
if (cell != null) {
switch (cell.getCellType()) {
case Cell.CELL_TYPE_STRING:
result = cell.getStringCellValue();
break;
case Cell.CELL_TYPE_NUMERIC:
result = cell.getNumericCellValue();
break;
case Cell.CELL_TYPE_BOOLEAN:
result = cell.getBooleanCellValue();
break;
case Cell.CELL_TYPE_FORMULA:
result = cell.getCellFormula();
break;
case Cell.CELL_TYPE_ERROR:
result = cell.getErrorCellValue();
break;
case Cell.CELL_TYPE_BLANK:
break;
default:
break;
}
}
return result.toString();
}
/**
* 通用读取Excel
*
* @Title: readExcel
* @Date : 2014-9-11 上午11:26:53
* @param wb
* @return
*/
private List<Row> readExcel(Workbook wb) {
List<Row> rowList = new ArrayList<Row>();
int sheetCount = 1;//需要操作的sheet数量
Sheet sheet = null;
if(onlyReadOneSheet){ //只操作一个sheet
// 获取设定操作的sheet(如果设定了名称，按名称查，否则按索引值查)
sheet =selectedSheetName.equals("")? wb.getSheetAt(selectedSheetIdx):wb.getSheet(selectedSheetName);
}else{ //操作多个sheet
sheetCount = wb.getNumberOfSheets();//获取可以操作的总数量
}
// 获取sheet数目
for(int t=startSheetIdx; t<sheetCount+endSheetIdx;t++){
// 获取设定操作的sheet
if(!onlyReadOneSheet) {
sheet =wb.getSheetAt(t);
}
//获取最后行号
int lastRowNum = sheet.getLastRowNum();
if(lastRowNum>0){ //如果>0，表示有数据
out("\n开始读取名为【"+sheet.getSheetName()+"】的内容：");
}
Row row = null;
// 循环读取
for (int i = startReadPos; i <= lastRowNum + endReadPos; i++) {
row = sheet.getRow(i);
if (row != null) {
rowList.add(row);
out("第"+(i+1)+"行：",false);
// 获取每一单元格的值
for (int j = 0; j < row.getLastCellNum(); j++) {
String value = getCellValue(row.getCell(j));
if (!value.equals("")) {
out(value + " | ",false);
}
}
out("");
}
}
}
return rowList;
}
/**
* 修改Excel，并另存为
*
* @Title: WriteExcel
* @Date : 2014-9-11 下午01:33:59
* @param wb
* @param rowList
* @param xlsPath
*/
private void writeExcel(Workbook wb, List<Row> rowList, String xlsPath) {
if (wb == null) {
out("操作文档不能为空！");
return;
}
Sheet sheet = wb.getSheetAt(0);// 修改第一个sheet中的值
// 如果每次重写，那么则从开始读取的位置写，否则果获取源文件最新的行。
int lastRowNum = isOverWrite ? startReadPos : sheet.getLastRowNum() + 1;
int t = 0;//记录最新添加的行数
out("要添加的数据总条数为："+rowList.size());
for (Row row : rowList) {
if (row == null) continue;
// 判断是否已经存在该数据
int pos = findInExcel(sheet, row);
Row r = null;// 如果数据行已经存在，则获取后重写，否则自动创建新行。
if (pos >= 0) {
sheet.removeRow(sheet.getRow(pos));
r = sheet.createRow(pos);
} else {
r = sheet.createRow(lastRowNum + t++);
}
//用于设定单元格样式
CellStyle newstyle = wb.createCellStyle();
//循环为新行创建单元格
for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {
Cell cell = r.createCell(i);// 获取数据类型
cell.setCellValue(getCellValue(row.getCell(i)));// 复制单元格的值到新的单元格
// cell.setCellStyle(row.getCell(i).getCellStyle());//出错
if (row.getCell(i) == null) continue;
copyCellStyle(row.getCell(i).getCellStyle(), newstyle); // 获取原来的单元格样式
cell.setCellStyle(newstyle);// 设置样式
// sheet.autoSizeColumn(i);//自动跳转列宽度
}
}
out("其中检测到重复条数为:" + (rowList.size() - t) + " ，追加条数为："+t);
// 统一设定合并单元格
setMergedRegion(sheet);
try {
// 重新将数据写入Excel中
FileOutputStream outputStream = new FileOutputStream(xlsPath);
wb.write(outputStream);
outputStream.flush();
outputStream.close();
} catch (Exception e) {
out("写入Excel时发生错误！ ");
e.printStackTrace();
}
}
/**
* 查找某行数据是否在Excel表中存在，返回行数。
*
* @Title: findInExcel
* @Date : 2014-9-11 下午02:23:12
* @param sheet
* @param row
* @return
*/
private int findInExcel(Sheet sheet, Row row) {
int pos = -1;
try {
// 如果覆写目标文件，或者不需要比较，则直接返回
if (isOverWrite || !isNeedCompare) {
return pos;
}
for (int i = startReadPos; i <= sheet.getLastRowNum() + endReadPos; i++) {
Row r = sheet.getRow(i);
if (r != null && row != null) {
String v1 = getCellValue(r.getCell(comparePos));
String v2 = getCellValue(row.getCell(comparePos));
if (v1.equals(v2)) {
pos = i;
break;
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return pos;
}
/**
* 复制一个单元格样式到目的单元格样式
*
* @param fromStyle
* @param toStyle
*/
public static void copyCellStyle(CellStyle fromStyle, CellStyle toStyle) {
toStyle.setAlignment(fromStyle.getAlignment());
// 边框和边框颜色
toStyle.setBorderBottom(fromStyle.getBorderBottom());
toStyle.setBorderLeft(fromStyle.getBorderLeft());
toStyle.setBorderRight(fromStyle.getBorderRight());
toStyle.setBorderTop(fromStyle.getBorderTop());
toStyle.setTopBorderColor(fromStyle.getTopBorderColor());
toStyle.setBottomBorderColor(fromStyle.getBottomBorderColor());
toStyle.setRightBorderColor(fromStyle.getRightBorderColor());
toStyle.setLeftBorderColor(fromStyle.getLeftBorderColor());
// 背景和前景
toStyle.setFillBackgroundColor(fromStyle.getFillBackgroundColor());
toStyle.setFillForegroundColor(fromStyle.getFillForegroundColor());
// 数据格式
toStyle.setDataFormat(fromStyle.getDataFormat());
toStyle.setFillPattern(fromStyle.getFillPattern());
// toStyle.setFont(fromStyle.getFont(null));
toStyle.setHidden(fromStyle.getHidden());
toStyle.setIndention(fromStyle.getIndention());// 首行缩进
toStyle.setLocked(fromStyle.getLocked());
toStyle.setRotation(fromStyle.getRotation());// 旋转
toStyle.setVerticalAlignment(fromStyle.getVerticalAlignment());
toStyle.setWrapText(fromStyle.getWrapText());
}
/**
* 获取合并单元格的值
*
* @param sheet
* @param row
* @param column
* @return
*/
public void setMergedRegion(Sheet sheet) {
int sheetMergeCount = sheet.getNumMergedRegions();
for (int i = 0; i < sheetMergeCount; i++) {
// 获取合并单元格位置
CellRangeAddress ca = sheet.getMergedRegion(i);
int firstRow = ca.getFirstRow();
if (startReadPos - 1 > firstRow) {// 如果第一个合并单元格格式在正式数据的上面，则跳过。
continue;
}
int lastRow = ca.getLastRow();
int mergeRows = lastRow - firstRow;// 合并的行数
int firstColumn = ca.getFirstColumn();
int lastColumn = ca.getLastColumn();
// 根据合并的单元格位置和大小，调整所有的数据行格式，
for (int j = lastRow + 1; j <= sheet.getLastRowNum(); j++) {
// 设定合并单元格
sheet.addMergedRegion(new CellRangeAddress(j, j + mergeRows, firstColumn, lastColumn));
j = j + mergeRows;// 跳过已合并的行
}
}
}
/**
* 打印消息，
* @param msg 消息内容
* @param tr 换行
*/
private void out(String msg){
if(printMsg){
out(msg,true);
}
}
/**
* 打印消息，
* @param msg 消息内容
* @param tr 换行
*/
private void out(String msg,boolean tr){
if(printMsg){
System.out.print(msg+(tr?"\n":""));
}
}
public String getExcelPath() {
return this.excelPath;
}
public void setExcelPath(String excelPath) {
this.excelPath = excelPath;
}
public boolean isNeedCompare() {
return isNeedCompare;
}
public void setNeedCompare(boolean isNeedCompare) {
this.isNeedCompare = isNeedCompare;
}
public int getComparePos() {
return comparePos;
}
public void setComparePos(int comparePos) {
this.comparePos = comparePos;
}
public int getStartReadPos() {
return startReadPos;
}
public void setStartReadPos(int startReadPos) {
this.startReadPos = startReadPos;
}
public int getEndReadPos() {
return endReadPos;
}
public void setEndReadPos(int endReadPos) {
this.endReadPos = endReadPos;
}
public boolean isOverWrite() {
return isOverWrite;
}
public void setOverWrite(boolean isOverWrite) {
this.isOverWrite = isOverWrite;
}
public boolean isOnlyReadOneSheet() {
return onlyReadOneSheet;
}
public void setOnlyReadOneSheet(boolean onlyReadOneSheet) {
this.onlyReadOneSheet = onlyReadOneSheet;
}
public int getSelectedSheetIdx() {
return selectedSheetIdx;
}
public void setSelectedSheetIdx(int selectedSheetIdx) {
this.selectedSheetIdx = selectedSheetIdx;
}
public String getSelectedSheetName() {
return selectedSheetName;
}
public void setSelectedSheetName(String selectedSheetName) {
this.selectedSheetName = selectedSheetName;
}
public int getStartSheetIdx() {
return startSheetIdx;
}
public void setStartSheetIdx(int startSheetIdx) {
this.startSheetIdx = startSheetIdx;
}
public int getEndSheetIdx() {
return endSheetIdx;
}
public void setEndSheetIdx(int endSheetIdx) {
this.endSheetIdx = endSheetIdx;
}
public boolean isPrintMsg() {
return printMsg;
}
public void setPrintMsg(boolean printMsg) {
this.printMsg = printMsg;
}
}

package com.tgb.ccl.excel.util;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import org.apache.poi.ss.usermodel.Cell;

import org.apache.poi.ss.usermodel.CellStyle;

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.XSSFWorkbook;

/**

 * Excel文件操作工具类，包括读、写、合并等功能

 *

 * @author  : 龙轩

 * @group   : tgb8

 * @Version : 1.00

 * @Date    : 2014-10-29 上午12:40:44

 */

public class ExcelUtil {

	//%%%%%%%%-------常量部分 开始----------%%%%%%%%%

	/**

	 * 默认的开始读取的行位置为第一行（索引值为0）

	 */

	private final static int READ_START_POS = 0;

	/**

	 * 默认结束读取的行位置为最后一行（索引值=0，用负数来表示倒数第n行）

	 */

	private final static int READ_END_POS = 0;

	/**

	 * 默认Excel内容的开始比较列位置为第一列（索引值为0）

	 */

	private final static int COMPARE_POS = 0;

	/**

	 * 默认多文件合并的时需要做内容比较（相同的内容不重复出现）

	 */

	private final static boolean NEED_COMPARE = true;

	/**

	 * 默认多文件合并的新文件遇到名称重复时，进行覆盖

	 */

	private final static boolean NEED_OVERWRITE = true;

	/**

	 * 默认只操作一个sheet

	 */

	private final static boolean ONLY_ONE_SHEET = true;

	/**

	 * 默认读取第一个sheet中（只有当ONLY_ONE_SHEET = true时有效）

	 */

	private final static int SELECTED_SHEET = 0;

	/**

	 * 默认从第一个sheet开始读取（索引值为0）

	 */

	private final static int READ_START_SHEET= 0;

	/**

	 * 默认在最后一个sheet结束读取（索引值=0，用负数来表示倒数第n行）

	 */

	private final static int READ_END_SHEET = 0;

	/**

	 * 默认打印各种信息

	 */

	private final static boolean PRINT_MSG = true;

	//%%%%%%%%-------常量部分 结束----------%%%%%%%%%

	//%%%%%%%%-------字段部分 开始----------%%%%%%%%%

	/**

	 * Excel文件路径

	 */

	private String excelPath = "data.xlsx";

	/**

	 * 设定开始读取的位置，默认为0

	 */

	private int startReadPos = READ_START_POS;

	/**

	 * 设定结束读取的位置，默认为0，用负数来表示倒数第n行

	 */

	private int endReadPos = READ_END_POS;

	/**

	 * 设定开始比较的列位置，默认为0

	 */

	private int comparePos = COMPARE_POS;

	/**

	 *  设定汇总的文件是否需要替换，默认为true

	 */

	private boolean isOverWrite = NEED_OVERWRITE;

	/**

	 *  设定是否需要比较，默认为true(仅当不覆写目标内容是有效，即isOverWrite=false时有效)

	 */

	private boolean isNeedCompare = NEED_COMPARE;

	/**

	 * 设定是否只操作第一个sheet

	 */

	private boolean onlyReadOneSheet = ONLY_ONE_SHEET;

	/**

	 * 设定操作的sheet在索引值

	 */

	private int selectedSheetIdx =SELECTED_SHEET;

	/**

	 * 设定操作的sheet的名称

	 */

	private String selectedSheetName = "";

	/**

	 * 设定开始读取的sheet，默认为0

	 */

	private int startSheetIdx = READ_START_SHEET;

	/**

	 * 设定结束读取的sheet，默认为0，用负数来表示倒数第n行

	 */

	private int endSheetIdx = READ_END_SHEET;

	/**

	 * 设定是否打印消息

	 */

	private boolean printMsg = PRINT_MSG;

	//%%%%%%%%-------字段部分 结束----------%%%%%%%%%

	public static void main(String[] args) {

		ExcelUtil eu = new ExcelUtil();

		//从第一行开始读取

		eu.setStartReadPos(1);

		String src_xlspath = "D:\\2.xls";

		String dist_xlsPath = "D:\\1.xls";

		List<Row> rowList;

		try {

			rowList = eu.readExcel(src_xlspath);

			//eu.writeExcel_xls(rowList, src_xlspath, dist_xlsPath);

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	public ExcelUtil(){

	}

	public ExcelUtil(String excelPath){

		this.excelPath = excelPath;

	}

	/**

	 * 还原设定（其实是重新new一个新的对象并返回）

	 * @return

	 */

	public ExcelUtil RestoreSettings(){

		ExcelUtil instance = new  ExcelUtil(this.excelPath);

		return instance;

	}

	/**

	 * 自动根据文件扩展名，调用对应的读取方法

	 *

	 * @Title: writeExcel

	 * @Date : 2014-9-11 下午01:50:38

	 * @param xlsPath

	 * @throws IOException

	 */

	public List<Row> readExcel() throws IOException{

		return readExcel(this.excelPath);

	}

	/**

	 * 自动根据文件扩展名，调用对应的读取方法

	 *

	 * @Title: writeExcel

	 * @Date : 2014-9-11 下午01:50:38

	 * @param xlsPath

	 * @throws IOException

	 */

	public List<Row> readExcel(String xlsPath) throws IOException{

		//扩展名为空时，

		if (xlsPath.equals("")){

			throw new IOException("文件路径不能为空！");

		}else{

			File file = new File(xlsPath);

			if(!file.exists()){

				throw new IOException("文件不存在！");

			}

		}

		//获取扩展名

		String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);

		try {

			if("xls".equals(ext)){				//使用xls方式读取

				return readExcel_xls(xlsPath);

			}else if("xlsx".equals(ext)){		//使用xlsx方式读取

				return readExcel_xlsx(xlsPath);

			}else{									//依次尝试xls、xlsx方式读取

				out("您要操作的文件没有扩展名，正在尝试以xls方式读取...");

				try{

					return readExcel_xls(xlsPath);

				} catch (IOException e1) {

					out("尝试以xls方式读取，结果失败！，正在尝试以xlsx方式读取...");

					try{

						return readExcel_xlsx(xlsPath);

					} catch (IOException e2) {

						out("尝试以xls方式读取，结果失败！\n请您确保您的文件是Excel文件，并且无损，然后再试。");

						throw e2;

					}

				}

			}

		} catch (IOException e) {

			throw e;

		}

	}

	/**

	 * 自动根据文件扩展名，调用对应的写入方法

	 *

	 * @Title: writeExcel

	 * @Date : 2014-9-11 下午01:50:38

	 * @param rowList

	 * @throws IOException

	 */

	public void writeExcel(List<Row> rowList) throws IOException{

		writeExcel(rowList,excelPath);

	}

	/**

	 * 自动根据文件扩展名，调用对应的写入方法

	 *

	 * @Title: writeExcel

	 * @Date : 2014-9-11 下午01:50:38

	 * @param rowList

	 * @param xlsPath

	 * @throws IOException

	 */

	public void writeExcel(List<Row> rowList, String xlsPath) throws IOException {

		//扩展名为空时，

		if (xlsPath.equals("")){

			throw new IOException("文件路径不能为空！");

		}

		//获取扩展名

		String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);

		try {

			if("xls".equals(ext)){				//使用xls方式写入

				writeExcel_xls(rowList,xlsPath);

			}else if("xlsx".equals(ext)){		//使用xlsx方式写入

				writeExcel_xlsx(rowList,xlsPath);

			}else{									//依次尝试xls、xlsx方式写入

				out("您要操作的文件没有扩展名，正在尝试以xls方式写入...");

				try{

					writeExcel_xls(rowList,xlsPath);

				} catch (IOException e1) {

					out("尝试以xls方式写入，结果失败！，正在尝试以xlsx方式读取...");

					try{

						writeExcel_xlsx(rowList,xlsPath);

					} catch (IOException e2) {

						out("尝试以xls方式写入，结果失败！\n请您确保您的文件是Excel文件，并且无损，然后再试。");

						throw e2;

					}

				}

			}

		} catch (IOException e) {

			throw e;

		}

	}

	/**

	 * 修改Excel（97-03版，xls格式）

	 *

	 * @Title: writeExcel_xls

	 * @Date : 2014-9-11 下午01:50:38

	 * @param rowList

	 * @param dist_xlsPath

	 * @throws IOException

	 */

	public void writeExcel_xls(List<Row> rowList, String dist_xlsPath) throws IOException {

		writeExcel_xls(rowList, excelPath,dist_xlsPath);

	}

	/**

	 * 修改Excel（97-03版，xls格式）

	 *

	 * @Title: writeExcel_xls

	 * @Date : 2014-9-11 下午01:50:38

	 * @param rowList

	 * @param src_xlsPath

	 * @param dist_xlsPath

	 * @throws IOException

	 */

	public void writeExcel_xls(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {

		// 判断文件路径是否为空

		if (dist_xlsPath == null || dist_xlsPath.equals("")) {

			out("文件路径不能为空");

			throw new IOException("文件路径不能为空");

		}

		// 判断文件路径是否为空

		if (src_xlsPath == null || src_xlsPath.equals("")) {

			out("文件路径不能为空");

			throw new IOException("文件路径不能为空");

		}

		// 判断列表是否有数据，如果没有数据，则返回

		if (rowList == null || rowList.size() == 0) {

			out("文档为空");

			return;

		}

		try {

			HSSFWorkbook wb = null;

			// 判断文件是否存在

			File file = new File(dist_xlsPath);

			if (file.exists()) {

				// 如果复写，则删除后

				if (isOverWrite) {

					file.delete();

					// 如果文件不存在，则创建一个新的Excel

					// wb = new HSSFWorkbook();

					// wb.createSheet("Sheet1");

					wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));

				} else {

					// 如果文件存在，则读取Excel

					wb = new HSSFWorkbook(new FileInputStream(file));

				}

			} else {

				// 如果文件不存在，则创建一个新的Excel

				// wb = new HSSFWorkbook();

				// wb.createSheet("Sheet1");

				wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));

			}

			// 将rowlist的内容写到Excel中

			writeExcel(wb, rowList, dist_xlsPath);

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	/**

	 * 修改Excel（97-03版，xls格式）

	 *

	 * @Title: writeExcel_xls

	 * @Date : 2014-9-11 下午01:50:38

	 * @param rowList

	 * @param dist_xlsPath

	 * @throws IOException

	 */

	public void writeExcel_xlsx(List<Row> rowList, String dist_xlsPath) throws IOException {

		writeExcel_xls(rowList, excelPath , dist_xlsPath);

	}

	/**

	 * 修改Excel（2007版，xlsx格式）

	 *

	 * @Title: writeExcel_xlsx

	 * @Date : 2014-9-11 下午01:50:38

	 * @param rowList

	 * @param xlsPath

	 * @throws IOException

	 */

	public void writeExcel_xlsx(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {

		// 判断文件路径是否为空

		if (dist_xlsPath == null || dist_xlsPath.equals("")) {

			out("文件路径不能为空");

			throw new IOException("文件路径不能为空");

		}

		// 判断文件路径是否为空

		if (src_xlsPath == null || src_xlsPath.equals("")) {

			out("文件路径不能为空");

			throw new IOException("文件路径不能为空");

		}

		// 判断列表是否有数据，如果没有数据，则返回

		if (rowList == null || rowList.size() == 0) {

			out("文档为空");

			return;

		}

		try {

			// 读取文档

			XSSFWorkbook wb = null;

			// 判断文件是否存在

			File file = new File(dist_xlsPath);

			if (file.exists()) {

				// 如果复写，则删除后

				if (isOverWrite) {

					file.delete();

					// 如果文件不存在，则创建一个新的Excel

					// wb = new XSSFWorkbook();

					// wb.createSheet("Sheet1");

					wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));

				} else {

					// 如果文件存在，则读取Excel

					wb = new XSSFWorkbook(new FileInputStream(file));

				}

			} else {

				// 如果文件不存在，则创建一个新的Excel

				// wb = new XSSFWorkbook();

				// wb.createSheet("Sheet1");

				wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));

			}

			// 将rowlist的内容添加到Excel中

			writeExcel(wb, rowList, dist_xlsPath);

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	/**

	 * //读取Excel 2007版，xlsx格式

	 *

	 * @Title: readExcel_xlsx

	 * @Date : 2014-9-11 上午11:43:11

	 * @return

	 * @throws IOException

	 */

	public List<Row> readExcel_xlsx() throws IOException {

		return readExcel_xlsx(excelPath);

	}

	/**

	 * //读取Excel 2007版，xlsx格式

	 *

	 * @Title: readExcel_xlsx

	 * @Date : 2014-9-11 上午11:43:11

	 * @return

	 * @throws Exception

	 */

	public List<Row> readExcel_xlsx(String xlsPath) throws IOException {

		// 判断文件是否存在

		File file = new File(xlsPath);

		if (!file.exists()) {

			throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");

		}

		XSSFWorkbook wb = null;

		List<Row> rowList = new ArrayList<Row>();

		try {

			FileInputStream fis = new FileInputStream(file);

			// 去读Excel

			wb = new XSSFWorkbook(fis);

			// 读取Excel 2007版，xlsx格式

			rowList = readExcel(wb);

		} catch (IOException e) {

			e.printStackTrace();

		}

		return rowList;

	}

	/***

	 * 读取Excel(97-03版，xls格式)

	 *

	 * @throws IOException

	 *

	 * @Title: readExcel

	 * @Date : 2014-9-11 上午09:53:21

	 */

	public List<Row> readExcel_xls() throws IOException {

		return readExcel_xls(excelPath);

	}

	/***

	 * 读取Excel(97-03版，xls格式)

	 *

	 * @throws Exception

	 *

	 * @Title: readExcel

	 * @Date : 2014-9-11 上午09:53:21

	 */

	public List<Row> readExcel_xls(String xlsPath) throws IOException {

		// 判断文件是否存在

		File file = new File(xlsPath);

		if (!file.exists()) {

			throw new IOException("文件名为" + file.getName() + "Excel文件不存在！");

		}

		HSSFWorkbook wb = null;// 用于Workbook级的操作，创建、删除Excel

		List<Row> rowList = new ArrayList<Row>();

		try {

			// 读取Excel

			wb = new HSSFWorkbook(new FileInputStream(file));

			// 读取Excel 97-03版，xls格式

			rowList = readExcel(wb);

		} catch (IOException e) {

			e.printStackTrace();

		}

		return rowList;

	}

	/***

	 * 读取单元格的值

	 *

	 * @Title: getCellValue

	 * @Date : 2014-9-11 上午10:52:07

	 * @param cell

	 * @return

	 */

	private String getCellValue(Cell cell) {

		Object result = "";

		if (cell != null) {

			switch (cell.getCellType()) {

			case Cell.CELL_TYPE_STRING:

				result = cell.getStringCellValue();

				break;

			case Cell.CELL_TYPE_NUMERIC:

				result = cell.getNumericCellValue();

				break;

			case Cell.CELL_TYPE_BOOLEAN:

				result = cell.getBooleanCellValue();

				break;

			case Cell.CELL_TYPE_FORMULA:

				result = cell.getCellFormula();

				break;

			case Cell.CELL_TYPE_ERROR:

				result = cell.getErrorCellValue();

				break;

			case Cell.CELL_TYPE_BLANK:

				break;

			default:

				break;

			}

		}

		return result.toString();

	}

	/**

	 * 通用读取Excel

	 *

	 * @Title: readExcel

	 * @Date : 2014-9-11 上午11:26:53

	 * @param wb

	 * @return

	 */

	private List<Row> readExcel(Workbook wb) {

		List<Row> rowList = new ArrayList<Row>();

		int sheetCount = 1;//需要操作的sheet数量

		Sheet sheet = null;

		if(onlyReadOneSheet){	//只操作一个sheet

			// 获取设定操作的sheet(如果设定了名称，按名称查，否则按索引值查)

			sheet =selectedSheetName.equals("")? wb.getSheetAt(selectedSheetIdx):wb.getSheet(selectedSheetName);

		}else{							//操作多个sheet

			sheetCount = wb.getNumberOfSheets();//获取可以操作的总数量

		}

		// 获取sheet数目

		for(int t=startSheetIdx; t<sheetCount+endSheetIdx;t++){

			// 获取设定操作的sheet

			if(!onlyReadOneSheet) {

				sheet =wb.getSheetAt(t);

			}

			//获取最后行号

			int lastRowNum = sheet.getLastRowNum();

			if(lastRowNum>0){	//如果>0，表示有数据

				out("\n开始读取名为【"+sheet.getSheetName()+"】的内容：");

			}

			Row row = null;

			// 循环读取

			for (int i = startReadPos; i <= lastRowNum + endReadPos; i++) {

				row = sheet.getRow(i);

				if (row != null) {

					rowList.add(row);

					out("第"+(i+1)+"行：",false);

					 // 获取每一单元格的值

					 for (int j = 0; j < row.getLastCellNum(); j++) {

						 String value = getCellValue(row.getCell(j));

						 if (!value.equals("")) {

							 out(value + " | ",false);

						 }

					 }

					 out("");

				}

			}

		}

		return rowList;

	}

	/**

	 * 修改Excel，并另存为

	 *

	 * @Title: WriteExcel

	 * @Date : 2014-9-11 下午01:33:59

	 * @param wb

	 * @param rowList

	 * @param xlsPath

	 */

	private void writeExcel(Workbook wb, List<Row> rowList, String xlsPath) {

		if (wb == null) {

			out("操作文档不能为空！");

			return;

		}

		Sheet sheet = wb.getSheetAt(0);// 修改第一个sheet中的值

		// 如果每次重写，那么则从开始读取的位置写，否则果获取源文件最新的行。

		int lastRowNum = isOverWrite ? startReadPos : sheet.getLastRowNum() + 1;

		int t = 0;//记录最新添加的行数

		out("要添加的数据总条数为："+rowList.size());

		for (Row row : rowList) {

			if (row == null) continue;

			// 判断是否已经存在该数据

			int pos = findInExcel(sheet, row);

			Row r = null;// 如果数据行已经存在，则获取后重写，否则自动创建新行。

			if (pos >= 0) {

				sheet.removeRow(sheet.getRow(pos));

				r = sheet.createRow(pos);

			} else {

				r = sheet.createRow(lastRowNum + t++);

			}

			//用于设定单元格样式

			CellStyle newstyle = wb.createCellStyle();

			//循环为新行创建单元格

			for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {

				Cell cell = r.createCell(i);// 获取数据类型

				cell.setCellValue(getCellValue(row.getCell(i)));// 复制单元格的值到新的单元格

				// cell.setCellStyle(row.getCell(i).getCellStyle());//出错

				if (row.getCell(i) == null) continue;

				copyCellStyle(row.getCell(i).getCellStyle(), newstyle); // 获取原来的单元格样式

				cell.setCellStyle(newstyle);// 设置样式

				// sheet.autoSizeColumn(i);//自动跳转列宽度

			}

		}

		out("其中检测到重复条数为:" + (rowList.size() - t) + " ，追加条数为："+t);

		// 统一设定合并单元格

		setMergedRegion(sheet);

		try {

			// 重新将数据写入Excel中

			FileOutputStream outputStream = new FileOutputStream(xlsPath);

			wb.write(outputStream);

			outputStream.flush();

			outputStream.close();

		} catch (Exception e) {

			out("写入Excel时发生错误！ ");

			e.printStackTrace();

		}

	}

	/**

	 * 查找某行数据是否在Excel表中存在，返回行数。

	 *

	 * @Title: findInExcel

	 * @Date : 2014-9-11 下午02:23:12

	 * @param sheet

	 * @param row

	 * @return

	 */

	private int findInExcel(Sheet sheet, Row row) {

		int pos = -1;

		try {

			// 如果覆写目标文件，或者不需要比较，则直接返回

			if (isOverWrite || !isNeedCompare) {

				return pos;

			}

			for (int i = startReadPos; i <= sheet.getLastRowNum() + endReadPos; i++) {

				Row r = sheet.getRow(i);

				if (r != null && row != null) {

					String v1 = getCellValue(r.getCell(comparePos));

					String v2 = getCellValue(row.getCell(comparePos));

					if (v1.equals(v2)) {

						pos = i;

						break;

					}

				}

			}

		} catch (Exception e) {

			e.printStackTrace();

		}

		return pos;

	}

	/**

	 * 复制一个单元格样式到目的单元格样式

	 *

	 * @param fromStyle

	 * @param toStyle

	 */

	public static void copyCellStyle(CellStyle fromStyle, CellStyle toStyle) {

		toStyle.setAlignment(fromStyle.getAlignment());

		// 边框和边框颜色

		toStyle.setBorderBottom(fromStyle.getBorderBottom());

		toStyle.setBorderLeft(fromStyle.getBorderLeft());

		toStyle.setBorderRight(fromStyle.getBorderRight());

		toStyle.setBorderTop(fromStyle.getBorderTop());

		toStyle.setTopBorderColor(fromStyle.getTopBorderColor());

		toStyle.setBottomBorderColor(fromStyle.getBottomBorderColor());

		toStyle.setRightBorderColor(fromStyle.getRightBorderColor());

		toStyle.setLeftBorderColor(fromStyle.getLeftBorderColor());

		// 背景和前景

		toStyle.setFillBackgroundColor(fromStyle.getFillBackgroundColor());

		toStyle.setFillForegroundColor(fromStyle.getFillForegroundColor());

		// 数据格式

		toStyle.setDataFormat(fromStyle.getDataFormat());

		toStyle.setFillPattern(fromStyle.getFillPattern());

		// toStyle.setFont(fromStyle.getFont(null));

		toStyle.setHidden(fromStyle.getHidden());

		toStyle.setIndention(fromStyle.getIndention());// 首行缩进

		toStyle.setLocked(fromStyle.getLocked());

		toStyle.setRotation(fromStyle.getRotation());// 旋转

		toStyle.setVerticalAlignment(fromStyle.getVerticalAlignment());

		toStyle.setWrapText(fromStyle.getWrapText());

	}

	/**

	 * 获取合并单元格的值

	 *

	 * @param sheet

	 * @param row

	 * @param column

	 * @return

	 */

	public void setMergedRegion(Sheet sheet) {

		int sheetMergeCount = sheet.getNumMergedRegions();

		for (int i = 0; i < sheetMergeCount; i++) {

			// 获取合并单元格位置

			CellRangeAddress ca = sheet.getMergedRegion(i);

			int firstRow = ca.getFirstRow();

			if (startReadPos - 1 > firstRow) {// 如果第一个合并单元格格式在正式数据的上面，则跳过。

				continue;

			}

			int lastRow = ca.getLastRow();

			int mergeRows = lastRow - firstRow;// 合并的行数

			int firstColumn = ca.getFirstColumn();

			int lastColumn = ca.getLastColumn();

			// 根据合并的单元格位置和大小，调整所有的数据行格式，

			for (int j = lastRow + 1; j <= sheet.getLastRowNum(); j++) {

				// 设定合并单元格

				sheet.addMergedRegion(new CellRangeAddress(j, j + mergeRows, firstColumn, lastColumn));

				j = j + mergeRows;// 跳过已合并的行

			}

		}

	}

	/**

	 * 打印消息，

	 * @param msg 消息内容

	 * @param tr 换行

	 */

	private void out(String msg){

		if(printMsg){

			out(msg,true);

		}

	}

	/**

	 * 打印消息，

	 * @param msg 消息内容

	 * @param tr 换行

	 */

	private void out(String msg,boolean tr){

		if(printMsg){

			System.out.print(msg+(tr?"\n":""));

		}

	}

	public String getExcelPath() {

		return this.excelPath;

	}

	public void setExcelPath(String excelPath) {

		this.excelPath = excelPath;

	}

	public boolean isNeedCompare() {

		return isNeedCompare;

	}

	public void setNeedCompare(boolean isNeedCompare) {

		this.isNeedCompare = isNeedCompare;

	}

	public int getComparePos() {

		return comparePos;

	}

	public void setComparePos(int comparePos) {

		this.comparePos = comparePos;

	}

	public int getStartReadPos() {

		return startReadPos;

	}

	public void setStartReadPos(int startReadPos) {

		this.startReadPos = startReadPos;

	}

	public int getEndReadPos() {

		return endReadPos;

	}

	public void setEndReadPos(int endReadPos) {

		this.endReadPos = endReadPos;

	}

	public boolean isOverWrite() {

		return isOverWrite;

	}

	public void setOverWrite(boolean isOverWrite) {

		this.isOverWrite = isOverWrite;

	}

	public boolean isOnlyReadOneSheet() {

		return onlyReadOneSheet;

	}

	public void setOnlyReadOneSheet(boolean onlyReadOneSheet) {

		this.onlyReadOneSheet = onlyReadOneSheet;

	}

	public int getSelectedSheetIdx() {

		return selectedSheetIdx;

	}

	public void setSelectedSheetIdx(int selectedSheetIdx) {

		this.selectedSheetIdx = selectedSheetIdx;

	}

	public String getSelectedSheetName() {

		return selectedSheetName;

	}

	public void setSelectedSheetName(String selectedSheetName) {

		this.selectedSheetName = selectedSheetName;

	}

	public int getStartSheetIdx() {

		return startSheetIdx;

	}

	public void setStartSheetIdx(int startSheetIdx) {

		this.startSheetIdx = startSheetIdx;

	}

	public int getEndSheetIdx() {

		return endSheetIdx;

	}

	public void setEndSheetIdx(int endSheetIdx) {

		this.endSheetIdx = endSheetIdx;

	}

	public boolean isPrintMsg() {

		return printMsg;

	}

	public void setPrintMsg(boolean printMsg) {

		this.printMsg = printMsg;

	}

}

以上就是工具类的全部代码，现在演示一下读取的功能：

public void testRead() {
try {
ExcelUtil eu = new ExcelUtil();
eu.setExcelPath("d:\\2.xls");
System.out.println("=======测试Excel 默认读取========");
eu.readExcel();
System.out.println("\n=======测试Excel 从第四行读取，倒数第二行结束========");
eu = eu.RestoreSettings();//还原设定
eu.setStartReadPos(3);
eu.setEndReadPos(-1);
eu.readExcel();
System.out.println("\n=======测试Excel 读取第二个sheet========");
eu = eu.RestoreSettings();//还原设定
eu.setSelectedSheetIdx(1);
eu.readExcel();
System.out.println("\n=======测试Excel 读取所有的sheet========");
eu = eu.RestoreSettings();//还原设定
eu.setOnlyReadOneSheet(false);
eu.readExcel();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

	public void testRead() {

		try {

			ExcelUtil eu = new ExcelUtil();

			eu.setExcelPath("d:\\2.xls");

			System.out.println("=======测试Excel 默认 读取========");

			eu.readExcel();

			System.out.println("\n=======测试Excel 从第四行读取，倒数第二行结束========");

			eu = eu.RestoreSettings();//还原设定

			eu.setStartReadPos(3);

			eu.setEndReadPos(-1);

			eu.readExcel();

			System.out.println("\n=======测试Excel 读取第二个sheet========");

			eu = eu.RestoreSettings();//还原设定

			eu.setSelectedSheetIdx(1);

			eu.readExcel();

			System.out.println("\n=======测试Excel 读取所有的sheet========");

			eu = eu.RestoreSettings();//还原设定

			eu.setOnlyReadOneSheet(false);

			eu.readExcel();

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

操作的Excel文件内容如下：

执行结果如下：

上面代码的提示和结果已经解释的很清楚了，我就不在这里过多介绍。

现在演示多个Excel的汇总合并功能，把上面的Excel内容合并到另一个Excel表中，这个Excel内容如下：

测试代码如下：

public void testMerge(){
try {
ExcelUtil eu1 = new ExcelUtil();//用来读取源xls
ExcelUtil eu2 = new ExcelUtil();//用来读取目标xls，用于演示合并结果
eu1.setExcelPath("d:\\2.xls");
eu2.setExcelPath("d:\\1.xls");
System.out.println("\n=======修改前，1.xls中的内容========");
eu2.readExcel();
System.out.println("\n=======读取源文件2.xls中的内容========");
eu1.setStartReadPos(3);
//eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
//eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
//eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。
eu1.writeExcel(eu1.readExcel(), "d:\\1.xls");//将读取到的2.xls中的数据合并到1.xls中
System.out.println("\n=======修改后，1.xls中的内容========");
eu2.readExcel();//读取合并后的1.xls的数据
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

	public void testMerge(){

		try {

			ExcelUtil eu1 = new ExcelUtil();//用来读取源xls

			ExcelUtil eu2 = new ExcelUtil();//用来读取目标xls，用于演示合并结果

			eu1.setExcelPath("d:\\2.xls");

			eu2.setExcelPath("d:\\1.xls");

			System.out.println("\n=======修改前，1.xls中的内容========");

			eu2.readExcel();

			System.out.println("\n=======读取源文件2.xls中的内容========");

			eu1.setStartReadPos(3);

			//eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）

			//eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）

			//eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

			eu1.writeExcel(eu1.readExcel(), "d:\\1.xls");//将读取到的2.xls中的数据合并到1.xls中

			System.out.println("\n=======修改后，1.xls中的内容========");

			eu2.readExcel();//读取合并后的1.xls的数据

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

	}

执行结果如下：

明明有重复的，为什么提示重复为0呢？这是因为默认对目标文件进行了覆写，直接把源文件的数据覆盖到目标文件中。所以只会显示源文件的内容。

如果把上段测试代码的13、14、15行换成下面的内容，手动还原1.xls，再测试一下：

eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
//eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
//eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

    eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）

    //eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）

    //eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

执行结果如下：

这次把覆写给取消了，在合并的时候，默认会比较第一列的数据，存在的则不再追加，所以1.xls中的张三保留了，李四追加到了后面。对比上面的覆盖，可以看到，覆写时跟2.xls的顺序一致（李四在张三前面），而不覆写，则在文档的最后执行追加操作。

我们再次修改测试代码：

eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
//eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

    eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）

    eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）

    //eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

同时手动把1.xls中的内容修改如下：

执行结果如下：

大家可以看到，比较的对象变到的第二列，由于张三所在行的第二列与添加的内容不相同，所以张三被追加到了文档的和面。

最后再次修改测试代码，并且手动还原1.xls为原始状态。

eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）
//eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）
eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

    eu1.setOverWrite(false);//是否覆写目标文件（默认覆写）

    //eu1.setComparePos(1);//设定比较哪一列内容（默认为0，比较第一列内容）

    eu1.setNeedCompare(false);//设定是否比较（默认值是true）。只有当不覆盖目标文件时，设置检查重复才有效。

执行结果如下：

这次把覆写和自动比较都取消了，结果就是直接在目标文件的后面进行追加操作。

代码有点多，大家可能看的有点累了，不过写这个工具类消耗了我n多脑细胞，还是希望对大家可以有所帮助。如果有什么问题，欢迎大家批评指正。

码农公寓

自己封装的poi操作Excel工具类

相关文章