封装poi操作Excel工具类

最新推荐文章于 2024-03-11 07:15:00 发布

_HQ

最新推荐文章于 2024-03-11 07:15:00 发布

阅读量3.6k

点赞数

分类专栏： Java工具类 java

java 同时被 2 个专栏收录

34 篇文章 0 订阅

订阅专栏

Java工具类

2 篇文章 0 订阅

订阅专栏

原文点这里：

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

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

工具类源码：

[java]view plain copy 
   
 print?
 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;  
     }  
 }  

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

[java]view plain copy 
   
 print?
 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内容如下：

测试代码如下：

[java]view plain copy 
   
 print?
 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，再测试一下：

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

执行结果如下：

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

我们再次修改测试代码：

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

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

执行结果如下：

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

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

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

执行结果如下：

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

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

_HQ

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
封装poi操作Excel工具类

原文点这里：在上一篇文章《使用poi读写Excel》中分享了一下poi操作Excel的简单示例，这次要分享一下我封装的一个Excel操作的工具类。该工具类主要完成的功能是：读取Excel、汇总Excel的功能。在读取时，可以设定开始和结束读取的位置、设定是否读取多个sheet、设定读取那个或者那些sheet等。在汇总时，如设定是否覆盖目标文件、设定是否比较
复制链接

扫一扫