原创/朱季谦

这款工具是笔者在2018年初开发完成的，时隔两载，偶然想起这款小工具，于是，决定将其开源，若有人需要做类似Java批处理实现整理文档的工具，可参考该工具逻辑思路来实现。

该工具是运行在windos系统上的，基于bat脚本与jar包形式协同运行，当时开发该工具的背景是，需要定时处理大批量的对账单txt文本信息，将其统一整合到一张Excel文档上，供会计人员获取。在没有该工具之前，项目组上的会计人员，需要每天手动打开大量txt文本，并从每份txt文档里，复制所需信息，将获取到的信息再复制到一份当日的Excel文档里。这个过程花费需近一小时，且重复操作，基于这个原因，当时就开发了这款小工具，供会计人员使用，其带来的效果是，节省了大量整理时间：会计人员只需把每天邮件收到的对账单txt，统一放到指定目录下，点击start启动脚本，就可一键自动批量处理完成。

这个工具在当时的工作环境下，是行之有效的，但若换到另一种领域或者环境，还需二次开发做修改。工具整体实现的逻辑并不复杂，笔者只提供一种解决文档重复工作的小思路，仅做参考学习之用，毕竟，解决问题的本质不在于工具，而在于思路。

下面，就围绕着业务与具体实现来结束该自动处理工具。

整体结构如下：

1.对账单：将同类型对账单批量放入到对账单文件夹中，同类，即格式几乎一样，但数据不一样，如下所示：

2.对账单集处理结果：批量处理获取到的数据，会统一写入到一份自动生成的Excel文档里，该文档存放在“对账单集处理结果”目录底下；

3.Auto.jar:由Java语言开发的jar包，通过循环读取各txt文本数据，从读取文本指定字段数据，截取其名字与对应保证金、可用资金，再写入到自动生成的Excel文档里。

4.CopyName.bat:bat脚本，将本目录下的txt文件名批量写入到“对账单批量名字集合.txt”；

CopyName.bat如下：

  1. 1 @dir /a-d /b *.txt>对账单批量名字集合.txt

5.Start.bat:bat脚本，主要实现是，将CopyName.bat和“对账单批量名字集合.txt”都复制到“对账单”目录，然后执行CopyName.bat，将该目录底下的所有.txt后缀的文件名，写入到“对账单批量名字集合.txt”，再启动Auto.jar包，该jar会去“对账单批量名字集合.txt”获取所在目录下各txt文档名字，再根据这些名字去读取对应的txt文档。

Start.bat主要代码如下：

  1. 1 @echo off
  2. 2 copy /y CopyName.bat 对账单
  3. 3 copy /y 对账单批量名字集合.txt 对账单
  4. 4 cd D:\批量处理对账单\对账单
  5. 5 call CopyName.bat
  6. 6 java -jar D:\批量处理对账单\Auto.jar

综上，业务人员只需把对账单统一放入到“对账单”目录下：

点击Start.bat启动，就可得到以下指定数据的统一获取：

接下来，就具体分享一下Java部分的逻辑实现：

代码结构

以maven进行jar依赖，主要有Datas、ExportExcelBase、ExportExcleClient、PutExcel四个类。

1.引入依赖

  1.  1 <dependencies>
  2.  2      <dependency>
  3.  3          <groupId>org.apache.poi</groupId>
  4.  4          <artifactId>poi</artifactId>
  5.  5          <version>3.10-FINAL</version>
  6.  6      </dependency>
  7.  7      <dependency>
  8.  8          <groupId>org.projectlombok</groupId>
  9.  9          <artifactId>lombok</artifactId>
  10. 10          <version>1.18.2</version>
  11. 11      </dependency>
  12. 12 </dependencies>

2.设置导出基本类，根据需生成的Excel展示数据设置，笔者案例里只需展示“组合名”，“保证金占用金额”，“可用资金额”三个字段，故只需设置name，margin，avaFunds来接受获取到的值；

  1.  1 package com.put.data;
  2.  2 import lombok.Data;
  3.  3 ​
  4.  4 /**
  5.  5  * 导出数据类
  6.  6  * @author zhujiqian
  7.  7  * @date 2020/10/27 20:09
  8.  8  */
  9.  9 @Data
  10. 10 public class Datas {
  11. 11     //名字
  12. 12     private String name;
  13. 13     //保证金
  14. 14     private String margin;
  15. 15     //可用资金
  16. 16     private String avaFunds;
  17. 17
  18. 18     public Datas(String name, String margin, String avaFunds) {
  19. 19         this.name = name;
  20. 20         this.margin = margin;
  21. 21         this.avaFunds = avaFunds;
  22. 22    }
  23. 23 ​
  24. 24 }

3.设置Excel表格生成类

  1.   1 package com.put.put;
  2.   2 ​
  3.   3 import org.apache.poi.hssf.usermodel.*;
  4.   4 import org.apache.poi.hssf.util.Region;
  5.   5 ​
  6.   6 import java.io.File;
  7.   7 import java.io.FileNotFoundException;
  8.   8 import java.io.FileOutputStream;
  9.   9 import java.io.IOException;
  10.  10 ​
  11.  11 /**
  12.  12  * HSSF - 提供读写Microsoft Excel格式档案的功能。
  13.  13  *
  14.  14  * XSSF - 提供读写Microsoft Excel OOXML格式档案的功能。
  15.  15  *
  16.  16  * @author zhujiqian
  17.  17  * @date 2020/10/27 20:33
  18.  18  */
  19.  19 public class ExportExcelBase {
  20.  20     private HSSFWorkbook hwb=null;
  21.  21     private HSSFSheet sheet=null;
  22.  22     public ExportExcelBase(HSSFWorkbook hwb,HSSFSheet sheet){
  23.  23         this.hwb=hwb;
  24.  24         this.sheet=sheet;
  25.  25    }
  26.  26     public HSSFWorkbook getHwb() {
  27.  27         return hwb;
  28.  28    }
  29.  29     public void setHwb(HSSFWorkbook hwb) {
  30.  30         this.hwb = hwb;
  31.  31    }
  32.  32     public HSSFSheet getSheet() {
  33.  33         return sheet;
  34.  34    }
  35.  35     public void setSheet(HSSFSheet sheet) {
  36.  36         this.sheet = sheet;
  37.  37    }
  38.  38 ​
  39.  39     /**
  40.  40      * 创建设置表格头
  41.  41      */
  42.  42     public void createNormalHead(String headString,int colSum){
  43.  43         //创建表格标题行，第一行
  44.  44         HSSFRow row=this.sheet.createRow(0);
  45.  45         //创建指定行的列，第一列
  46.  46         HSSFCell cell=row.createCell(0);
  47.  47         //设置标题行默认行高
  48.  48         row.setHeight((short) 500);
  49.  49         //设置表格内容类型：0-数值型；1-字符串；2-公式型；3-空值；4-布尔型；5-错误
  50.  50         cell.setCellType(1);
  51.  51         //设置表格标题内容
  52.  52         cell.setCellValue(new HSSFRichTextString(headString));
  53.  53         // 指定合并区域
  54.  54         this.sheet.addMergedRegion(new Region(0, (short)0, 0, (short)colSum));
  55.  55         // 定义单元格格式，添加单元格表样式，并添加到工作簿
  56.  56         HSSFCellStyle cellStyle=this.hwb.createCellStyle();
  57.  57         // 设置单元格水平对齐居中类型
  58.  58         cellStyle.setAlignment(HSSFCellStyle.ALIGN_CENTER);
  59.  59         // 指定单元格垂直居中对齐
  60.  60         cellStyle.setVerticalAlignment(HSSFCellStyle.VERTICAL_CENTER);
  61.  61         // 指定单元格自动换行
  62.  62         cellStyle.setWrapText(true);
  63.  63         //设置字体
  64.  64         HSSFFont font=this.hwb.createFont();
  65.  65         font.setBoldweight((short) 700);
  66.  66         font.setFontName("宋体");
  67.  67         font.setFontHeight((short) 300);
  68.  68         cellStyle.setFont(font);
  69.  69         cell.setCellStyle(cellStyle);
  70.  70    }
  71.  71 ​
  72.  72     /**
  73.  73      *表单第二行
  74.  74      * @param params
  75.  75      * @param colSum
  76.  76      */
  77.  77     public void createNormalTwoRow(String[] params,int colSum){
  78.  78         HSSFRow row1=this.sheet.createRow(1);
  79.  79         row1.setHeight((short) 300);
  80.  80         HSSFCell cell2=row1.createCell(0);
  81.  81         cell2.setCellType(1);
  82.  82         cell2.setCellValue(new HSSFRichTextString("统计时间"+params[0]+"至"+params[1]));
  83.  83         this.sheet.addMergedRegion(new Region(1, (short) 0,1,(short)colSum));
  84.  84         HSSFCellStyle cellStyle=this.hwb.createCellStyle();
  85.  85         cellStyle.setAlignment((short) 2);
  86.  86         cellStyle.setVerticalAlignment((short) 1);
  87.  87         cellStyle.setWrapText(true);
  88.  88         HSSFFont font=this.hwb.createFont();
  89.  89         font.setBoldweight((short) 700);
  90.  90         font.setFontName("宋体");
  91.  91         font.setFontHeight((short) 250);
  92.  92         cellStyle.setFont(font);
  93.  93         cell2.setCellStyle(cellStyle);
  94.  94    }
  95.  95 ​
  96.  96 ​
  97.  97     /**
  98.  98      * 表单内容
  99.  99      * @param wb
  100. 100      * @param row
  101. 101      * @param col
  102. 102      * @param align
  103. 103      * @param val
  104. 104      */
  105. 105     public void cteateCell(HSSFWorkbook wb, HSSFRow row, int col, short align, String val) {
  106. 106         HSSFCell cell = row.createCell(col);
  107. 107         cell.setCellType(1);
  108. 108         cell.setCellValue(new HSSFRichTextString(val));
  109. 109         HSSFCellStyle cellstyle = wb.createCellStyle();
  110. 110         cellstyle.setAlignment(align);
  111. 111         cell.setCellStyle(cellstyle);
  112. 112    }
  113. 113 ​
  114. 114 ​
  115. 115     /**
  116. 116      * 文档输出流
  117. 117      * @param fileName
  118. 118      */
  119. 119     public void outputExcle(String fileName) {
  120. 120         FileOutputStream fos = null;
  121. 121         try {
  122. 122             fos = new FileOutputStream(new File(fileName));
  123. 123             this.hwb.write(fos);
  124. 124             fos.close();
  125. 125        } catch (FileNotFoundException var4) {
  126. 126             var4.printStackTrace();
  127. 127        } catch (IOException var5) {
  128. 128             var5.printStackTrace();
  129. 129        }
  130. 130    }
  131. 131 }

