J技术跟踪

记录在程序开发中使用过的技术心得及常用的技巧;
数据加载中……
文件处理通用类
  1
  2
  3import java.io.BufferedReader;
  4import java.io.File;
  5import java.io.FileInputStream;
  6import java.io.FileOutputStream;
  7import java.io.InputStreamReader;
  8import java.io.OutputStreamWriter;
  9import java.io.Writer;
 10
 11/**
 12 * 文件操作通用类
 13 * 
 14 * @author YangHui
 15 */

 16public class FileHandle {
 17
 18    /**
 19     * 判断指定路径文件或目录是否存在
 20     * 
 21     * @param strPath
 22     *            文件全路径(含文件名)/目录全路径
 23     * @return boolean
 24     */

 25    public static boolean getState(String strPath) {
 26        boolean blnResult = false;
 27        File file = null;
 28        try {
 29            file = new File(strPath);
 30            if (file.exists() || file.isFile()) {
 31                blnResult = true;
 32            }

 33        }

 34        catch (Exception e) {
 35            System.out.println("类:FileHandle,方法:getState,信息:路径有误," + strPath);
 36        }

 37        finally {
 38            file = null;
 39        }

 40        // 释放对象
 41        strPath = null;
 42        return blnResult;
 43    }

 44
 45    /**
 46     * 读取文件到字符串中
 47     * 
 48     * @param strFilePath
 49     *            文件全路径(含文件名)
 50     * @param strCoding
 51     *            编码格式
 52     * @return String
 53     */

 54    public static String fileToString(String strFilePath, String strCoding) {
 55        StringBuffer strBuffResult = new StringBuffer();
 56        int i = 0;
 57        if (strCoding == null || strCoding.trim().length() <= 0{
 58            strCoding = "UTF-8";
 59        }

 60        BufferedReader bufferedReader = null;
 61        try {
 62            if (strCoding == null || strCoding.trim().length() <= 0{
 63                bufferedReader = new BufferedReader(new InputStreamReader(
 64                        new FileInputStream(strFilePath)));
 65            }
 else {
 66                bufferedReader = new BufferedReader(new InputStreamReader(
 67                        new FileInputStream(strFilePath), strCoding));
 68            }

 69            while ((i = bufferedReader.read()) != -1{
 70                strBuffResult.append((char) i);
 71            }

 72            bufferedReader.close();
 73        }

 74        catch (Exception ex) {
 75            System.out.println("类:FileHandle,方法:fileToString,信息:" + ex);
 76        }

 77        finally {
 78            bufferedReader = null;
 79        }

 80        // 释放对象
 81        strCoding = null;
 82        strFilePath = null;
 83        return strBuffResult.toString();
 84    }

 85
 86    /**
 87     * 将字符串写入到文件中
 88     * 
 89     * @param strContent
 90     *            字符串内容
 91     * @param strFilePath
 92     *            文件全路径(含文件名)
 93     * @param strCoding
 94     *            编码格式,默认:UTF-8
 95     * @return boolean
 96     */

 97    public static boolean stringToFile(String strContent, String strFilePath,
 98            String strCoding) {
 99        boolean blnResult = false;
100        if (strCoding == null || strCoding.trim().length() <= 0{
101            strCoding = "UTF-8";
102        }

103        FileOutputStream fileOutputStream = null// 文件输出对象
104        Writer writer = null;
105        try {
106            fileOutputStream = new FileOutputStream(strFilePath);
107            if (strCoding == null || strCoding.trim().length() <= 0{
108                writer = new OutputStreamWriter(fileOutputStream);
109            }
 else {
110                writer = new OutputStreamWriter(fileOutputStream, strCoding);
111            }

112            writer.write(strContent);
113            writer.flush();
114            writer.close();
115            fileOutputStream.close();
116            blnResult = true;
117        }

118        catch (Exception ex) {
119            System.out.println("类:FileHandle;方法:stringToFile;信息:" + ex);
120        }

121        finally {
122            writer = null;
123            fileOutputStream = null;
124        }

125        // 释放对象
126        strCoding = null;
127        strContent = null;
128        strFilePath = null;
129        return blnResult;
130    }

131
132    /**
133     * 新建目录
134     * 
135     * @param strFolderPath
136     *            目录路径(含要创建的目录名称)
137     * @return boolean
138     */

139    public static boolean createFolder(String strFolderPath) {
140        boolean blnResult = true;
141        File file = null;
142        if (strFolderPath != null && strFolderPath.trim().length() > 0{
143            try {
144                file = new File(strFolderPath);
145                if (!file.exists()) {
146                    file.mkdir();
147                }

148            }

149            catch (Exception e) {
150                System.out.println("类:FileHandle,方法:createFolder,信息:创建目录操作出错,"
151                        + strFolderPath);
152                blnResult = false;
153            }

154            finally {
155                file = null;
156            }

157        }

158        // 释放对象
159        strFolderPath = null;
160        return blnResult;
161    }

162
163    /**
164     * 复制整个文件夹的内容
165     * 
166     * @param strOldFolderPath
167     *            准备拷贝的目录
168     * @param strNewFolderPath
169     *            指定绝对路径的新目录
170     * @return void
171     */

172    public static void copyFolder(String strOldFolderPath,
173            String strNewFolderPath) {
174        FileInputStream fileInputStream = null;
175        FileOutputStream fileOutputStream = null;
176        File file = null;
177        String[] strArrayFile = null;
178        File fileTemp = null;
179        byte[] byteArray = null;
180        int intIndex = 0;
181        try {
182            new File(strNewFolderPath).mkdirs(); // 如果文件夹不存在 则建立新文件夹
183            file = new File(strOldFolderPath);
184            strArrayFile = file.list();
185            for (int i = 0; i < strArrayFile.length; i++{
186                if (strOldFolderPath.endsWith(File.separator)) {
187                    fileTemp = new File(strOldFolderPath + strArrayFile[i]);
188                }
 else {
189                    fileTemp = new File(strOldFolderPath + File.separator
190                            + strArrayFile[i]);
191                }

192                if (fileTemp.isFile() && (!fileTemp.isHidden())) {
193                    fileInputStream = new FileInputStream(fileTemp);
194                    fileOutputStream = new FileOutputStream(strNewFolderPath
195                            + "/" + (fileTemp.getName()).toString());
196                    byteArray = new byte[1024 * 5];
197                    while ((intIndex = fileInputStream.read(byteArray)) != -1{
198                        fileOutputStream.write(byteArray, 0, intIndex);
199                    }

200                    fileOutputStream.flush();
201                    fileOutputStream.close();
202                    fileInputStream.close();
203                    intIndex = 0;
204                }

205                if (fileTemp.isDirectory() && (!fileTemp.isHidden())) {// 如果是子文件夹
206                    copyFolder(strOldFolderPath + File.separator
207                            + strArrayFile[i], strNewFolderPath
208                            + File.separator + strArrayFile[i]);
209                }

210            }

211        }

212        catch (Exception e) {
213            System.out.println("类:FileHandle,方法:copyFolder,信息:复制整个文件夹内容操作出错,"
214                    + e);
215        }

216        finally {
217            fileInputStream = null;
218            fileOutputStream = null;
219            file = null;
220            fileTemp = null;
221            byteArray = null;
222        }

223        // 释放对象
224        strArrayFile = null;
225        strNewFolderPath = null;
226        strOldFolderPath = null;
227    }

228
229    /**
230     * 复制单个文件
231     * 
232     * @param strOldFilePath
233     *            准备复制的文件源
234     * @param strNewFilePath
235     *            拷贝到新绝对路径带文件名
236     * @return boolean
237     */

238    public static boolean copyFile(String strOldFilePath, String strNewFilePath) {
239        boolean blnResult = false;
240        FileInputStream fileInputStream = null;
241        FileOutputStream fileOutputStream = null;
242        File file = null;
243        byte[] byteArray = null;
244        int intIndex = 0;
245        try {
246            fileInputStream = new FileInputStream(strOldFilePath);
247            file = new File(strNewFilePath);
248            if (!file.exists()) {
249                file.createNewFile();
250            }

251            fileOutputStream = new FileOutputStream(file);
252            byteArray = new byte[1024];
253            while ((intIndex = fileInputStream.read(byteArray)) != -1{
254                for (int i = 0; i < intIndex; i++)
255                    fileOutputStream.write(byteArray[i]);
256            }

257            intIndex = 0;
258            fileInputStream.close();
259            fileOutputStream.close();
260            blnResult = true;
261        }

262        catch (Exception e) {
263            System.out.println("类:FileHandle,方法:copyFile,信息:被拷贝文件不存在!" + e);
264        }

265        finally {
266            fileInputStream = null;
267            fileOutputStream = null;
268            file = null;
269            byteArray = null;
270        }

271        // 释放对象
272        strNewFilePath = null;
273        strOldFilePath = null;
274        return blnResult;
275    }

276
277    /**
278     * 删除文件
279     * 
280     * @param strFilePath
281     *            文件全路径(含文件名)
282     * @return boolean
283     */

284    public static boolean delFile(String strFilePath) {
285        boolean blnResult = false;
286        File file = null;
287        if (strFilePath != null && strFilePath.trim().length() > 0{
288            try {
289                file = new File(strFilePath);
290                if (file.exists()) {
291                    file.delete();
292                    blnResult = true;
293                }
 else {
294                    System.out.println("类:FileHandle,方法:delFile,信息:被文件不存在,"
295                            + strFilePath);
296                }

297            }

298            catch (Exception e) {
299                System.out.println("类:FileHandle,方法:delFile,信息:删除文件有误," + e);
300            }

301            finally {
302                file = null;
303            }

304        }
 else {
305            System.out.println("类:FileHandle,方法:delFile,"
306                    + "信息:strFilePath = null.");
307        }

308        // 释放对象
309        strFilePath = null;
310        return blnResult;
311    }

312
313    /**
314     * 删除文件夹
315     * 
316     * @param strFolderPath
317     *            文件夹完整绝对路径
318     * @return void
319     */

320    public static void delFolder(String strFolderPath) {
321        File file = null;
322        if (strFolderPath != null && strFolderPath.trim().length() > 0{
323            try {
324                delAllFile(strFolderPath); // 删除完里面所有内容
325                file = new File(strFolderPath);
326                file.delete(); // 删除空文件夹
327            }

328            catch (Exception e) {
329                System.out.println("类:FileHandle,方法:delFolder,信息:删除目录有误," + e);
330            }

331            finally {
332                file = null;
333            }

334        }
 else {
335            System.out.println("类:FileHandle,方法:delFolder,"
336                    + "信息:strFolderPath=null");
337        }

338        // 释放对象
339        strFolderPath = null;
340    }

341
342    /**
343     * 删除指定文件夹下所有文件及目录
344     * 
345     * @param strFolderPath
346     *            文件夹完整绝对路径
347     * @return boolean
348     */

349    public static boolean delAllFile(String strFolderPath) {
350        boolean blnResult = false;
351        int intFileCount = 0;
352        String[] strArrayFile = null;
353        File file = new File(strFolderPath);
354        if (file.exists() && file.isDirectory()) {
355            strArrayFile = file.list();
356            if (strArrayFile == null || strArrayFile.length <= 0{
357                blnResult = true;
358            }
 else {
359                intFileCount = strArrayFile.length;
360                if (intFileCount > 0{
361                    for (int i = 0; i < intFileCount; i++{
362                        if (strFolderPath.endsWith(File.separator)) {
363                            file = new File(strFolderPath + strArrayFile[i]);
364                        }
 else {
365                            file = new File(strFolderPath + File.separator
366                                    + strArrayFile[i]);
367                        }

368                        if (file.isFile()) {
369                            file.delete();
370                        }

371                        if (file.isDirectory()) {
372                            delAllFile(strFolderPath + File.separator
373                                    + strArrayFile[i]);// 先删除文件夹里面的文件
374                            delFolder(strFolderPath + File.separator
375                                    + strArrayFile[i]);// 再删除空文件夹
376                        }

377                        blnResult = true;
378                    }

379                }
 else {
380                    blnResult = true;
381                }

382            }

383        }
 else {
384            System.out.println("类:FileHandle,方法:delAllFile,信息:删除文件目录有误,"
385                    + strFolderPath);
386        }

387        // 释放对象
388        strFolderPath = null;
389        strArrayFile = null;
390        file = null;
391        return blnResult;
392    }

393
394    /**
395     * 获得一个目录下面所有文件
396     * 
397     * @param strFolderPath
398     *            文件夹完整绝对路径
399     * @return String[]
400     */

401    public static String[] getAllFile(String strFolderPath) {
402        String[] strArrayResult = null;
403        File file = null;
404        if (strFolderPath != null && strFolderPath.trim().length() > 0{
405            file = new File(strFolderPath);
406            if (getState(strFolderPath) && file.isDirectory()) {
407                strArrayResult = file.list();
408            }

409            if (strArrayResult == null || strArrayResult.length <= 0
410                    || strArrayResult[0].trim().length() <= 0{
411                strArrayResult = null;
412            }

413        }
 else {
414            System.out.println("类:FileHandle,方法:getAllFile,"
415                    + "信息:strFolderPath=null");
416        }

417        // 释放对象
418        file = null;
419        strFolderPath = null;
420        return strArrayResult;
421    }

422
423    /**
424     * 获得指定目录下所有的一级目录
425     * 
426     * @param strFolderPath
427     *            指定路径名
428     * @return File[]
429     */

430    public static File[] getAllFolder(String strFolderPath) {
431        File file = null;
432        File[] fileArray = null;
433        if (strFolderPath != null && strFolderPath.trim().length() > 0{
434            file = new File(strFolderPath);
435            fileArray = file.listFiles();
436            if (fileArray == null || fileArray.length <= 0{
437                fileArray = null;
438            }

439        }
 else {
440            System.out.println("类:FileHandle,方法:getAllFolder,"
441                    + "信息:strFolderPath=null");
442        }

443        // 释放对象
444        file = null;
445        strFolderPath = null;
446        return fileArray;
447    }

448
449}

450

posted on 2009-11-17 10:34 J_sp-404 阅读(145) 评论(0)  编辑  收藏 所属分类: Java技术


只有注册用户登录后才能发表评论。


网站导航: