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

时间:2023-03-08 20:35:25

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

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

工具类源码:

  1. package com.tgb.ccl.excel.util;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileOutputStream;
  5. import java.io.IOException;
  6. import java.util.ArrayList;
  7. import java.util.List;
  8. import org.apache.poi.hssf.usermodel.HSSFWorkbook;
  9. import org.apache.poi.ss.usermodel.Cell;
  10. import org.apache.poi.ss.usermodel.CellStyle;
  11. import org.apache.poi.ss.usermodel.Row;
  12. import org.apache.poi.ss.usermodel.Sheet;
  13. import org.apache.poi.ss.usermodel.Workbook;
  14. import org.apache.poi.ss.util.CellRangeAddress;
  15. import org.apache.poi.xssf.usermodel.XSSFWorkbook;
  16. /**
  17. * Excel文件操作工具类,包括读、写、合并等功能
  18. *
  19. * @author  : 龙轩
  20. * @group   : tgb8
  21. * @Version : 1.00
  22. * @Date    : 2014-10-29 上午12:40:44
  23. */
  24. public class ExcelUtil {
  25. //%%%%%%%%-------常量部分 开始----------%%%%%%%%%
  26. /**
  27. * 默认的开始读取的行位置为第一行(索引值为0)
  28. */
  29. private final static int READ_START_POS = 0;
  30. /**
  31. * 默认结束读取的行位置为最后一行(索引值=0,用负数来表示倒数第n行)
  32. */
  33. private final static int READ_END_POS = 0;
  34. /**
  35. * 默认Excel内容的开始比较列位置为第一列(索引值为0)
  36. */
  37. private final static int COMPARE_POS = 0;
  38. /**
  39. * 默认多文件合并的时需要做内容比较(相同的内容不重复出现)
  40. */
  41. private final static boolean NEED_COMPARE = true;
  42. /**
  43. * 默认多文件合并的新文件遇到名称重复时,进行覆盖
  44. */
  45. private final static boolean NEED_OVERWRITE = true;
  46. /**
  47. * 默认只操作一个sheet
  48. */
  49. private final static boolean ONLY_ONE_SHEET = true;
  50. /**
  51. * 默认读取第一个sheet中(只有当ONLY_ONE_SHEET = true时有效)
  52. */
  53. private final static int SELECTED_SHEET = 0;
  54. /**
  55. * 默认从第一个sheet开始读取(索引值为0)
  56. */
  57. private final static int READ_START_SHEET= 0;
  58. /**
  59. * 默认在最后一个sheet结束读取(索引值=0,用负数来表示倒数第n行)
  60. */
  61. private final static int READ_END_SHEET = 0;
  62. /**
  63. * 默认打印各种信息
  64. */
  65. private final static boolean PRINT_MSG = true;
  66. //%%%%%%%%-------常量部分 结束----------%%%%%%%%%
  67. //%%%%%%%%-------字段部分 开始----------%%%%%%%%%
  68. /**
  69. * Excel文件路径
  70. */
  71. private String excelPath = "data.xlsx";
  72. /**
  73. * 设定开始读取的位置,默认为0
  74. */
  75. private int startReadPos = READ_START_POS;
  76. /**
  77. * 设定结束读取的位置,默认为0,用负数来表示倒数第n行
  78. */
  79. private int endReadPos = READ_END_POS;
  80. /**
  81. * 设定开始比较的列位置,默认为0
  82. */
  83. private int comparePos = COMPARE_POS;
  84. /**
  85. *  设定汇总的文件是否需要替换,默认为true
  86. */
  87. private boolean isOverWrite = NEED_OVERWRITE;
  88. /**
  89. *  设定是否需要比较,默认为true(仅当不覆写目标内容是有效,即isOverWrite=false时有效)
  90. */
  91. private boolean isNeedCompare = NEED_COMPARE;
  92. /**
  93. * 设定是否只操作第一个sheet
  94. */
  95. private boolean onlyReadOneSheet = ONLY_ONE_SHEET;
  96. /**
  97. * 设定操作的sheet在索引值
  98. */
  99. private int selectedSheetIdx =SELECTED_SHEET;
  100. /**
  101. * 设定操作的sheet的名称
  102. */
  103. private String selectedSheetName = "";
  104. /**
  105. * 设定开始读取的sheet,默认为0
  106. */
  107. private int startSheetIdx = READ_START_SHEET;
  108. /**
  109. * 设定结束读取的sheet,默认为0,用负数来表示倒数第n行
  110. */
  111. private int endSheetIdx = READ_END_SHEET;
  112. /**
  113. * 设定是否打印消息
  114. */
  115. private boolean printMsg = PRINT_MSG;
  116. //%%%%%%%%-------字段部分 结束----------%%%%%%%%%
  117. public static void main(String[] args) {
  118. ExcelUtil eu = new ExcelUtil();
  119. //从第一行开始读取
  120. eu.setStartReadPos(1);
  121. String src_xlspath = "D:\\2.xls";
  122. String dist_xlsPath = "D:\\1.xls";
  123. List<Row> rowList;
  124. try {
  125. rowList = eu.readExcel(src_xlspath);
  126. //eu.writeExcel_xls(rowList, src_xlspath, dist_xlsPath);
  127. } catch (IOException e) {
  128. e.printStackTrace();
  129. }
  130. }
  131. public ExcelUtil(){
  132. }
  133. public ExcelUtil(String excelPath){
  134. this.excelPath = excelPath;
  135. }
  136. /**
  137. * 还原设定(其实是重新new一个新的对象并返回)
  138. * @return
  139. */
  140. public ExcelUtil RestoreSettings(){
  141. ExcelUtil instance = new  ExcelUtil(this.excelPath);
  142. return instance;
  143. }
  144. /**
  145. * 自动根据文件扩展名,调用对应的读取方法
  146. *
  147. * @Title: writeExcel
  148. * @Date : 2014-9-11 下午01:50:38
  149. * @param xlsPath
  150. * @throws IOException
  151. */
  152. public List<Row> readExcel() throws IOException{
  153. return readExcel(this.excelPath);
  154. }
  155. /**
  156. * 自动根据文件扩展名,调用对应的读取方法
  157. *
  158. * @Title: writeExcel
  159. * @Date : 2014-9-11 下午01:50:38
  160. * @param xlsPath
  161. * @throws IOException
  162. */
  163. public List<Row> readExcel(String xlsPath) throws IOException{
  164. //扩展名为空时,
  165. if (xlsPath.equals("")){
  166. throw new IOException("文件路径不能为空!");
  167. }else{
  168. File file = new File(xlsPath);
  169. if(!file.exists()){
  170. throw new IOException("文件不存在!");
  171. }
  172. }
  173. //获取扩展名
  174. String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);
  175. try {
  176. if("xls".equals(ext)){              //使用xls方式读取
  177. return readExcel_xls(xlsPath);
  178. }else if("xlsx".equals(ext)){       //使用xlsx方式读取
  179. return readExcel_xlsx(xlsPath);
  180. }else{                                  //依次尝试xls、xlsx方式读取
  181. out("您要操作的文件没有扩展名,正在尝试以xls方式读取...");
  182. try{
  183. return readExcel_xls(xlsPath);
  184. } catch (IOException e1) {
  185. out("尝试以xls方式读取,结果失败!,正在尝试以xlsx方式读取...");
  186. try{
  187. return readExcel_xlsx(xlsPath);
  188. } catch (IOException e2) {
  189. out("尝试以xls方式读取,结果失败!\n请您确保您的文件是Excel文件,并且无损,然后再试。");
  190. throw e2;
  191. }
  192. }
  193. }
  194. } catch (IOException e) {
  195. throw e;
  196. }
  197. }
  198. /**
  199. * 自动根据文件扩展名,调用对应的写入方法
  200. *
  201. * @Title: writeExcel
  202. * @Date : 2014-9-11 下午01:50:38
  203. * @param rowList
  204. * @throws IOException
  205. */
  206. public void writeExcel(List<Row> rowList) throws IOException{
  207. writeExcel(rowList,excelPath);
  208. }
  209. /**
  210. * 自动根据文件扩展名,调用对应的写入方法
  211. *
  212. * @Title: writeExcel
  213. * @Date : 2014-9-11 下午01:50:38
  214. * @param rowList
  215. * @param xlsPath
  216. * @throws IOException
  217. */
  218. public void writeExcel(List<Row> rowList, String xlsPath) throws IOException {
  219. //扩展名为空时,
  220. if (xlsPath.equals("")){
  221. throw new IOException("文件路径不能为空!");
  222. }
  223. //获取扩展名
  224. String ext = xlsPath.substring(xlsPath.lastIndexOf(".")+1);
  225. try {
  226. if("xls".equals(ext)){              //使用xls方式写入
  227. writeExcel_xls(rowList,xlsPath);
  228. }else if("xlsx".equals(ext)){       //使用xlsx方式写入
  229. writeExcel_xlsx(rowList,xlsPath);
  230. }else{                                  //依次尝试xls、xlsx方式写入
  231. out("您要操作的文件没有扩展名,正在尝试以xls方式写入...");
  232. try{
  233. writeExcel_xls(rowList,xlsPath);
  234. } catch (IOException e1) {
  235. out("尝试以xls方式写入,结果失败!,正在尝试以xlsx方式读取...");
  236. try{
  237. writeExcel_xlsx(rowList,xlsPath);
  238. } catch (IOException e2) {
  239. out("尝试以xls方式写入,结果失败!\n请您确保您的文件是Excel文件,并且无损,然后再试。");
  240. throw e2;
  241. }
  242. }
  243. }
  244. } catch (IOException e) {
  245. throw e;
  246. }
  247. }
  248. /**
  249. * 修改Excel(97-03版,xls格式)
  250. *
  251. * @Title: writeExcel_xls
  252. * @Date : 2014-9-11 下午01:50:38
  253. * @param rowList
  254. * @param dist_xlsPath
  255. * @throws IOException
  256. */
  257. public void writeExcel_xls(List<Row> rowList, String dist_xlsPath) throws IOException {
  258. writeExcel_xls(rowList, excelPath,dist_xlsPath);
  259. }
  260. /**
  261. * 修改Excel(97-03版,xls格式)
  262. *
  263. * @Title: writeExcel_xls
  264. * @Date : 2014-9-11 下午01:50:38
  265. * @param rowList
  266. * @param src_xlsPath
  267. * @param dist_xlsPath
  268. * @throws IOException
  269. */
  270. public void writeExcel_xls(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {
  271. // 判断文件路径是否为空
  272. if (dist_xlsPath == null || dist_xlsPath.equals("")) {
  273. out("文件路径不能为空");
  274. throw new IOException("文件路径不能为空");
  275. }
  276. // 判断文件路径是否为空
  277. if (src_xlsPath == null || src_xlsPath.equals("")) {
  278. out("文件路径不能为空");
  279. throw new IOException("文件路径不能为空");
  280. }
  281. // 判断列表是否有数据,如果没有数据,则返回
  282. if (rowList == null || rowList.size() == 0) {
  283. out("文档为空");
  284. return;
  285. }
  286. try {
  287. HSSFWorkbook wb = null;
  288. // 判断文件是否存在
  289. File file = new File(dist_xlsPath);
  290. if (file.exists()) {
  291. // 如果复写,则删除后
  292. if (isOverWrite) {
  293. file.delete();
  294. // 如果文件不存在,则创建一个新的Excel
  295. // wb = new HSSFWorkbook();
  296. // wb.createSheet("Sheet1");
  297. wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
  298. } else {
  299. // 如果文件存在,则读取Excel
  300. wb = new HSSFWorkbook(new FileInputStream(file));
  301. }
  302. } else {
  303. // 如果文件不存在,则创建一个新的Excel
  304. // wb = new HSSFWorkbook();
  305. // wb.createSheet("Sheet1");
  306. wb = new HSSFWorkbook(new FileInputStream(src_xlsPath));
  307. }
  308. // 将rowlist的内容写到Excel中
  309. writeExcel(wb, rowList, dist_xlsPath);
  310. } catch (IOException e) {
  311. e.printStackTrace();
  312. }
  313. }
  314. /**
  315. * 修改Excel(97-03版,xls格式)
  316. *
  317. * @Title: writeExcel_xls
  318. * @Date : 2014-9-11 下午01:50:38
  319. * @param rowList
  320. * @param dist_xlsPath
  321. * @throws IOException
  322. */
  323. public void writeExcel_xlsx(List<Row> rowList, String dist_xlsPath) throws IOException {
  324. writeExcel_xls(rowList, excelPath , dist_xlsPath);
  325. }
  326. /**
  327. * 修改Excel(2007版,xlsx格式)
  328. *
  329. * @Title: writeExcel_xlsx
  330. * @Date : 2014-9-11 下午01:50:38
  331. * @param rowList
  332. * @param xlsPath
  333. * @throws IOException
  334. */
  335. public void writeExcel_xlsx(List<Row> rowList, String src_xlsPath, String dist_xlsPath) throws IOException {
  336. // 判断文件路径是否为空
  337. if (dist_xlsPath == null || dist_xlsPath.equals("")) {
  338. out("文件路径不能为空");
  339. throw new IOException("文件路径不能为空");
  340. }
  341. // 判断文件路径是否为空
  342. if (src_xlsPath == null || src_xlsPath.equals("")) {
  343. out("文件路径不能为空");
  344. throw new IOException("文件路径不能为空");
  345. }
  346. // 判断列表是否有数据,如果没有数据,则返回
  347. if (rowList == null || rowList.size() == 0) {
  348. out("文档为空");
  349. return;
  350. }
  351. try {
  352. // 读取文档
  353. XSSFWorkbook wb = null;
  354. // 判断文件是否存在
  355. File file = new File(dist_xlsPath);
  356. if (file.exists()) {
  357. // 如果复写,则删除后
  358. if (isOverWrite) {
  359. file.delete();
  360. // 如果文件不存在,则创建一个新的Excel
  361. // wb = new XSSFWorkbook();
  362. // wb.createSheet("Sheet1");
  363. wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
  364. } else {
  365. // 如果文件存在,则读取Excel
  366. wb = new XSSFWorkbook(new FileInputStream(file));
  367. }
  368. } else {
  369. // 如果文件不存在,则创建一个新的Excel
  370. // wb = new XSSFWorkbook();
  371. // wb.createSheet("Sheet1");
  372. wb = new XSSFWorkbook(new FileInputStream(src_xlsPath));
  373. }
  374. // 将rowlist的内容添加到Excel中
  375. writeExcel(wb, rowList, dist_xlsPath);
  376. } catch (IOException e) {
  377. e.printStackTrace();
  378. }
  379. }
  380. /**
  381. * //读取Excel 2007版,xlsx格式
  382. *
  383. * @Title: readExcel_xlsx
  384. * @Date : 2014-9-11 上午11:43:11
  385. * @return
  386. * @throws IOException
  387. */
  388. public List<Row> readExcel_xlsx() throws IOException {
  389. return readExcel_xlsx(excelPath);
  390. }
  391. /**
  392. * //读取Excel 2007版,xlsx格式
  393. *
  394. * @Title: readExcel_xlsx
  395. * @Date : 2014-9-11 上午11:43:11
  396. * @return
  397. * @throws Exception
  398. */
  399. public List<Row> readExcel_xlsx(String xlsPath) throws IOException {
  400. // 判断文件是否存在
  401. File file = new File(xlsPath);
  402. if (!file.exists()) {
  403. throw new IOException("文件名为" + file.getName() + "Excel文件不存在!");
  404. }
  405. XSSFWorkbook wb = null;
  406. List<Row> rowList = new ArrayList<Row>();
  407. try {
  408. FileInputStream fis = new FileInputStream(file);
  409. // 去读Excel
  410. wb = new XSSFWorkbook(fis);
  411. // 读取Excel 2007版,xlsx格式
  412. rowList = readExcel(wb);
  413. } catch (IOException e) {
  414. e.printStackTrace();
  415. }
  416. return rowList;
  417. }
  418. /***
  419. * 读取Excel(97-03版,xls格式)
  420. *
  421. * @throws IOException
  422. *
  423. * @Title: readExcel
  424. * @Date : 2014-9-11 上午09:53:21
  425. */
  426. public List<Row> readExcel_xls() throws IOException {
  427. return readExcel_xls(excelPath);
  428. }
  429. /***
  430. * 读取Excel(97-03版,xls格式)
  431. *
  432. * @throws Exception
  433. *
  434. * @Title: readExcel
  435. * @Date : 2014-9-11 上午09:53:21
  436. */
  437. public List<Row> readExcel_xls(String xlsPath) throws IOException {
  438. // 判断文件是否存在
  439. File file = new File(xlsPath);
  440. if (!file.exists()) {
  441. throw new IOException("文件名为" + file.getName() + "Excel文件不存在!");
  442. }
  443. HSSFWorkbook wb = null;// 用于Workbook级的操作,创建、删除Excel
  444. List<Row> rowList = new ArrayList<Row>();
  445. try {
  446. // 读取Excel
  447. wb = new HSSFWorkbook(new FileInputStream(file));
  448. // 读取Excel 97-03版,xls格式
  449. rowList = readExcel(wb);
  450. } catch (IOException e) {
  451. e.printStackTrace();
  452. }
  453. return rowList;
  454. }
  455. /***
  456. * 读取单元格的值
  457. *
  458. * @Title: getCellValue
  459. * @Date : 2014-9-11 上午10:52:07
  460. * @param cell
  461. * @return
  462. */
  463. private String getCellValue(Cell cell) {
  464. Object result = "";
  465. if (cell != null) {
  466. switch (cell.getCellType()) {
  467. case Cell.CELL_TYPE_STRING:
  468. result = cell.getStringCellValue();
  469. break;
  470. case Cell.CELL_TYPE_NUMERIC:
  471. result = cell.getNumericCellValue();
  472. break;
  473. case Cell.CELL_TYPE_BOOLEAN:
  474. result = cell.getBooleanCellValue();
  475. break;
  476. case Cell.CELL_TYPE_FORMULA:
  477. result = cell.getCellFormula();
  478. break;
  479. case Cell.CELL_TYPE_ERROR:
  480. result = cell.getErrorCellValue();
  481. break;
  482. case Cell.CELL_TYPE_BLANK:
  483. break;
  484. default:
  485. break;
  486. }
  487. }
  488. return result.toString();
  489. }
  490. /**
  491. * 通用读取Excel
  492. *
  493. * @Title: readExcel
  494. * @Date : 2014-9-11 上午11:26:53
  495. * @param wb
  496. * @return
  497. */
  498. private List<Row> readExcel(Workbook wb) {
  499. List<Row> rowList = new ArrayList<Row>();
  500. int sheetCount = 1;//需要操作的sheet数量
  501. Sheet sheet = null;
  502. if(onlyReadOneSheet){   //只操作一个sheet
  503. // 获取设定操作的sheet(如果设定了名称,按名称查,否则按索引值查)
  504. sheet =selectedSheetName.equals("")? wb.getSheetAt(selectedSheetIdx):wb.getSheet(selectedSheetName);
  505. }else{                          //操作多个sheet
  506. sheetCount = wb.getNumberOfSheets();//获取可以操作的总数量
  507. }
  508. // 获取sheet数目
  509. for(int t=startSheetIdx; t<sheetCount+endSheetIdx;t++){
  510. // 获取设定操作的sheet
  511. if(!onlyReadOneSheet) {
  512. sheet =wb.getSheetAt(t);
  513. }
  514. //获取最后行号
  515. int lastRowNum = sheet.getLastRowNum();
  516. if(lastRowNum>0){    //如果>0,表示有数据
  517. out("\n开始读取名为【"+sheet.getSheetName()+"】的内容:");
  518. }
  519. Row row = null;
  520. // 循环读取
  521. for (int i = startReadPos; i <= lastRowNum + endReadPos; i++) {
  522. row = sheet.getRow(i);
  523. if (row != null) {
  524. rowList.add(row);
  525. out("第"+(i+1)+"行:",false);
  526. // 获取每一单元格的值
  527. for (int j = 0; j < row.getLastCellNum(); j++) {
  528. String value = getCellValue(row.getCell(j));
  529. if (!value.equals("")) {
  530. out(value + " | ",false);
  531. }
  532. }
  533. out("");
  534. }
  535. }
  536. }
  537. return rowList;
  538. }
  539. /**
  540. * 修改Excel,并另存为
  541. *
  542. * @Title: WriteExcel
  543. * @Date : 2014-9-11 下午01:33:59
  544. * @param wb
  545. * @param rowList
  546. * @param xlsPath
  547. */
  548. private void writeExcel(Workbook wb, List<Row> rowList, String xlsPath) {
  549. if (wb == null) {
  550. out("操作文档不能为空!");
  551. return;
  552. }
  553. Sheet sheet = wb.getSheetAt(0);// 修改第一个sheet中的值
  554. // 如果每次重写,那么则从开始读取的位置写,否则果获取源文件最新的行。
  555. int lastRowNum = isOverWrite ? startReadPos : sheet.getLastRowNum() + 1;
  556. int t = 0;//记录最新添加的行数
  557. out("要添加的数据总条数为:"+rowList.size());
  558. for (Row row : rowList) {
  559. if (row == null) continue;
  560. // 判断是否已经存在该数据
  561. int pos = findInExcel(sheet, row);
  562. Row r = null;// 如果数据行已经存在,则获取后重写,否则自动创建新行。
  563. if (pos >= 0) {
  564. sheet.removeRow(sheet.getRow(pos));
  565. r = sheet.createRow(pos);
  566. } else {
  567. r = sheet.createRow(lastRowNum + t++);
  568. }
  569. //用于设定单元格样式
  570. CellStyle newstyle = wb.createCellStyle();
  571. //循环为新行创建单元格
  572. for (int i = row.getFirstCellNum(); i < row.getLastCellNum(); i++) {
  573. Cell cell = r.createCell(i);// 获取数据类型
  574. cell.setCellValue(getCellValue(row.getCell(i)));// 复制单元格的值到新的单元格
  575. // cell.setCellStyle(row.getCell(i).getCellStyle());//出错
  576. if (row.getCell(i) == null) continue;
  577. copyCellStyle(row.getCell(i).getCellStyle(), newstyle); // 获取原来的单元格样式
  578. cell.setCellStyle(newstyle);// 设置样式
  579. // sheet.autoSizeColumn(i);//自动跳转列宽度
  580. }
  581. }
  582. out("其中检测到重复条数为:" + (rowList.size() - t) + " ,追加条数为:"+t);
  583. // 统一设定合并单元格
  584. setMergedRegion(sheet);
  585. try {
  586. // 重新将数据写入Excel中
  587. FileOutputStream outputStream = new FileOutputStream(xlsPath);
  588. wb.write(outputStream);
  589. outputStream.flush();
  590. outputStream.close();
  591. } catch (Exception e) {
  592. out("写入Excel时发生错误! ");
  593. e.printStackTrace();
  594. }
  595. }
  596. /**
  597. * 查找某行数据是否在Excel表中存在,返回行数。
  598. *
  599. * @Title: findInExcel
  600. * @Date : 2014-9-11 下午02:23:12
  601. * @param sheet
  602. * @param row
  603. * @return
  604. */
  605. private int findInExcel(Sheet sheet, Row row) {
  606. int pos = -1;
  607. try {
  608. // 如果覆写目标文件,或者不需要比较,则直接返回
  609. if (isOverWrite || !isNeedCompare) {
  610. return pos;
  611. }
  612. for (int i = startReadPos; i <= sheet.getLastRowNum() + endReadPos; i++) {
  613. Row r = sheet.getRow(i);
  614. if (r != null && row != null) {
  615. String v1 = getCellValue(r.getCell(comparePos));
  616. String v2 = getCellValue(row.getCell(comparePos));
  617. if (v1.equals(v2)) {
  618. pos = i;
  619. break;
  620. }
  621. }
  622. }
  623. } catch (Exception e) {
  624. e.printStackTrace();
  625. }
  626. return pos;
  627. }
  628. /**
  629. * 复制一个单元格样式到目的单元格样式
  630. *
  631. * @param fromStyle
  632. * @param toStyle
  633. */
  634. public static void copyCellStyle(CellStyle fromStyle, CellStyle toStyle) {
  635. toStyle.setAlignment(fromStyle.getAlignment());
  636. // 边框和边框颜色
  637. toStyle.setBorderBottom(fromStyle.getBorderBottom());
  638. toStyle.setBorderLeft(fromStyle.getBorderLeft());
  639. toStyle.setBorderRight(fromStyle.getBorderRight());
  640. toStyle.setBorderTop(fromStyle.getBorderTop());
  641. toStyle.setTopBorderColor(fromStyle.getTopBorderColor());
  642. toStyle.setBottomBorderColor(fromStyle.getBottomBorderColor());
  643. toStyle.setRightBorderColor(fromStyle.getRightBorderColor());
  644. toStyle.setLeftBorderColor(fromStyle.getLeftBorderColor());
  645. // 背景和前景
  646. toStyle.setFillBackgroundColor(fromStyle.getFillBackgroundColor());
  647. toStyle.setFillForegroundColor(fromStyle.getFillForegroundColor());
  648. // 数据格式
  649. toStyle.setDataFormat(fromStyle.getDataFormat());
  650. toStyle.setFillPattern(fromStyle.getFillPattern());
  651. // toStyle.setFont(fromStyle.getFont(null));
  652. toStyle.setHidden(fromStyle.getHidden());
  653. toStyle.setIndention(fromStyle.getIndention());// 首行缩进
  654. toStyle.setLocked(fromStyle.getLocked());
  655. toStyle.setRotation(fromStyle.getRotation());// 旋转
  656. toStyle.setVerticalAlignment(fromStyle.getVerticalAlignment());
  657. toStyle.setWrapText(fromStyle.getWrapText());
  658. }
  659. /**
  660. * 获取合并单元格的值
  661. *
  662. * @param sheet
  663. * @param row
  664. * @param column
  665. * @return
  666. */
  667. public void setMergedRegion(Sheet sheet) {
  668. int sheetMergeCount = sheet.getNumMergedRegions();
  669. for (int i = 0; i < sheetMergeCount; i++) {
  670. // 获取合并单元格位置
  671. CellRangeAddress ca = sheet.getMergedRegion(i);
  672. int firstRow = ca.getFirstRow();
  673. if (startReadPos - 1 > firstRow) {// 如果第一个合并单元格格式在正式数据的上面,则跳过。
  674. continue;
  675. }
  676. int lastRow = ca.getLastRow();
  677. int mergeRows = lastRow - firstRow;// 合并的行数
  678. int firstColumn = ca.getFirstColumn();
  679. int lastColumn = ca.getLastColumn();
  680. // 根据合并的单元格位置和大小,调整所有的数据行格式,
  681. for (int j = lastRow + 1; j <= sheet.getLastRowNum(); j++) {
  682. // 设定合并单元格
  683. sheet.addMergedRegion(new CellRangeAddress(j, j + mergeRows, firstColumn, lastColumn));
  684. j = j + mergeRows;// 跳过已合并的行
  685. }
  686. }
  687. }
  688. /**
  689. * 打印消息,
  690. * @param msg 消息内容
  691. * @param tr 换行
  692. */
  693. private void out(String msg){
  694. if(printMsg){
  695. out(msg,true);
  696. }
  697. }
  698. /**
  699. * 打印消息,
  700. * @param msg 消息内容
  701. * @param tr 换行
  702. */
  703. private void out(String msg,boolean tr){
  704. if(printMsg){
  705. System.out.print(msg+(tr?"\n":""));
  706. }
  707. }
  708. public String getExcelPath() {
  709. return this.excelPath;
  710. }
  711. public void setExcelPath(String excelPath) {
  712. this.excelPath = excelPath;
  713. }
  714. public boolean isNeedCompare() {
  715. return isNeedCompare;
  716. }
  717. public void setNeedCompare(boolean isNeedCompare) {
  718. this.isNeedCompare = isNeedCompare;
  719. }
  720. public int getComparePos() {
  721. return comparePos;
  722. }
  723. public void setComparePos(int comparePos) {
  724. this.comparePos = comparePos;
  725. }
  726. public int getStartReadPos() {
  727. return startReadPos;
  728. }
  729. public void setStartReadPos(int startReadPos) {
  730. this.startReadPos = startReadPos;
  731. }
  732. public int getEndReadPos() {
  733. return endReadPos;
  734. }
  735. public void setEndReadPos(int endReadPos) {
  736. this.endReadPos = endReadPos;
  737. }
  738. public boolean isOverWrite() {
  739. return isOverWrite;
  740. }
  741. public void setOverWrite(boolean isOverWrite) {
  742. this.isOverWrite = isOverWrite;
  743. }
  744. public boolean isOnlyReadOneSheet() {
  745. return onlyReadOneSheet;
  746. }
  747. public void setOnlyReadOneSheet(boolean onlyReadOneSheet) {
  748. this.onlyReadOneSheet = onlyReadOneSheet;
  749. }
  750. public int getSelectedSheetIdx() {
  751. return selectedSheetIdx;
  752. }
  753. public void setSelectedSheetIdx(int selectedSheetIdx) {
  754. this.selectedSheetIdx = selectedSheetIdx;
  755. }
  756. public String getSelectedSheetName() {
  757. return selectedSheetName;
  758. }
  759. public void setSelectedSheetName(String selectedSheetName) {
  760. this.selectedSheetName = selectedSheetName;
  761. }
  762. public int getStartSheetIdx() {
  763. return startSheetIdx;
  764. }
  765. public void setStartSheetIdx(int startSheetIdx) {
  766. this.startSheetIdx = startSheetIdx;
  767. }
  768. public int getEndSheetIdx() {
  769. return endSheetIdx;
  770. }
  771. public void setEndSheetIdx(int endSheetIdx) {
  772. this.endSheetIdx = endSheetIdx;
  773. }
  774. public boolean isPrintMsg() {
  775. return printMsg;
  776. }
  777. public void setPrintMsg(boolean printMsg) {
  778. this.printMsg = printMsg;
  779. }
  780. }
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;
}
}

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

  1. public void testRead() {
  2. try {
  3. ExcelUtil eu = new ExcelUtil();
  4. eu.setExcelPath("d:\\2.xls");
  5. System.out.println("=======测试Excel 默认 读取========");
  6. eu.readExcel();
  7. System.out.println("\n=======测试Excel 从第四行读取,倒数第二行结束========");
  8. eu = eu.RestoreSettings();//还原设定
  9. eu.setStartReadPos(3);
  10. eu.setEndReadPos(-1);
  11. eu.readExcel();
  12. System.out.println("\n=======测试Excel 读取第二个sheet========");
  13. eu = eu.RestoreSettings();//还原设定
  14. eu.setSelectedSheetIdx(1);
  15. eu.readExcel();
  16. System.out.println("\n=======测试Excel 读取所有的sheet========");
  17. eu = eu.RestoreSettings();//还原设定
  18. eu.setOnlyReadOneSheet(false);
  19. eu.readExcel();
  20. } catch (IOException e) {
  21. // TODO Auto-generated catch block
  22. e.printStackTrace();
  23. }
  24. }
	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文件内容如下:

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

执行结果如下:

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

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

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

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

测试代码如下:

  1. public void testMerge(){
  2. try {
  3. ExcelUtil eu1 = new ExcelUtil();//用来读取源xls
  4. ExcelUtil eu2 = new ExcelUtil();//用来读取目标xls,用于演示合并结果
  5. eu1.setExcelPath("d:\\2.xls");
  6. eu2.setExcelPath("d:\\1.xls");
  7. System.out.println("\n=======修改前,1.xls中的内容========");
  8. eu2.readExcel();
  9. System.out.println("\n=======读取源文件2.xls中的内容========");
  10. eu1.setStartReadPos(3);
  11. //eu1.setOverWrite(false);//是否覆写目标文件(默认覆写)
  12. //eu1.setComparePos(1);//设定比较哪一列内容(默认为0,比较第一列内容)
  13. //eu1.setNeedCompare(false);//设定是否比较(默认值是true)。只有当不覆盖目标文件时,设置检查重复才有效。
  14. eu1.writeExcel(eu1.readExcel(), "d:\\1.xls");//将读取到的2.xls中的数据合并到1.xls中
  15. System.out.println("\n=======修改后,1.xls中的内容========");
  16. eu2.readExcel();//读取合并后的1.xls的数据
  17. } catch (IOException e) {
  18. // TODO Auto-generated catch block
  19. e.printStackTrace();
  20. }
  21. }
	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();
}
}

执行结果如下:

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

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

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

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

执行结果如下:

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

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

我们再次修改测试代码:

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

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

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

执行结果如下:

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

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

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

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

执行结果如下:

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

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

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