4.设置Excel根据数据导出类

  1.  1 package com.put.put;
  2.  2 ​
  3.  3 ​
  4.  4 import com.put.data.Datas;
  5.  5 import org.apache.poi.hssf.usermodel.*;
  6.  6 ​
  7.  7 import java.text.SimpleDateFormat;
  8.  8 import java.util.Date;
  9.  9 import java.util.List;
  10. 10 ​
  11. 11 /**
  12. 12  * TODO
  13. 13  *
  14. 14  * @author zhujiqian
  15. 15  * @date 2020/10/27 20:24
  16. 16  */
  17. 17 public class ExportExcleClient {
  18. 18     private HSSFWorkbook hwb=null;
  19. 19     private HSSFSheet sheet=null;
  20. 20 ​
  21. 21     ExportExcelBase exportExcel = null;
  22. 22     SimpleDateFormat df = new SimpleDateFormat("yyyy年MM月dd日");
  23. 23 ​
  24. 24     public ExportExcleClient() {
  25. 25         this.hwb = new HSSFWorkbook();
  26. 26         this.exportExcel = new ExportExcelBase(this.hwb, this.sheet);
  27. 27    }
  28. 28 ​
  29. 29     /**
  30. 30      * 导出Excel
  31. 31      * @return
  32. 32      */
  33. 33     public String exportExcel() {
  34. 34         String a = this.df.format(new Date()) + "对账单集合.xls";
  35. 35         String b = "D:\\批量处理对账单\\对账单集处理结果\\" + a;
  36. 36         this.exportExcel.outputExcle(b);
  37. 37         return b;
  38. 38    }
  39. 39 ​
  40. 40     /**
  41. 41      * 设置导出格式
  42. 42      * @param data
  43. 43      * @return
  44. 44      */
  45. 45     public String alldata(List<Datas> data) {
  46. 46         if (data.size() != 0) {
  47. 47             this.sheet = this.exportExcel.getHwb().createSheet("对账单集合");
  48. 48             this.exportExcel.setSheet(this.sheet);
  49. 49             int number = 2;
  50. 50 ​
  51. 51             for(int i = 0; i < number; ++i) {
  52. 52                 this.sheet.setColumnWidth(i, 8000);
  53. 53            }
  54. 54 ​
  55. 55             HSSFCellStyle cellStyle = this.hwb.createCellStyle();
  56. 56             cellStyle.setAlignment((short)2);
  57. 57             cellStyle.setVerticalAlignment((short)1);
  58. 58             cellStyle.setWrapText(true);
  59. 59             HSSFFont font = this.hwb.createFont();
  60. 60             font.setBoldweight((short)700);
  61. 61             font.setFontName("宋体");
  62. 62             font.setFontHeight((short)200);
  63. 63             cellStyle.setFont(font);
  64. 64             this.exportExcel.createNormalHead("对账单整合表", number);
  65. 65             String[] params = new String[]{this.df.format(new Date()), this.df.format(new Date())};
  66. 66             this.exportExcel.createNormalTwoRow(params, number);
  67. 67             HSSFRow row2 = this.sheet.createRow(2);
  68. 68             HSSFCell cell0 = row2.createCell(0);
  69. 69             cell0.setCellStyle(cellStyle);
  70. 70             cell0.setCellValue(new HSSFRichTextString("组合名"));
  71. 71             HSSFCell cell1 = row2.createCell(1);
  72. 72             cell1.setCellStyle(cellStyle);
  73. 73             cell1.setCellValue(new HSSFRichTextString("保证金占用金额"));
  74. 74             HSSFCell cell2 = row2.createCell(2);
  75. 75             cell2.setCellStyle(cellStyle);
  76. 76             cell2.setCellValue(new HSSFRichTextString("可用资金额"));
  77. 77 ​
  78. 78             for(int i = 0; i < data.size(); ++i) {
  79. 79                 System.out.println("==============" + ((Datas)data.get(i)).getName() + " " + ((Datas)data.get(i)).getMargin() + " " + ((Datas)data.get(i)).getAvaFunds());
  80. 80                 HSSFRow row = this.sheet.createRow((short)i + 3);
  81. 81                 this.exportExcel.cteateCell(this.hwb, row, 0, (short)6, ((Datas)data.get(i)).getName());
  82. 82                 this.exportExcel.cteateCell(this.hwb, row, 1, (short)6, ((Datas)data.get(i)).getMargin());
  83. 83                 this.exportExcel.cteateCell(this.hwb, row, 2, (short)6, ((Datas)data.get(i)).getAvaFunds());
  84. 84            }
  85. 85        }
  86. 86 ​
  87. 87         return "";
  88. 88    }
  89. 89 }

