Java操作Excle（基于Poi）

有一次有个同事问我会不会有java操作Excle，回答当然是不会了！感觉被嘲讽了，于是开始寻找度娘，找到个小例子，结果越写越有意思，最后就成就了这个工具类。

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map.Entry;
 import java.util.Set;

 import org.apache.poi.hssf.usermodel.HSSFCell;
 import org.apache.poi.hssf.usermodel.HSSFCellStyle;
 import org.apache.poi.hssf.usermodel.HSSFFont;
 import org.apache.poi.hssf.usermodel.HSSFRow;
 import org.apache.poi.hssf.usermodel.HSSFSheet;
 import org.apache.poi.hssf.usermodel.HSSFWorkbook;
 import org.apache.poi.hssf.util.HSSFColor;
 import org.apache.poi.ss.usermodel.BorderStyle;
 import org.apache.poi.ss.usermodel.Cell;
 import org.apache.poi.ss.usermodel.CellStyle;
 import org.apache.poi.ss.usermodel.DataFormat;
 import org.apache.poi.ss.usermodel.FillPatternType;
 import org.apache.poi.ss.usermodel.HorizontalAlignment;
 import org.apache.poi.ss.usermodel.IndexedColors;
 import org.apache.poi.ss.usermodel.Row;
 import org.apache.poi.ss.usermodel.Sheet;
 import org.apache.poi.ss.usermodel.VerticalAlignment;
 import org.apache.poi.ss.usermodel.Workbook;
 import org.apache.poi.ss.util.CellAddress;
 import org.apache.poi.xssf.usermodel.*;
 import org.apache.poi.xssf.usermodel.XSSFFont;
 import org.apache.poi.xssf.usermodel.XSSFWorkbook;

 /**
  *
  * 这是一个对excle操作的类 有可以 读取 创建 修改
  *
  * 对标题提供了基本的样式 包括 字体 背景颜色 边框 内容还未提供样式 后续处理吧
  *
  * @author heyt
  * @param
  *
  */

 public class Excle {

     public static File excelFile;// 没有用该变量 后续一定变为用这个

     public static InputStream fileInStream;// 没有用该变量 后续一定变为用这个

     public static OutputStream fileOutStream;// 没有用该变量 后续一定变为用这个

     public static Workbook workBook;// 没有用该变量 后续一定变为用这个

     /**
      * 读取指定路径的Excel文件，并且按行获取数据记录到list中，最后返回结果为装有多行list对象的list数据。 即：一行数据装进一个list
      *
      * 注意：有几个sysout 输出语句是当时测试时候用的 如果将来这个方法处问题了 就解开观察一下
      *
      * @param cFilePath
      * @return
      */
     public List<List<String>> readExcle(String cFilePath) {
         List<List<String>> sumLists = new ArrayList<List<String>>();
         List<String> sumList = null;
         boolean isE2007 = false; // 判断是否是excel2007格式
         if (cFilePath.endsWith(".xlsx"))
             isE2007 = true;
         try {
             InputStream input = new FileInputStream(cFilePath); // 建立输入流
             Workbook wb = null;
             // 根据文件格式(2003或者2007)来初始化
             if (isE2007)
                 wb = new XSSFWorkbook(input);
             else
                 wb = new HSSFWorkbook(input);
             Sheet sheet = wb.getSheetAt(0); // 获得第一个表单
             Iterator<Row> rows = sheet.rowIterator(); // 获得第一个表单的迭代器
             while (rows.hasNext()) {
                 Row row = rows.next(); // 获得行数据
                 Iterator<Cell> cells = row.cellIterator(); // 获得第一行的迭代器
                 // System.out.println("现在是读的第：" + row.getRowNum() + "行");
                 sumList = new ArrayList<String>();
                 // 遍历一行数据装到subList中
                 int count = 0;
                 int countRes = 0;
                 while (cells.hasNext()) {
                     Cell cell = cells.next();
                     // System.out.println("读取的第:" + cell.getColumnIndex() + "列" + ",应该写第：" +
                     // countRes + "列");
                     count = cell.getColumnIndex();
                     int res = count - countRes;
                     // System.out.println("应该加：" + res + "列的空格");
                     if (res == 0) {
                         sumList.add(cell.toString());
                         ++countRes;
                     } else {
                         for (int i = 0; i < res; i++) {
                             sumList.add(" ");// 空位补空格
                             ++countRes;
                         }
                         sumList.add(cell.toString());
                         ++countRes;
                     }
                 }
                 sumLists.add(sumList);
             }
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return sumLists;
     }
     /**
      * 根据一个excle的绝对路径,得到一个excle的所有sheet的名称保存到一个list里返回
      *
      * @param cFilePath
      * @return list<String>
      */
     public List<String> getSheetCountName(String cFilePath) {
         List<String> sheetNames = new ArrayList<String>();
         boolean isE2007 = false; // 判断是否是excel2007格式
         if (cFilePath.endsWith(".xlsx"))
             isE2007 = true;
         try {
             InputStream input = new FileInputStream(cFilePath); // 建立输入流
             Workbook wb = null;
             // 根据文件格式(2003或者2007)来初始化
             if (isE2007)
                 wb = new XSSFWorkbook(input);
             else
                 wb = new HSSFWorkbook(input);
             int results = wb.getNumberOfSheets();
             for (int i = 0; i < results; i++) {
                 sheetNames.add(wb.getSheetName(i));
             }
             return sheetNames;
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return null;// 正常情况下永远都不会返回一个null吧
     }
     /**
      * 这个是读一个exlce中的一个sheet,cFilePath是excle的绝对路径，
      * index是sheet的下标，一般配合本类中的getSheetCountName()方法使用即可
      */
     public List<List<String>> readExcleOneSheet(String cFilePath, int index) {
         List<List<String>> sumLists = new ArrayList<List<String>>();
         List<String> sumList = null;
         boolean isE2007 = false; // 判断是否是excel2007格式
         if (cFilePath.endsWith(".xlsx"))
             isE2007 = true;
         try {
             InputStream input = new FileInputStream(cFilePath); // 建立输入流
             Workbook wb = null;
             // 根据文件格式(2003或者2007)来初始化
             if (isE2007)
                 wb = new XSSFWorkbook(input);
             else
                 wb = new HSSFWorkbook(input);
             Sheet sheet = wb.getSheetAt(index); // 获得第一个表单
             Iterator<Row> rows = sheet.rowIterator(); // 获得第一个表单的迭代器
             while (rows.hasNext()) {
                 Row row = rows.next(); // 获得行数据
                 Iterator<Cell> cells = row.cellIterator(); // 获得第一行的迭代器
                 // System.out.println("现在是读的第：" + row.getRowNum() + "行");
                 sumList = new ArrayList<String>();
                 // 遍历一行数据装到subList中
                 int count = 0;
                 int countRes = 0;
                 while (cells.hasNext()) {
                     Cell cell = cells.next();
                     // System.out.println("读取的第:" + cell.getColumnIndex() + "列" + ",应该写第：" +
                     // countRes + "列");
                     count = cell.getColumnIndex();
                     int res = count - countRes;
                     // System.out.println("应该加：" + res + "列的空格");
                     if (res == 0) {
                         sumList.add(cell.toString());
                         ++countRes;
                     } else {
                         for (int i = 0; i < res; i++) {
                             sumList.add(" ");// 空位补空格
                             ++countRes;
                         }
                         sumList.add(cell.toString());
                         ++countRes;
                     }
                 }
                 sumLists.add(sumList);
             }
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return sumLists;
     }

     /**
      * 对excle提供样式 说实话很简陋 哈哈
      *
      * @param wb
      * @param endStr
      * @return
      */
     public static CellStyle initStyle(Workbook wb, final String endStr) {

         if (endStr.equals("xlsx")) {
             XSSFCellStyle scs = (XSSFCellStyle) wb.createCellStyle();
             scs.setAlignment(HorizontalAlignment.CENTER);// 居中
             scs.setVerticalAlignment(VerticalAlignment.CENTER);

             scs.setBorderBottom(BorderStyle.THIN); // 下边框
             scs.setBorderLeft(BorderStyle.THIN);// 左边框
             scs.setBorderTop(BorderStyle.THIN);// 上边框
             scs.setBorderRight(BorderStyle.THIN);// 右边框

             scs.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
             scs.setFillPattern(FillPatternType.SOLID_FOREGROUND);
             scs.setFillPattern(FillPatternType.SOLID_FOREGROUND);

             XSSFFont xf = (XSSFFont) wb.createFont();

             xf.setFontName("微软雅黑");
             xf.setFontHeightInPoints((short) 10);

             scs.setFont(xf);
             return scs;
         }
         if (endStr.equals("xls")) {

             HSSFCellStyle hcs = (HSSFCellStyle) wb.createCellStyle();
             hcs.setAlignment(HorizontalAlignment.CENTER);// 居中
             hcs.setVerticalAlignment(VerticalAlignment.CENTER);
             hcs.setBorderBottom(BorderStyle.THIN); // 下边框
             hcs.setBorderLeft(BorderStyle.THIN);// 左边框
             hcs.setBorderTop(BorderStyle.THIN);// 上边框
             hcs.setBorderRight(BorderStyle.THIN);// 右边框
             hcs.setFillForegroundColor(IndexedColors.GREY_40_PERCENT.getIndex());
             hcs.setFillPattern(FillPatternType.SOLID_FOREGROUND);
             hcs.setFillPattern(FillPatternType.SOLID_FOREGROUND);
             HSSFFont hf = (HSSFFont) wb.createFont();
             hf.setFontName("微软雅黑");
             hf.setFontHeightInPoints((short) 10);

             hcs.setFont(hf);
             return hcs;
         }
         return null;
     }

     /**
      * 对excle提供样式 说实话很简陋 哈哈
      *
      * @param wb
      * @param endStr
      * @return
      */
     public static CellStyle initStyle2(Workbook wb, final String endStr) {

         if (endStr.equals("xlsx")) {
             XSSFCellStyle scs = (XSSFCellStyle) wb.createCellStyle();
             scs.setAlignment(HorizontalAlignment.LEFT);// 居中
             scs.setVerticalAlignment(VerticalAlignment.CENTER);
             scs.setBorderBottom(BorderStyle.THIN); // 下边框
             scs.setBorderLeft(BorderStyle.THIN);// 左边框
             scs.setBorderTop(BorderStyle.THIN);// 上边框
             scs.setBorderRight(BorderStyle.THIN);// 右边框

             // scs.setFillForegroundColor(IndexedColors.GREY_25_PERCENT.getIndex());
             // scs.setFillPattern(FillPatternType.SOLID_FOREGROUND);
             // scs.setFillPattern(FillPatternType.SOLID_FOREGROUND);

             XSSFFont xf = (XSSFFont) wb.createFont();
             xf.setFontName("黑体");
             xf.setFontHeightInPoints((short) 10);
             scs.setFont(xf);
             return scs;
         }
         if (endStr.equals("xls")) {

             HSSFCellStyle hcs = (HSSFCellStyle) wb.createCellStyle();
             hcs.setAlignment(HorizontalAlignment.LEFT);// 居中
             hcs.setVerticalAlignment(VerticalAlignment.CENTER);
             hcs.setBorderBottom(BorderStyle.THIN); // 下边框
             hcs.setBorderLeft(BorderStyle.THIN);// 左边框
             hcs.setBorderTop(BorderStyle.THIN);// 上边框
             hcs.setBorderRight(BorderStyle.THIN);// 右边框
             // hcs.setFillForegroundColor(IndexedColors.BLUE.getIndex());
             // hcs.setFillPattern(FillPatternType.SOLID_FOREGROUND);
             // hcs.setFillPattern(FillPatternType.SOLID_FOREGROUND);
             HSSFFont hf = (HSSFFont) wb.createFont();
             hf.setFontName("黑体");
             hf.setFontHeightInPoints((short) 10);
             hcs.setFont(hf);
             return hcs;
         }

         return null;
     }

     /**
      * @param filePath
      *            文件路径
      * @param str
      *            表头的列名
      * @param sheetName
      *            顾名思义
      * @return
      */
     public static boolean writeExcle(String filePath, String[] str, String sheetName) {

         String tFilePath = initFile(filePath);

         boolean bo = true;
         Workbook wb = null;
         CellStyle cs = null;
         // 定义一个新的工作簿
         if (tFilePath.endsWith(".xlsx")) {
             wb = new XSSFWorkbook();
             cs = initStyle(wb, "xlsx");
         } else if (tFilePath.endsWith(".xls")) {
             wb = new HSSFWorkbook();
             cs = initStyle(wb, "xls");
         } else
             bo = false;
         // 创建sheet1
         Sheet sheet = wb.createSheet(sheetName);

         // 创建行
         Row row = sheet.createRow(0);

         // DataFormat df= wb.createDataFormat();

         // scs.setDataFormat(df.getFormat("@"));

         for (int i = 0; i < str.length; i++) {

             // sheet.autoSizeColumn(i);//宽度自适应 亲测不管用

             row.createCell(i).setCellStyle(cs);
             row.getCell(i).setCellValue(str[i]);// 创建单元格 表头

         }
         // 写入
         try {
             FileOutputStream fileOutputStream = new FileOutputStream(tFilePath);
             wb.write(fileOutputStream);
             fileOutputStream.close();
         } catch (IOException e) {
             e.printStackTrace();
         }

         return bo;
     }

     /**
      * @param filePath
      *            文件路径
      * @param str
      *            表头的列名
      * @param sheetName
      *            顾名思义
      * @param lis
      *            填入exlce的数据
      * @return
      */
     protected static boolean writeExcle(String filePath, String[] str, String sheetName, List<List<String>> lis) {

         boolean bo = true;
         Workbook wb = null;
         String tFilePath = initFile(filePath);
         CellStyle cs = null;
         CellStyle cs2 = null;
         // 定义一个新的工作簿
         if (tFilePath.endsWith(".xlsx")) {
             wb = new XSSFWorkbook();
             cs = initStyle(wb, "xlsx");
             cs2 = initStyle2(wb, "xlsx");
         } else if (tFilePath.endsWith(".xls")) {
             wb = new HSSFWorkbook();
             cs = initStyle(wb, "xls");
             cs2 = initStyle2(wb, "xls");
         } else
             bo = false;

         // 创建sheet1
         Sheet sheet = wb.createSheet(sheetName);
         // sheet.autoSizeColumn(0);//宽度自适应

         // 创建行
         Row row = sheet.createRow(0);

         for (int k = 0; k < str.length; k++) {

             row.createCell(k).setCellValue(str[k]);// 创建单元格 表头
             row.getCell(k).setCellStyle(cs);
         }

         for (int i = 0; i < lis.size(); i++) {

             Row row2 = sheet.createRow(i + 1);

             for (int j = 0; j < lis.get(i).size(); j++) {

                 row2.createCell(j).setCellValue(lis.get(i).get(j).toString());

                 row2.getCell(j).setCellStyle(cs2);

                 // 这是不是应该也加一个样式呢 这就是个问题了 怎么完善呢 后续处理吧 initStyle2() return cellStyle;

             }
         }

         // 写入
         try {
             FileOutputStream fileOutputStream = new FileOutputStream(tFilePath);
             wb.write(fileOutputStream);
             wb.close();
             fileOutputStream.close();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

         return bo;
     }

     public static boolean writeExcle(String filePath) {

         boolean bo = true;
         Workbook wb = null;
         String tFilePath = initFile(filePath);
         // 定义一个新的工作簿
         if (tFilePath.endsWith(".xlsx")) {
             wb = new XSSFWorkbook();
         } else if (tFilePath.endsWith(".xls"))
             wb = new HSSFWorkbook();
         else
             bo = false;
         // 创建sheet1
         Sheet sheet = wb.createSheet("sheet1");

         // 创建行
         Row row = sheet.createRow(0);

         // 写入
         try {
             FileOutputStream fileOutputStream = new FileOutputStream(tFilePath);
             wb.write(fileOutputStream);
             wb.close();
         } catch (IOException e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }

         return bo;
     }

     // 配合initFile 方法的变量
     public static int tOneCountForInitFile = 1;

     /**
      * 判断当前系统中是否存在该文件，如果存在则换一个名字， 也就是不会造成文件的内容覆盖。
      *
      * @param filePath
      * @return 文件名
      */
     public static String initFile(String filePath) {

         String tFilePath = filePath.replace("//", "\\");

         tFilePath = tFilePath.replace("/", "\\");

         String ss = "";
         // 才疏学浅，真心不知道怎么处理，只能用这样的苯方法获取文件名了
         ss = tFilePath.substring(0, tFilePath.lastIndexOf("\\") + 1);

         boolean bo = false;

         File[] files = new File(ss).listFiles();

         for (File file : files) {

             String str2 = file.getPath();

             if (!str2.contains("."))// 文件夹就不需要校验了
                 continue;

             if (str2.equals(filePath)) {
                 bo = true;
                 break;
             }
         }

         if (bo) {

             if (tFilePath.contains("(")) {

                 tOneCountForInitFile++;
                 tFilePath = filePath.substring(0, filePath.lastIndexOf("(")) + "(" + tOneCountForInitFile + ")"
                         + filePath.substring(filePath.lastIndexOf("."), filePath.length());

             } else {
                 tFilePath = filePath.substring(0, filePath.lastIndexOf(".")) + "(" + tOneCountForInitFile + ")"
                         + filePath.substring(filePath.lastIndexOf("."), filePath.length());

             }
             return initFile(tFilePath);
         }
         return tFilePath;
     }

     /**
      * @param sourceString
      *            源字符串
      * @param targetString
      *            目标字符串
      * @param count
      *            第几次出现
      * @param flag
      *            查找方向（正向查找，反向查找）
      * @return 出现的位置（都是正向开始计算）
      *
      */

     public static int indexWithCount(String sourceString, String targetString, int count, int flag) {

         int lengthCount = 0;
         if (!sourceString.contains(targetString)) // 判断是否存在目标字符串
             return -1;
         int strHaveHowCount = strHaveHowCount(sourceString, targetString); // 目标字符串出现了几次
         if (strHaveHowCount < count)
             return -1;
         if (flag == -1) {
             count = strHaveHowCount - count + 1;
         } else if (flag == 1 || flag == 0) {
             count = count;
         } else
             return -1;
         int j = 0;
         for (int i = 0; i < count; i++) {
             if (count == 1) {
                 lengthCount = sourceString.indexOf(targetString);
                 return lengthCount;
             } else {
                 lengthCount = sourceString.indexOf(targetString, j);
                 j = lengthCount + 1;
             }
         }
         return lengthCount;
     }

     /**
      * @param sourceString
      *            源字符串
      * @param targetString
      *            目标字符串
      * @param count
      *            第几次出现
      * @return 出现的位置（都是正向开始计算） indexWithCount的方法的重构 没写最后一个参数是 默认从请往后查询
      */
     protected static int indexWithCount(String sourceString, String targetString, int count) {

         int lengthCount = 0;
         if (!sourceString.contains(targetString)) // 判断是否存在目标字符串
             return -1;
         int strHaveHowCount = strHaveHowCount(sourceString, targetString); // 目标字符串出现了几次
         if (strHaveHowCount < count)
             return -1;
         int j = 0;
         for (int i = 0; i < count; i++) {
             if (count == 1) {
                 lengthCount = sourceString.indexOf(targetString);
                 return lengthCount;
             } else {
                 lengthCount = sourceString.indexOf(targetString, j);
                 j = lengthCount + 1;
             }
         }
         return lengthCount;
     }

     /**
      * 次方法就是判断出一个字符串在另一个中出出现的多少次
      *
      * @param a
      *            被匹配的长字符串
      * @param b
      *            匹配的短字符串
      * @return 匹配次数
      */
     public static int strHaveHowCount(String sourceStr, String targetStr) {

         if (sourceStr.length() < targetStr.length()) {
             return 0;
         }
         char[] a_t = sourceStr.toCharArray();
         int count = 0;
         for (int i = 0; i <= sourceStr.length() - targetStr.length(); i++) {// 条件必须用 <= 要不然会少比较一次
             StringBuffer buffer = new StringBuffer();
             for (int j = 0; j < targetStr.length(); j++) {
                 buffer.append(a_t[i + j]);
             }
             if (buffer.toString().equals(targetStr)) {
                 count++;
             }
         }
         return count;
     }

     /**
      *
      * @param sourceStr
      *            源字符串
      * @param targetStr
      *            目标字符串
      * @return count 次数（注意“aaa”找“aa”这样算出现一次）
      */
     public static int strHaveHowCount2(String sourceStr, String targetStr) {

         int count = 0;

         if (sourceStr.length() < targetStr.length()) {
             return count;
         }

         int bigLength = sourceStr.length();
         int smallLength = targetStr.length();

         String newSourceStr = "";

         if (sourceStr.contains(targetStr)) {
             newSourceStr = sourceStr.replace(targetStr, "");
         } else {
             return 0;

         }
         int newBigLength = newSourceStr.length();

         count = (bigLength - newBigLength) / smallLength;

         return count;
     }

     /**
      * 这个方法是读一个文本格式的文件，按行读取将内容放到一个List里面
      *
      * @param filePath
      * @return
      */
     public static List<String> readOneFile(String filePath) {
         List<String> resultList = new ArrayList<String>();// 获取文件中每一行的字符串
         int count = 0;
         try {
             // String encoding = "UTF-8";
             File file = new File(filePath);
             if (file.isFile() && file.exists()) { // 判断文件是否存在
                 InputStreamReader read = new InputStreamReader(new FileInputStream(file));// 考虑到编码格式
                 BufferedReader bufferedReader = new BufferedReader(read);
                 String lineTxt = null;
                 while ((lineTxt = bufferedReader.readLine()) != null) {
                     resultList.add(lineTxt);
                     // System.out.println(lineTxt);
                     count++;
                 }
                 count = 0;
                 read.close();
             } else {
                 System.err.println("找不到指定的文件");
             }
         } catch (Exception e) {
             System.err.println("读取文件内容出错");
             e.printStackTrace();
         }
         return resultList;
     }

     /**
      * 这个是借用了读取单个excle的方法 可以完成对一个文件夹下的所有excle内容的读取（只能读到每个excle的第一个sheet,后续完善）
      *
      * @param filePaths
      * @return
      */
     public List<List<String>> readExcleAll(String filePaths) {

         File[] files = new File(filePaths).listFiles();

         List<List<String>> lis = new ArrayList<List<String>>();

         for (int i = 0; i < files.length; i++) {

             List<List<String>> li = new ArrayList<List<String>>();

             li = readExcle(files[i].getPath());

             for (int j = 0; j < li.size(); j++) {

                 lis.add(li.get(j));
             }
         }

         System.out.println("获取多个excle后，一共得到:" + lis.size() + "====行的数据");
         return lis;
     }

     /**
      * 这是为getFileList() 提供的辅助属性，用于存放所符合条件的路径
      */
     public List<String> oneLis = new ArrayList<String>();

     /**
      * 获取一个文件夹下的所有文件名的绝对路径,这个方法是getFileList(String filepath)的方法的重写 可以获得 规定后缀的文件
      *
      * @param filepath
      * @return
      */
     public List<String> getFileList(String filepath, String engStr) {

         File file = new File(filepath);
         File[] files = file.listFiles(); // 该文件目录下文件全部放入数组
         if (files != null) {
             for (int i = 0; i < files.length; i++) {
                 String fileName = files[i].getName();
                 if (files[i].isDirectory()) { // 判断是文件还是文件夹
                     getFileList(files[i].getAbsolutePath(), engStr); // 获取文件绝对路径
                 } else {
                     if (files[i].getAbsolutePath().endsWith(engStr))
                         oneLis.add(files[i].getAbsolutePath()); // 将符合规定后缀的文件收集到 一个集合里
                 }
             }
         }
         // 用于输出一个文件夹地址下存在多少个文件 利用了递归方法 每一条
         // System.out.println("一同获得" + oneLis.size() + "条路径！！！！！");
         return oneLis;
     }

     /**
      * 获取一个文件夹下的所有文件名的绝对路径
      *
      * @param filepath
      * @return
      */
     public List<String> getFileList(String filepath) {

         File file = new File(filepath);
         File[] files = file.listFiles(); // 该文件目录下文件全部放入数组
         if (files != null) {
             for (int i = 0; i < files.length; i++) {
                 String fileName = files[i].getName();
                 if (files[i].isDirectory()) { // 判断是文件还是文件夹
                     getFileList(files[i].getAbsolutePath()); // 获取文件绝对路径
                 } else {
                     oneLis.add(files[i].getAbsolutePath());
                 }
             }
         }
         System.out.println("一同获得" + oneLis.size() + "条路径！！！！！");
         return oneLis;
     }

     /**
      *
      * 读取exce的全部sheet的数据，把每一个sheet的名称放到每一行数据的最后一列
      *
      * @param cFilePath
      * @return
      */
     public static List<List<String>> readExcleAllSheet(String cFilePath) {
         List<List<String>> sumLists = new ArrayList<List<String>>();
         ArrayList<String> sumList = null;
         boolean isE2007 = false; // 判断是否是excel2007格式
         if (cFilePath.endsWith(".xlsx"))
             isE2007 = true;
         try {
             InputStream input = new FileInputStream(cFilePath); // 建立输入流
             Workbook wb = null;
             // 根据文件格式(2003或者2007)来初始化
             if (isE2007)
                 wb = new XSSFWorkbook(input);
             else
                 wb = new HSSFWorkbook(input);
             Sheet sheet = null;// 获得第一个表单

             for (int j = 0; j < wb.getNumberOfSheets(); j++) {
                 sheet = wb.getSheetAt(j);

                 if (sheet == null)
                     continue;

                 Iterator<Row> rows = sheet.rowIterator(); // 获得第一个表单的迭代器
                 while (rows.hasNext()) {
                     Row row = rows.next(); // 获得行数据
                     Iterator<Cell> cells = row.cellIterator(); // 获得第一行的迭代器
                     sumList = new ArrayList<String>();

                     // 遍历一行数据装到subList中
                     int count = 0;
                     int countRes = 0;
                     while (cells.hasNext()) {
                         Cell cell = cells.next();
                         // System.out.println(cell.getColumnIndex());
                         count = cell.getColumnIndex();

                         int res = count - countRes;
                         // System.out.println("应该加："+res);
                         if (res == 0) {
                             sumList.add(new String(cell.toString()));
                             countRes++;
                         } else {
                             for (int i = 0; i < res; i++) {
                                 sumList.add(" ");// 空位补空格
                                 countRes++;
                             }
                             sumList.add(new String(cell.toString()));
                         }
                     }
                     count = 0;
                     countRes = 0;
                     sumList.add(sheet.getSheetName());
                     sumLists.add(sumList);

                 }
             }
         } catch (IOException ex) {
             ex.printStackTrace();
         }
         return sumLists;
     }

     /**
      * 这个参数是一个set集合 为了处理那种重复数据
      *
      * @param set
      *            需要的内容
      * @param tPath
      *            文件绝对地址
      * @return 虽然是boolean类型 但是没有做任何操作 后续需要在说吧
      */
     public static boolean writeFileAtPath(Set set, String tPath) {

         Excle ex = new Excle();
         Iterator iterator = set.iterator();
         String endPath = ex.initFile(tPath);// 将生成的sql放到指点的文件地址
         File file = new File(endPath);
         FileWriter fw = null;
         BufferedWriter writer = null;
         try {
             fw = new FileWriter(file);
             writer = new BufferedWriter(fw);
             while (iterator.hasNext()) {
                 writer.write(iterator.next().toString());
                 writer.newLine();// 换行
             }
             writer.flush();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 writer.close();
                 fw.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return true;
     }

     /**
      * 这个参数是一个list集合 可以做到有序
      *
      * @param list
      *            需要的内容
      * @param tPath
      *            文件的绝对地址
      * @return 虽然是boolean类型 但是没有做任何操作 后续需要在说吧
      */
     public static boolean writeFileAtPath(List list, String tPath) {

         Excle ex = new Excle();
         Iterator iterator = list.iterator();
         String endPath = ex.initFile(tPath);// 将生成的sql放到指点的文件地址
         File file = new File(endPath);
         FileWriter fw = null;
         BufferedWriter writer = null;
         try {
             fw = new FileWriter(file);
             writer = new BufferedWriter(fw);
             while (iterator.hasNext()) {
                 writer.write(iterator.next().toString());
                 writer.newLine();// 换行
             }
             writer.flush();
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             try {
                 writer.close();
                 fw.close();
             } catch (IOException e) {
                 e.printStackTrace();
             }
         }
         return false;
     }

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

         //initFile("E:\\nety");

     }

 }