java关于文件的工具类以及Excel高效导出

java开发中的一些关于文件和文件夹操作的工具类：

1、文件以及文件夹工具类：

package com.hpe.poi.util;

import org.apache.commons.io.FileUtils;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.StringTokenizer;

/**
 * 文件以及文件夹工具类
 * Created by Administrator on 2018/11/30 0030.
 */
public class FileUtil {

    /**
     * 创建文件夹(循环创建)
     * @param dirPath 需要创建的文件夹
     */
    public static void dirExists(String dirPath) {

        StringTokenizer st =new StringTokenizer(dirPath,"/");

        String   path1 = st.nextToken()+"/";

        String   path2 = path1;

        while(st.hasMoreTokens()){

            path1 = st.nextToken()+"/";

            path2 += path1;

            File file   =   new File(path2);

            if(!file.exists()){

                file.mkdir();

            }
        }
    }

    /**
     * 判断文件是否存在，不存在创建
     * @param file 需要创建的文件
     */
    public static void judeFileExists(File file) {

        if (file.exists() == false){

            try {
                file.createNewFile();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 判断文件夹是否存在,不存在创建。
     * @param file 需要创建的文件夹
     */
    public static void judeDirExists(File file) {

        if (file.exists() == false){

            file.mkdir();
        }
    }

    /**
     * 删除文件
     * @param fileRoot 删除文件路径
     */
    public static void deleteFile(String fileRoot) {

        File file = new File(fileRoot);

        if(file.exists() && file.isFile()){
            //删除文件
            file.delete();
        }
    }


    /**
     * 压缩文件路径
     * @param compressFileName 压缩文件名称
     * @param compressFolder 压缩文件夹路径
     */
    public static void compressFolder(String compressFileName,String compressFolder) {

        try {

            //压缩文件夹路径
            FileOutputStream fos1 = new FileOutputStream(new File(compressFolder+".zip"));

            //压缩文件
            ZipUtils.toZip(compressFolder, fos1,true);

        } catch (Exception e) {
            e.printStackTrace();
        }

    }


    /**
     * 删除文件夹：支持多层文件夹删除
     * @param folderPath 文件夹路径
     */
    public static void removeFolder(String folderPath) {

        try {

            //需要删除的文件夹
            File file = new File(folderPath);
            //执行删除
            FileUtils.deleteDirectory(file);

        } catch (Exception e) {

            e.printStackTrace();
        }
    }

}

2、压缩文件工具类

package com.hpe.poi.util;

import java.io.*;
import java.util.List;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

/**
 * 压缩文件工具类
 */
public class ZipUtils {

    private static final int  BUFFER_SIZE = 2 * 1024;

    /**
     * 压缩成ZIP(压缩文件夹) 方法1
     * @param compressFolder 压缩文件夹路径
     * @param out    压缩文件输出流
     * @param KeepDirStructure  是否保留原来的目录结构,true:保留目录结构;
     *                          false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
     * @throws RuntimeException 压缩失败会抛出运行时异常
     */
    public static void toZip(String compressFolder, OutputStream out, boolean KeepDirStructure)

            throws RuntimeException{

        ZipOutputStream zos = null ;

        try {
            zos = new ZipOutputStream(out);
            //创建文件夹
            File sourceFile = new File(compressFolder);

            compress(sourceFile,zos,sourceFile.getName(),KeepDirStructure);

        } catch (Exception e) {
            e.printStackTrace();
            //throw new BusinessException("zip文件生成失败！");

        }finally{
            if(zos != null){
                try {
                    zos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     * 压缩成ZIP(压缩单个文件) 方法2
     * @param compressFileList 需要压缩的文件列表
     * @param out           压缩文件输出流
     * @throws RuntimeException 压缩失败会抛出运行时异常
     */
    public static void toZip(List<File> compressFileList , OutputStream out)throws RuntimeException {

        ZipOutputStream zos = null ;

        try {
            zos = new ZipOutputStream(out);
            for (File srcFile : compressFileList) {
                byte[] buf = new byte[BUFFER_SIZE];
                zos.putNextEntry(new ZipEntry(srcFile.getName()));
                int len;
                FileInputStream in = new FileInputStream(srcFile);
                while ((len = in.read(buf)) != -1){
                    zos.write(buf, 0, len);
                }
                zos.closeEntry();
                in.close();
            }

        } catch (Exception e) {
            e.printStackTrace();
            //throw new BusinessException("zip文件生成失败！");

        }finally{
            if(zos != null){
                try {
                    zos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 递归压缩方法
     * @param sourceFile 源文件
     * @param zos        zip输出流
     * @param name       压缩后的名称
     * @param KeepDirStructure  是否保留原来的目录结构,true:保留目录结构;
     *                          false:所有文件跑到压缩包根目录下(注意：不保留目录结构可能会出现同名文件,会压缩失败)
     * @throws Exception
     **/
    private static void compress(File sourceFile, ZipOutputStream zos, String name,
                                 boolean KeepDirStructure) throws Exception{
        byte[] buf = new byte[BUFFER_SIZE];
        if(sourceFile.isFile()){
            // 向zip输出流中添加一个zip实体，构造器中name为zip实体的文件的名字
            zos.putNextEntry(new ZipEntry(name));
            // copy文件到zip输出流中
            int len;
            FileInputStream in = new FileInputStream(sourceFile);
            while ((len = in.read(buf)) != -1){
                zos.write(buf, 0, len);
            }
            // Complete the entry
            zos.closeEntry();
            in.close();
        } else {
            File[] listFiles = sourceFile.listFiles();
            if(listFiles == null || listFiles.length == 0){
                // 需要保留原来的文件结构时,需要对空文件夹进行处理
                if(KeepDirStructure){
                    // 空文件夹的处理
                    zos.putNextEntry(new ZipEntry(name + "/"));
                    // 没有文件，不需要文件的copy
                    zos.closeEntry();
                }

            }else {
                for (File file : listFiles) {
                    // 判断是否需要保留原来的文件结构
                    if (KeepDirStructure) {
                        // 注意：file.getName()前面需要带上父文件夹的名字加一斜杠,
                        // 不然最后压缩包中就不能保留原来的文件结构,即：所有文件都跑到压缩包根目录下了
                        compress(file, zos, name + "/" + file.getName(),KeepDirStructure);
                    } else {
                        compress(file, zos, file.getName(),KeepDirStructure);
                    }

                }

            }

        }

    }


    public static void main(String[] args) throws Exception {

        /** 文件夹压缩测试-测试压缩方法1  */
        FileOutputStream fos1 = new FileOutputStream(new File("E:/ftp/order/export/temp/6.28-7.4.zip"));

        ZipUtils.toZip("E:/ftp/order/export/temp/6.28-7.4/", fos1,true);

        //删除文件夹
        /*File file = new File("E:/ftp/order/export/temp/6.28-7.4执行单/");
        long start = System.currentTimeMillis();
        FileUtils.deleteDirectory(file);
        long end = System.currentTimeMillis();
        System.out.println("删除文件夹成功,消耗时间："+(end - start)+"ms");*/

        /** 具体文件压缩-测试压缩方法2  */
        /*List<File> fileList = new ArrayList<>();

        fileList.add(new File("D:/Java/jdk1.7.0_45_64bit/bin/java.exe"));

        fileList.add(new File("D:/Java/jdk1.7.0_45_64bit/bin/java.exe"));

        FileOutputStream fos2 = new FileOutputStream(new File("c:test.zip"));

        ZipUtils.toZip(fileList, fos2);*/

    }
}

3、导出excel工具类（主要针对poi和jxls导出excel）

      使用此工具类需要的依赖：

   

<!-- ##################jxls导出用##################### -->
      <dependency>
          <groupId>net.sf.jxls</groupId>
          <artifactId>jxls-core</artifactId>
          <version>1.0.6</version>
      </dependency>

      <dependency>
          <groupId>commons-logging</groupId>
          <artifactId>commons-logging</artifactId>
          <version>1.2</version>
      </dependency>

      <dependency>
          <groupId>org.apache.commons</groupId>
          <artifactId>commons-jexl</artifactId>
          <version>2.1.1</version>
      </dependency>

      <dependency>
          <groupId>commons-digester</groupId>
          <artifactId>commons-digester</artifactId>
          <version>2.1</version>
      </dependency>

      <dependency>
          <groupId>commons-beanutils</groupId>
          <artifactId>commons-beanutils</artifactId>
          <version>1.9.3</version>
      </dependency>



      <!-- #########poi和jxls导出都需要jar############### -->
      <dependency>
          <groupId>org.apache.poi</groupId>
          <artifactId>poi</artifactId>
          <version>3.17</version>
      </dependency>

      <dependency>
          <groupId>org.apache.poi</groupId>
          <artifactId>poi-ooxml</artifactId>
          <version>3.17</version>
      </dependency>

      <dependency>
          <groupId>org.apache.xmlbeans</groupId>
          <artifactId>xmlbeans</artifactId>
          <version>2.6.0</version>
      </dependency>

      <dependency>
          <groupId> org.apache.commons</groupId>
          <artifactId>commons-collections4</artifactId>
          <version>4.1</version>
      </dependency>

      <!-- #####################poi导出必须包####################### -->
      <dependency>
          <groupId>org.apache.poi</groupId>
          <artifactId>ooxml-schemas</artifactId>
          <version>1.3</version>
      </dependency>

      <!-- #####################servlet支持######################## -->
      <dependency>
          <groupId>javax.servlet</groupId>
          <artifactId>servlet-api</artifactId>
          <version>2.5</version>
          <scope>provided</scope>
      </dependency>

      <!-- ####################io################################-->
      <dependency>
          <groupId>commons-io</groupId>
          <artifactId>commons-io</artifactId>
          <version>2.6</version>
      </dependency>

Sheet工具类：

package com.hpe.poi.util;


import net.sf.jxls.transformer.XLSTransformer;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.xssf.streaming.SXSSFCell;
import org.apache.poi.xssf.streaming.SXSSFRow;
import org.apache.poi.xssf.streaming.SXSSFSheet;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;

import java.io.*;
import java.util.List;
import java.util.Map;

/**
 * Created on 2017/5/18.
 */
public class SheetUtil {

    /**
     * 写xls
     * @param sheet
     * @param rowNum
     * @param cellValues
     */
    public static void writeRow(HSSFSheet sheet, int rowNum, String... cellValues) {
        HSSFRow row = sheet.createRow(rowNum);
        int col = 0;
        for (String value : cellValues) {
            HSSFCell cell = row.createCell(col++);
            cell.setCellValue(value);
        }
    }

    public static void mergeCell(HSSFSheet sheet, int rowStart, int colStart, int rowEnd, int colEnd) {

        sheet.addMergedRegion(new CellRangeAddress(rowStart, rowEnd, colStart, colEnd));
    }


    /**
     * 写xlsx(性能不佳)
     * @param sheet
     * @param rowNum
     * @param cellValues
     */
    public static void writeRowXlsx(XSSFSheet sheet, int rowNum, String... cellValues) {
        XSSFRow row = sheet.createRow(rowNum);
        int col = 0;
        for (String value : cellValues) {
            XSSFCell cell = row.createCell(col++);
            cell.setCellValue(value);
        }
    }

    public static void writeRowXlsxByList(XSSFSheet sheet, int rowNum, List cellValues) {
        XSSFRow row = sheet.createRow(rowNum);
        int col = 0;
        for (Object value : cellValues) {
            XSSFCell cell = row.createCell(col++);
            cell.setCellValue(value.toString());
        }
    }


    public static void mergeCellXlsx(XSSFSheet sheet, int rowStart, int colStart, int rowEnd, int colEnd) {
        sheet.addMergedRegion(new CellRangeAddress(rowStart, rowEnd, colStart, colEnd));
    }

    /**
     * 写大容量数据
     * @param sheet sheet页
     * @param rowStartNum 开始行
     * @param colStartNum 开始列
     * @param cellValues 填充数据
     */
    public static void writeRowExcelBySXSSF(SXSSFSheet sheet, int rowStartNum, int colStartNum, Object... cellValues) {
        SXSSFRow row = sheet.createRow(rowStartNum);
        for (Object value : cellValues) {
            SXSSFCell cell = row.createCell(colStartNum++);
            cell.setCellValue(value.toString());
        }
    }


    /**
     * 写数据
     * @param sheet sheet页
     * @param rowStartNum 开始行
     * @param colStartNum 开始列
     * @param cellValues 填充数据
     */
    public static void writeRowExcelListBySXSSF(SXSSFSheet sheet, int rowStartNum, int colStartNum, List cellValues) {
        //创建行
        SXSSFRow row = sheet.createRow(rowStartNum);

        //循环添加数据
        for (Object value : cellValues) {
            SXSSFCell cell = row.createCell(colStartNum++);
            cell.setCellValue(value.toString());
        }
    }

    /**
     * 插入到指定行列内
     * @param sheet
     * @param rowStart
     * @param colStart
     * @param rowEnd
     * @param colEnd
     */
    public static void mergeCellXlsxBySXSSF(SXSSFSheet sheet, int rowStart, int colStart, int rowEnd, int colEnd) {
        sheet.addMergedRegion(new CellRangeAddress(rowStart, rowEnd, colStart, colEnd));
    }

    public static void writeXlsxSXSSF(String fileName, List<String[]> list) {
        try {
            //输出文件名称
            InputStream is = new FileInputStream(fileName);
            //创建Excel文档对象
            XSSFWorkbook workbook = new XSSFWorkbook(is);
            SXSSFWorkbook wb = new SXSSFWorkbook(workbook);
            //获得工作表
            SXSSFSheet sheet = wb.getSheetAt(0);
            for (int i = 0; i < list.size(); i++) {
                SXSSFRow row = sheet.createRow(i);
                String[] str = list.get(i);
                for (int j = 0; j < str.length; j++) {
                    SXSSFCell cell = row.createCell(j);
                    cell.setCellValue(str[j]);
                }
            }
            OutputStream outputStream = new FileOutputStream(fileName);
            wb.write(outputStream);
            outputStream.flush();
            outputStream.close();
            wb.close();
        } catch (Exception e) {
            e.fillInStackTrace();
        }
    }

    /*public static Map<Integer, List<String[]>> readXlsx(String fileName) {
        Map<Integer, List<String[]>> map = new HashMap<Integer, List<String[]>>();
        try {
            InputStream is = new FileInputStream(fileName);
            XSSFWorkbook workbook = new XSSFWorkbook(is);
            //循环工作表Sheet
            for (int numSheet = 0; numSheet < workbook.getNumberOfSheets(); numSheet++) {
                XSSFSheet xssfSheet = workbook.getSheetAt(numSheet);
                if (xssfSheet == null) {
                    continue;
                }
                List<String[]> list = new ArrayList<String[]>();

                for (int row = 0; row <= xssfSheet.getLastRowNum(); row++) {
                    XSSFRow xssfRow = xssfSheet.getRow(row);
                    if (xssfRow == null) {
                        continue;
                    }
                    try {
                        String[] singleRow = new String[xssfRow.getLastCellNum()];
                        for (int column = 0; column < xssfRow.getLastCellNum(); column++) {
                            Cell cell = xssfRow.getCell(column, Row.MissingCellPolicy.CREATE_NULL_AS_BLANK);
                            switch (cell.getCellType()) {
                                case BLANK:
                                    singleRow[column] = "";
                                    break;
                                case BOOLEAN:
                                    singleRow[column] = Boolean.toString(cell.getBooleanCellValue());
                                    break;
                                case ERROR:
                                    singleRow[column] = "";
                                    break;
                                case FORMULA:
                                    cell.setCellType(STRING);
                                    singleRow[column] = cell.getStringCellValue();
                                    if (singleRow[column] != null) {
                                        singleRow[column] = singleRow[column].replaceAll("#N/A", "").trim();
                                    }
                                    break;
                                case NUMERIC:
                                    if (DateUtil.isCellDateFormatted(cell)) {
                                        singleRow[column] = String.valueOf(cell.getDateCellValue());
                                    } else {
                                        cell.setCellType(STRING);
                                        String temp = cell.getStringCellValue();
                                        //判断是否包含小数点，如果不含小数点，则以字符串读取，如果含小数点，则转换为Double类型的字符串
                                        if (temp.contains(".")) {
                                            singleRow[column] = String.valueOf(new Double(temp)).trim();
                                        } else {
                                            singleRow[column] = temp.trim();
                                        }
                                    }

                                    break;
                                case STRING:
                                    singleRow[column] = cell.getStringCellValue().trim();
                                    break;
                                default:
                                    singleRow[column] = "";
                                    break;
                            }
                        }
                        list.add(singleRow);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
                map.put(numSheet, list);

            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return map;
    }*/

    /**
     * jxls模板导出excel：一个sheet页(效率比较高支持xls和xlsx格式)
     * @param templateFile 模板文件
     * @param context 导出数据
     * @param exportFilePath 导出文件位置
     */
    public static void jxlsExportExcelOneSheet(String templateFile,Map<String,Object> context,String exportFilePath) {

        try {

            XLSTransformer transformer = new XLSTransformer();

            transformer.transformXLS(templateFile, context, exportFilePath);


        } catch (Exception e) {

            e.printStackTrace();
        }
    }

    /**
     * jxls模板：多sheet导出(效率比较高支持xls和xlsx格式)
     * @param inputStream 文件输入流对象
     * @param dataLists sheet需要数据
     * @param sheetNamesList sheet名称集合
     * @param beanName  模板用于遍历的名称，比如：模板遍历的对象为list，这个属性值就应该设置为list
     * @param beanParams 这个参数是在如果传入的objects还与其他的对象关联的时候使用的，该参数是一个HashMap类型的参数，如果不使用的话，直接传入new HashMap()即可
     * @param startSheetNum 传入0即可，即SheetNo从0开始
     */
    public static Workbook jxlsExportMultipleSheet(InputStream inputStream, List dataLists, List sheetNamesList, String beanName, Map beanParams, int startSheetNum){

        Workbook workbook = null;

        try{

            //创建XLSTransformer对象
            XLSTransformer transformer = new XLSTransformer();

            //调用引擎生成excel报表
            workbook = (Workbook)transformer.transformMultipleSheetsList(inputStream,dataLists,sheetNamesList,beanName,beanParams,startSheetNum);

        }catch (Exception e){

            e.printStackTrace();
        }

        return workbook;
    }

    /**
     * jxls循环删除多个sheet
     * @param workbook Workbook对象
     * @param sheetNames sheet名称数组
     * @return
     */
    public static Workbook removeSheets(Workbook workbook,String[] sheetNames){

        //循环删除多余的sheet
        for (String sheetName : sheetNames){

            workbook.removeSheetAt(workbook.getSheetIndex(sheetName));
        }

        return workbook;

    }

}

下面是针对导出excel工具类，使用模板导出excel中一个sheet页和一个excel中多个sheet页的简单demo：

（1）、模板导出一个excel中一个sheet页，使用jxlsExportExcelOneSheet类

目录结构如图所示，模板文件在resource文件夹下（java项目）

  首先创建模板导出用模板样式如下图：

书写测试类进行工具类的测试：

    /**
     * 单Sheet Excel导出测试
     */
    @Test
    public void oneSheetExportTest(){

        //模板文件(当前项目下的模板)
        String templateFile = "src/main/resource/template.xlsx";

        Map<String, Object> context = new HashMap<String, Object>();

        List<User> userList = new ArrayList<User>();

        User user1 = new User();

        user1.setId(11);

        user1.setUserName("李四");

        user1.setPassword("lisi");

        user1.setAge(25);

        userList.add(user1);

        User user2 = new User();

        user2.setId(13);

        user2.setUserName("王五");

        user2.setPassword("wangwu");

        user2.setAge(25);

        userList.add(user2);

        context.put("resultList", userList);

        //导出文件
        String exportFilePath = "G:/simple.xlsx";

        SheetUtil.jxlsExportExcelOneSheet(templateFile,context,exportFilePath);

    }

执行导出输出结果：

（2）、jxls根据模板导出多Sheet页，首先模板文件存放位置和单sheet导出模板位置相同在：src/main/resource/multiSheet.xlsx

(注意：为了导出后不删除多余的sheet页，再制作模板的时候，就只留一个sheet页)，模板样式：

 

/**
     * jxls多sheet导出测试
     */
    @Test
    public void multipleSheetsExportTest(){

        try{

            //模板文件(当前项目下的模板)
            String templateFile = "src/main/resource/multiSheet.xlsx";

            FileInputStream is = new FileInputStream(templateFile);

            List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();

            Map<String, Object> map1 = new HashMap<String, Object>();

            map1.put("name", "华为");

            map1.put("price", "3000");

            map1.put("desc", "全面屏");

            map1.put("remark", "中文测试");

            Map<String, Object> map2 = new HashMap<String, Object>();

            map2.put("name", "努比亚");

            map2.put("price", "2000");

            map2.put("desc", "无边框");

            map2.put("remark", "测试中文");

            list.add(map1);

            list.add(map2);

            //封装数据map
            Map<String,Object> dataMap = new HashMap<String,Object>();
            //excel取得集合
            dataMap.put("dataList",list);
            //直接取属性
            dataMap.put("userName","zhangsan");

            List<Map<String,Object>> objects = new ArrayList<Map<String,Object>>();

            objects.add(dataMap);

            objects.add(dataMap);

            objects.add(dataMap);

            objects.add(dataMap);

            objects.add(dataMap);

            //sheet的名称
            List<String> listSheetNames = new ArrayList<String>();

            listSheetNames.add("测试1");

            listSheetNames.add("测试2");

            listSheetNames.add("测试3");

            listSheetNames.add("测试4");

            listSheetNames.add("测试5");

            //调用引擎生成excel报表
            Workbook workbook = SheetUtil.jxlsExportMultipleSheet(is, objects, listSheetNames, "list", new HashMap(), 0);

            //删除多余sheet
            //String[] sheetNames = {"sheet2","sheet3"};
            //workbook = SheetUtil.removeSheets(workbook,sheetNames);

            //workbook.removeSheetAt(workbook.getSheetIndex("sheet2"));
            //workbook.removeSheetAt(workbook.getSheetIndex("sheet3"));

            workbook.write(new FileOutputStream("G:/xlsExportUtils.xlsx"));

        }catch(Exception e){
            e.printStackTrace();
        }

    }

注意：程序中的

这些地方一定要和excel模板文件中相对应，否则会出错

导出测试结果：

导出成功；