5.批量读取txt文本截取指定数据类

  1.   1 package com.put;
  2.   2 ​
  3.   3 import com.put.data.Datas;
  4.   4 import com.put.put.ExportExcleClient;
  5.   5 import java.io.*;
  6.   6 import java.util.ArrayList;
  7.   7 import java.util.List;
  8.   8 ​
  9.   9 /**
  10.  10  * TODO
  11.  11  *
  12.  12  * @author zhujiqian
  13.  13  * @date 2020/10/27 20:08
  14.  14  */
  15.  15 public class PutExcel {
  16.  16     public PutExcel() {
  17.  17    }
  18.  18     public static List<String> readTxtFile1(String TxtName, String filePath) {
  19.  19         ArrayList list = new ArrayList();
  20.  20         try {
  21.  21             System.out.println("该组合：" + TxtName);
  22.  22             File file = new File(filePath);
  23.  23             if (file.isFile() && file.exists()) {
  24.  24                 InputStreamReader read = new InputStreamReader(new FileInputStream(file), "GBK");
  25.  25                 BufferedReader bufferedReader = new BufferedReader(read);
  26.  26                 String lineTxt = null;
  27.  27 ​
  28.  28                 while(true) {
  29.  29                     do {
  30.  30                         if ((lineTxt = bufferedReader.readLine()) == null) {
  31.  31                             read.close();
  32.  32                             return list;
  33.  33                        }
  34.  34                    } while(!lineTxt.contains("持仓保证金:") && !lineTxt.contains("保证金占用:") && !lineTxt.contains("保证金占用 Margin Occupied：") && !lineTxt.contains("保证金占用 Margin Occupied:"));
  35.  35                     String ZiJin;
  36.  36                     int a;
  37.  37                     String b;
  38.  38                     int c;
  39.  39                     String d;
  40.  40                     int e;
  41.  41                     int f;
  42.  42                     String E;
  43.  43                     if (lineTxt.contains("持仓保证金:")) {
  44.  44                         ZiJin = lineTxt.replace(" ", "");
  45.  45                         a = ZiJin.indexOf("持");
  46.  46                         b = ZiJin.substring(a);
  47.  47                         c = b.indexOf(".");
  48.  48                         d = b.substring(0, c + 3);
  49.  49                         e = d.indexOf(":");
  50.  50                         f = d.length();
  51.  51                         E = d.substring(e + 1, f);
  52.  52                         list.add(E);
  53.  53                    } else if (lineTxt.contains("保证金占用:")) {
  54.  54                         ZiJin = lineTxt.replace(" ", "");
  55.  55                         a = ZiJin.indexOf("保");
  56.  56                         b = ZiJin.substring(a);
  57.  57                         c = b.indexOf(".");
  58.  58                         d = b.substring(0, c + 3);
  59.  59                         e = d.indexOf(":");
  60.  60                         f = d.length();
  61.  61                         E = d.substring(e + 1, f);
  62.  62                         list.add(E);
  63.  63                    } else if (lineTxt.contains("保证金占用 Margin Occupied：")) {
  64.  64                         ZiJin = lineTxt.replace(" ", "");
  65.  65                         a = ZiJin.indexOf("保");
  66.  66                         b = ZiJin.substring(a);
  67.  67                         c = b.indexOf(".");
  68.  68                         d = b.substring(0, c + 3);
  69.  69                         e = d.indexOf("：");
  70.  70                         f = d.length();
  71.  71                         E = d.substring(e + 1, f);
  72.  72                         list.add(E);
  73.  73                    } else if (lineTxt.contains("保证金占用 Margin Occupied:")) {
  74.  74                         ZiJin = lineTxt.replace(" ", "");
  75.  75                         a = ZiJin.indexOf("保");
  76.  76                         b = ZiJin.substring(a);
  77.  77                         c = b.indexOf(".");
  78.  78                         d = b.substring(0, c + 3);
  79.  79                         e = d.indexOf(":");
  80.  80                         f = d.length();
  81.  81                         E = d.substring(e + 1, f);
  82.  82                         list.add(E);
  83.  83                    }
  84.  84                }
  85.  85            } else {
  86.  86                 System.out.println("找不到指定的文件");
  87.  87            }
  88.  88        } catch (Exception var16) {
  89.  89             System.out.println("读取文件内容出错");
  90.  90             var16.printStackTrace();
  91.  91        }
  92.  92         return list;
  93.  93    }
  94.  94     public static List<String> readTxtFile2(String TxtName, String filePath) {
  95.  95         ArrayList list = new ArrayList();
  96.  96 ​
  97.  97         try {
  98.  98 ​
  99.  99             System.out.println("该组合：" + TxtName);
  100. 100             File file = new File(filePath);
  101. 101             if (file.isFile() && file.exists()) {
  102. 102                 InputStreamReader read = new InputStreamReader(new FileInputStream(file), "GBK");
  103. 103                 BufferedReader bufferedReader = new BufferedReader(read);
  104. 104                 String lineTxt = null;
  105. 105 ​
  106. 106                 while(true) {
  107. 107                     do {
  108. 108                         if ((lineTxt = bufferedReader.readLine()) == null) {
  109. 109                             read.close();
  110. 110                             return list;
  111. 111                        }
  112. 112                    } while(!lineTxt.contains("可用资金:") && !lineTxt.contains("可用资金 Fund Avail.：") && !lineTxt.contains("可用资金 Fund Avail.:"));
  113. 113                     String ZiJin;
  114. 114                     int a;
  115. 115                     String b;
  116. 116                     int c;
  117. 117                     String d;
  118. 118                     int e;
  119. 119                     int f;
  120. 120                     String E;
  121. 121                     if (lineTxt.contains("可用资金:")) {
  122. 122                         ZiJin = lineTxt.replace(" ", "");
  123. 123                         ZiJin = lineTxt.replace(" ", "");
  124. 124                         a = ZiJin.indexOf("可");
  125. 125                         b = ZiJin.substring(a);
  126. 126                         c = b.indexOf(".");
  127. 127                         d = b.substring(0, c + 3);
  128. 128                         e = d.indexOf(":");
  129. 129                         f = d.length();
  130. 130                         E = d.substring(e + 1, f);
  131. 131                         list.add(E);
  132. 132                    } else if (lineTxt.contains("可用资金 Fund Avail.：")) {
  133. 133                         ZiJin = lineTxt.replace(" ", "");
  134. 134                         ZiJin = lineTxt.replace(" ", "");
  135. 135                         a = ZiJin.indexOf("可");
  136. 136                         b = ZiJin.substring(a);
  137. 137                         c = b.lastIndexOf(".");
  138. 138                         d = b.substring(0, c + 3);
  139. 139                         e = d.indexOf("：");
  140. 140                         f = d.length();
  141. 141                         E = d.substring(e + 1, f);
  142. 142                         list.add(E);
  143. 143                    } else if (lineTxt.contains("可用资金 Fund Avail.:")) {
  144. 144                         lineTxt.replace(" ", "");
  145. 145                         ZiJin = lineTxt.replace(" ", "");
  146. 146                         a = ZiJin.indexOf("可");
  147. 147                         b = ZiJin.substring(a);
  148. 148                         c = b.lastIndexOf(".");
  149. 149                         d = b.substring(0, c + 3);
  150. 150                         e = d.indexOf(":");
  151. 151                         f = d.length();
  152. 152                         E = d.substring(e + 1, f);
  153. 153                         list.add(E);
  154. 154                    }
  155. 155                }
  156. 156            } else {
  157. 157                 System.out.println("找不到指定的文件");
  158. 158            }
  159. 159        } catch (Exception var16) {
  160. 160             System.out.println("读取文件内容出错");
  161. 161             var16.printStackTrace();
  162. 162        }
  163. 163 ​
  164. 164         return list;
  165. 165    }
  166. 166 ​
  167. 167     public static void main(String[] argv) {
  168. 168         String path = "D:\\批量处理对账单\\对账单\\对账单批量名字集合.txt";
  169. 169         List<String> nums = writeToDat(path);
  170. 170         List<Datas> listData = new ArrayList();
  171. 171         for(int i = 0; i < nums.size(); ++i) {
  172. 172             if (!(nums.get(i)).equals("对账单批量名字集合.txt")) {
  173. 173                 listData.add(ZuHe(nums.get(i)));
  174. 174                 System.out.println("--------==========" + ZuHe(nums.get(i)));
  175. 175            }
  176. 176        }
  177. 177 ​
  178. 178         System.out.println("-----------" + listData);
  179. 179         ExportExcleClient client = new ExportExcleClient();
  180. 180         client.alldata(listData);
  181. 181         String url = client.exportExcel();
  182. 182         System.out.println(url);
  183. 183    }
  184. 184 ​
  185. 185     public static Datas ZuHe(String TxtName) {
  186. 186         String address = "D:\\批量处理对账单\\对账单\\" + TxtName;
  187. 187         List<String> r1 = readTxtFile1(TxtName, address);
  188. 188         List<String> r2 = readTxtFile2(TxtName, address);
  189. 189         int c = TxtName.indexOf(".");
  190. 190         String txt = TxtName.substring(0, c);
  191. 191         System.out.println(txt);
  192. 192         System.out.println(r1);
  193. 193         Datas d = null;
  194. 194         if (r1.isEmpty() && r2.isEmpty()) {
  195. 195             if (r1.isEmpty() && r2.isEmpty()) {
  196. 196                 System.out.println(txt + "--" + r1 + "---" + r2);
  197. 197                 d = new Datas(txt, "无", "无");
  198. 198            }
  199. 199        } else {
  200. 200             d = new Datas(txt, r1.get(0), r2.get(0));
  201. 201        }
  202. 202         return d;
  203. 203    }
  204. 204     public static List<String> writeToDat(String path) {
  205. 205         File file = new File(path);
  206. 206         ArrayList list = new ArrayList();
  207. 207         try {
  208. 208             String encoding = "GBK";
  209. 209             InputStreamReader read = new InputStreamReader(new FileInputStream(file), encoding);
  210. 210             BufferedReader bw = new BufferedReader(read);
  211. 211             String line = null;
  212. 212 ​
  213. 213             while((line = bw.readLine()) != null) {
  214. 214                 list.add(line);
  215. 215            }
  216. 216             bw.close();
  217. 217        } catch (IOException var7) {
  218. 218             var7.printStackTrace();
  219. 219        }
  220. 220         return list;
  221. 221    }
  222. 222 }

