JAVA FileUtils(文件读写以及操作工具类)

  1 package com.suning.yypt.business.report;
  2 
  3 import java.io.*;
  4 import java.util.*;
  5 
  6 @SuppressWarnings({"resource","unused"})
  7 public class FileUtils {
  8 
  9     /**
 10      * 获取windows/linux的项目根目录
 11      * @return
 12      */
 13     public static String getConTextPath(){
 14         String fileUrl = Thread.currentThread().getContextClassLoader().getResource("").getPath();
 15         if("usr".equals(fileUrl.substring(1,4))){
 16             fileUrl = (fileUrl.substring(0,fileUrl.length()-16));//linux
 17         }else{
 18             fileUrl = (fileUrl.substring(1,fileUrl.length()-16));//windows
 19         }
 20         return fileUrl;
 21     }
 22 
 23     /**
 24      * 字符串转数组
 25      * @param str 字符串
 26      * @param splitStr 分隔符
 27      * @return
 28      */
 29     public static String[] StringToArray(String str,String splitStr){
 30         String[] arrayStr = null;
 31         if(!"".equals(str) && str != null){
 32             if(str.indexOf(splitStr)!=-1){
 33                 arrayStr = str.split(splitStr);
 34             }else{
 35                 arrayStr = new String[1];
 36                 arrayStr[0] = str;
 37             }
 38         }
 39         return arrayStr;
 40     }
 41 
 42     /**
 43      * 读取文件
 44      *
 45      * @param Path
 46      * @return
 47      */
 48     public static String ReadFile(String Path) {
 49         BufferedReader reader = null;
 50         String laststr = "";
 51         try {
 52             FileInputStream fileInputStream = new FileInputStream(Path);
 53             InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
 54             reader = new BufferedReader(inputStreamReader);
 55             String tempString = null;
 56             while ((tempString = reader.readLine()) != null) {
 57                 laststr += tempString;
 58             }
 59             reader.close();
 60         } catch (IOException e) {
 61             e.printStackTrace();
 62         } finally {
 63             if (reader != null) {
 64                 try {
 65                     reader.close();
 66                 } catch (IOException e) {
 67                     e.printStackTrace();
 68                 }
 69             }
 70         }
 71         return laststr;
 72     }
 73 
 74     /**
 75      * 获取文件夹下所有文件的名称 + 模糊查询（当不需要模糊查询时，queryStr传空或null即可）
 76      * 1.当路径不存在时，map返回retType值为1
 77      * 2.当路径为文件路径时，map返回retType值为2，文件名fileName值为文件名
 78      * 3.当路径下有文件夹时，map返回retType值为3，文件名列表fileNameList，文件夹名列表folderNameList
 79      * @param folderPath 路径
 80      * @param queryStr 模糊查询字符串
 81      * @return
 82      */
 83     public static HashMap getFilesName(String folderPath , String queryStr) {
 84         HashMap map = new HashMap();
 85         List fileNameList = new ArrayList();//文件名列表
 86         List folderNameList = new ArrayList();//文件夹名列表
 87         File f = new File(folderPath);
 88         if (!f.exists()) { //路径不存在
 89             map.put("retType", "1");
 90         }else{
 91             boolean flag = f.isDirectory();
 92             if(flag==false){ //路径为文件
 93                 map.put("retType", "2");
 94                 map.put("fileName", f.getName());
 95             }else{ //路径为文件夹
 96                 map.put("retType", "3");
 97                 File fa[] = f.listFiles();
 98                 queryStr = queryStr==null ? "" : queryStr;//若queryStr传入为null,则替换为空（indexOf匹配值不能为null）
 99                 for (int i = 0; i ) {
100                     File fs = fa[i];
101                     if(fs.getName().indexOf(queryStr)!=-1){
102                         if (fs.isDirectory()) {
103                             folderNameList.add(fs.getName());
104                         } else {
105                             fileNameList.add(fs.getName());
106                         }
107                     }
108                 }
109                 map.put("fileNameList", fileNameList);
110                 map.put("folderNameList", folderNameList);
111             }
112         }
113         return map;
114     }
115 
116     /**
117      * 以行为单位读取文件，读取到最后一行
118      * @param filePath
119      * @return
120      */
121     public static List readFileContent(String filePath) {
122         BufferedReader reader = null;
123         List listContent = new ArrayList();
124         try {
125             reader = new BufferedReader(new FileReader(filePath));
126             String tempString = null;
127             int line = 1;
128             // 一次读入一行，直到读入null为文件结束
129             while ((tempString = reader.readLine()) != null) {
130                 listContent.add(tempString);
131                 line++;
132             }
133             reader.close();
134         } catch (IOException e) {
135             e.printStackTrace();
136         } finally {
137             if (reader != null) {
138                 try {
139                     reader.close();
140                 } catch (IOException e1) {
141                 }
142             }
143         }
144         return listContent;
145     }
146 
147     /**
148      * 读取指定行数据 ，注意：0为开始行
149      * @param filePath
150      * @param lineNumber
151      * @return
152      */
153     public static String readLineContent(String filePath,int lineNumber){
154         BufferedReader reader = null;
155         String lineContent="";
156         try {
157             reader = new BufferedReader(new FileReader(filePath));
158             int line=0;
159             while(linelineNumber){
160                 lineContent=reader.readLine();
161                 line++;
162             }
163             reader.close();
164         } catch (IOException e) {
165             e.printStackTrace();
166         } finally {
167             if (reader != null) {
168                 try {
169                     reader.close();
170                 } catch (IOException e1) {
171                 }
172             }
173         }
174         return lineContent;
175     }
176 
177     /**
178      * 读取从beginLine到endLine数据（包含beginLine和endLine），注意：0为开始行
179      * @param filePath
180      * @param beginLineNumber 开始行
181      * @param endLineNumber 结束行
182      * @return
183      */
184     public static List readLinesContent(String filePath,int beginLineNumber,int endLineNumber){
185         List listContent = new ArrayList();
186         try{
187             int count = 0;
188             BufferedReader reader = new BufferedReader(new FileReader(filePath));
189             String content = reader.readLine();
190             while(content !=null){
191                 if(count >= beginLineNumber && count endLineNumber){
192                     listContent.add(content);
193                 }
194                 content = reader.readLine();
195                 count++;
196             }
197         } catch(Exception e){
198         }
199         return listContent;
200     }
201 
202     /**
203      * 读取若干文件中所有数据
204      * @param listFilePath
205      * @return
206      */
207     public static List readFileContent_list(List listFilePath) {
208         List listContent = new ArrayList();
209         for(String filePath : listFilePath){
210             File file = new File(filePath);
211             BufferedReader reader = null;
212             try {
213                 reader = new BufferedReader(new FileReader(file));
214                 String tempString = null;
215                 int line = 1;
216                 // 一次读入一行，直到读入null为文件结束
217                 while ((tempString = reader.readLine()) != null) {
218                     listContent.add(tempString);
219                     line++;
220                 }
221                 reader.close();
222             } catch (IOException e) {
223                 e.printStackTrace();
224             } finally {
225                 if (reader != null) {
226                     try {
227                         reader.close();
228                     } catch (IOException e1) {
229                     }
230                 }
231             }
232         }
233         return listContent;
234     }
235 
236     /**
237      * 文件数据写入（如果文件夹和文件不存在，则先创建，再写入）
238      * @param filePath
239      * @param content
240      * @param flag true:如果文件存在且存在内容，则内容换行追加；false:如果文件存在且存在内容，则内容替换
241      */
242     public static String fileLinesWrite(String filePath,String content,boolean flag){
243         String filedo = "write";
244         FileWriter fw = null;
245         try {
246             File file=new File(filePath);
247             //如果文件夹不存在，则创建文件夹
248             if (!file.getParentFile().exists()){
249                 file.getParentFile().mkdirs();
250             }
251             if(!file.exists()){//如果文件不存在，则创建文件,写入第一行内容
252                 file.createNewFile();
253                 fw = new FileWriter(file);
254                 filedo = "create";
255             }else{//如果文件存在,则追加或替换内容
256                 fw = new FileWriter(file, flag);
257             }
258         } catch (IOException e) {
259             e.printStackTrace();
260         }
261         PrintWriter pw = new PrintWriter(fw);
262         pw.println(content);
263         pw.flush();
264         try {
265             fw.flush();
266             pw.close();
267             fw.close();
268         } catch (IOException e) {
269             e.printStackTrace();
270         }
271         return filedo;
272     }
273 
274     /**
275      * 写文件
276      * @param ins
277      * @param out
278      */
279     public static void writeIntoOut(InputStream ins, OutputStream out) {
280         byte[] bb = new byte[10 * 1024];
281         try {
282             int cnt = ins.read(bb);
283             while (cnt > 0) {
284                 out.write(bb, 0, cnt);
285                 cnt = ins.read(bb);
286             }
287         } catch (IOException e) {
288             e.printStackTrace();
289         } finally {
290             try {
291                 out.flush();
292                 ins.close();
293                 out.close();
294             } catch (IOException e) {
295                 e.printStackTrace();
296             }
297         }
298     }
299 
300     /**
301      * 判断list中元素是否完全相同（完全相同返回true,否则返回false）
302      * @param list
303      * @return
304      */
305     private static boolean hasSame(List extends Object> list){
306         if(null == list)
307             return false;
308         return 1 == new HashSet