以上的代码，大部分都是在2018年左右写成，现再阅读，代码风格甚为稚嫩。我没有做大的修改，原因是，想要留住这些代码最初的样子，就像留住刚毕业那会的记忆一般。整体实现逻辑并不算复杂，但再简单的东西，能解决问题，都是值得分享的东西。在此基础上，还可继续完善与扩展，给需要用到的业务人员带来方便。

这是我开源的第一个小工具，以此为励，在以后的日子里，要更加深入地学习，并将所学与所得，多多分享。在我看来，输入的东西，不一定是自己的，但输出的，一定是自己的。

这，就是我喜欢输出的原因之一。

开源一套原创文本处理工具：Java+Bat脚本实现自动批量处理对账单工具的更多相关文章

  1. 利用devcon工具编写bat脚本一键控制系统设备，如开启关闭网卡

    系统WIN7 x64位 下载devcon命令行工具 Download the "Windows Driver Kit (WDK) 7.1.0 from Microsoft: http://w ...

  2. Java静态检测工具/Java代码规范和质量检查简单介绍（转）

    静态检查: 静态测试包括代码检查.静态结构分析.代码质量度量等.它可以由人工进行,充分发挥人的逻辑思维优势,也可以借助软件工具自动进行.代码检查代码检查包括代码走查.桌面检查.代码审查等,主要检查代码 ...

  3. 《深入理解Java虚拟机》虚拟机性能监控与故障处理工具

    上节学习回顾 从课本章节划分,<垃圾收集器>和<内存分配策略>这两篇随笔同属一章节,主要是从理论+实验的手段来讲解JVM的内存处理机制.好让我们对JVM运行机制有一个良好的概念 ...

  4. Java 开发者不容错过的 12 种高效工具

    Java 开发者常常都会想办法如何更快地编写 Java 代码,让编程变得更加轻松.目前,市面上涌现出越来越多的高效编程工具.所以,以下总结了一系列工具列表,其中包含了大多数开发人员已经使用.正在使用或 ...

  5. [原创]k8exe2bat任意文件转Bat工具(WebShell无法上传EXE解决方案)

    http://qqhack8.blog.163.com/blog/static/114147985201126105626755/ 这是我2011年的东西了,当时用此方法可免杀很多马,至今依然有很大的 ...

  6. Java编程的逻辑 (81) - 并发同步协作工具

    ​本系列文章经补充和完善,已修订整理成书<Java编程的逻辑>,由机械工业出版社华章分社出版,于2018年1月上市热销,读者好评如潮!各大网店和书店有售,欢迎购买,京东自营链接:http: ...

  7. Java并发编程系列-(2) 线程的并发工具类

    2.线程的并发工具类 2.1 Fork-Join JDK 7中引入了fork-join框架,专门来解决计算密集型的任务.可以将一个大任务,拆分成若干个小任务,如下图所示: Fork-Join框架利用了 ...

  8. Java匹马行天下之JavaSE核心技术——工具类

    Java匹马行天之JavaSE核心技术——工具类 一.Object类 java.lang.ObjectObject类是所有类直接或间接的父类 常用的方法: toString():以字符串形式返回对象的 ...

  9. [Google Guava] 2.3-强大的集合工具类：java.util.Collections中未包含的集合工具

    原文链接 译文链接 译者:沈义扬,校对:丁一 尚未完成: Queues, Tables工具类 任何对JDK集合框架有经验的程序员都熟悉和喜欢java.util.Collections包含的工具方法.G ...

随机推荐

  1. [原题复现]百度杯CTF比赛 十月场 WEB EXEC(PHP弱类型)

    简介  原题复现:  考察知识点:PHP弱类型.  线上平台:https://www.ichunqiu.com/battalion(i春秋 CTF平台) 过程 看源码发现这个 vim泄露  下方都试了 ...

  2. 教你在CorelDRAW中制作水印

    水印是一种数字保护的手段,在图像上添加水印即能证明本人的版权,还能对版权的保护做出贡献.也就是在图片上打上半透明的标记,因其具有透明和阴影的特性,使之不管在较为阴暗或明亮的图片上都能完美使用,嵌入的水 ...

  3. 怎么借助CrossOver安装想要的Windows程序

    面对安装双系统时的繁琐步骤,以及虚拟机软件那庞大的体积,CrossOver的出现,让一切都变得简单起来. CrossOver自带的一系列的Windows应用,涵盖游戏软件.办公软件.设计软件等多个种类 ...

  4. MarkDown学习总结-2020.05.11

    1.使用工具 1.1Typora 官网地址:https://www.typora.io/ 下载链接 2.基础入门 注意: []中的内容则是对应格式的标记符,默认全部标识符后面需要多加一个空格才能生效. ...

  5. 【模版 Luogu P3808/P3796/P5357】AC自动机（简论）

    浙江集训Day9,没有出任何实质性成果,只好把昨天打完的板子记一下. 该博客基于luogu的三道模版题.只有一个大致的讲解,主要提供代码给自己参考. ------------------------- ...

  6. 公平lock和非公平lock的区别

    可以看到区别在于,在lock时和tryAquire时,非公平锁不会去管队列中有没有线程在排队,直接尝试去获取锁,失败之后就和公平锁一样,乖乖去排队. 也就是说发生竞争的场景在于,尚未入队的线程之间和刚 ...

  7. 创建topic

    sh kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 1 --topic ...

  8. Jmeter(三十) - 从入门到精通 - Jmeter Http协议录制脚本工具-Badboy3（详解教程）

    1.简介 Badboy为方便自动化数据灵活性,以及脚本的重用,减少工作量:为此提供了脚本参数化的功能,这一篇文章宏哥以度娘搜索的关键字"北京-宏哥"进行参数化为例,宏哥带领你们实战 ...

  9. ubuntu配置网络和静态路由(界面配置形式)

    目录 网卡配置 静态ip配置 静态路由 外网ip配置(动态获取DHCP) 内网ip和静态路由配置 本文主要针对ubuntu18.0系统进行界面形式配置网络.并配置静态路由. 网卡配置 静态ip配置 打 ...

  10. web.xml之servlet与filter配置

    servlet配置 一个完整的servlet配置分为两块,< servlet >块和< servlet-mapping >块 < servlet > <ser ...