Java IO(文件操作工具类)

FileOperate实现的功能：

1. 返回文件夹中所有文件列表

2. 读取文本文件内容

3. 新建目录

4. 新建多级目录

5. 新建文件

6. 有编码方式的创建文件

7. 删除文件

8. 删除指定文件夹下所有文件

9. 复制单个文件

10. 复制整个文件夹的内容

11. 移动文件

12. 移动目录

13. 建立一个可以追加的bufferedwriter

14. 得到一个bufferedreader

1. package utils;
2. import java.io.BufferedReader;
3. import java.io.BufferedWriter;
4. import java.io.File;
5. import java.io.FileInputStream;
6. import java.io.FileNotFoundException;
7. import java.io.FileOutputStream;
8. import java.io.FileWriter;
9. import java.io.IOException;
10. import java.io.InputStream;
11. import java.io.InputStreamReader;
12. import java.io.PrintWriter;
13. import java.util.StringTokenizer;
14. public class FileOperate {
15. private String message;
16. public FileOperate() {
17. }
18. /**
19. * 遍历文件夹中文件
20. *
21. * @param filepath
22. * @return 返回file［］数组
23. */
24. public File[] getFileList(String filepath) {
25. File d = null;
26. File list[] = null;
27. // 建立当前目录中文件的File对象
28. try {
29. d = new File(filepath);
30. if (d.exists()) {
31. list = d.listFiles();
32. }
33. } catch (Exception ex) {
34. ex.printStackTrace();
35. message = "遍历文件夹出错";
36. }
37. // 取得代表目录中所有文件的File对象数组
38. return list;
39. }
40. /**
41. * 读取文本文件内容
42. *
43. * @param filePathAndName
44. *            带有完整绝对路径的文件名
45. * @param encoding
46. *            文本文件打开的编码方式
47. * @return 返回文本文件的内容
48. */
49. public String readTxt(String filePathAndName, String encoding)
50. throws IOException {
51. encoding = encoding.trim();
52. StringBuffer str = new StringBuffer("");
53. String st = "";
54. try {
55. FileInputStream fs = new FileInputStream(filePathAndName);
56. InputStreamReader isr;
57. if (encoding.equals("")) {
58. isr = new InputStreamReader(fs);
59. } else {
60. isr = new InputStreamReader(fs, encoding);
61. }
62. BufferedReader br = new BufferedReader(isr);
63. try {
64. String data = "";
65. while ((data = br.readLine()) != null) {
66. str.append(data);
67. }
68. } catch (Exception e) {
69. str.append(e.toString());
70. }
71. st = str.toString();
72. if (st != null && st.length() > 1)
73. st = st.substring(0, st.length() - 1);
74. } catch (IOException es) {
75. st = "";
76. }
77. return st;
78. }
79. /**
80. * 新建目录
81. *
82. * @param folderPath
83. *            目录
84. * @return 返回目录创建后的路径
85. */
86. public String createFolder(String folderPath) {
87. String txt = folderPath;
88. try {
89. java.io.File myFilePath = new java.io.File(txt);
90. txt = folderPath;
91. if (!myFilePath.exists()) {
92. myFilePath.mkdir();
93. }
94. } catch (Exception e) {
95. message = "创建目录操作出错";
96. }
97. return txt;
98. }
99. /**
100. * 多级目录创建
101. *
102. * @param folderPath
103. *            准备要在本级目录下创建新目录的目录路径例如 c:myf
104. * @param paths
105. *            无限级目录参数，各级目录以单数线区分 例如 a|b|c
106. * @return 返回创建文件后的路径
107. */
108. public String createFolders(String folderPath, String paths) {
109. String txts = folderPath;
110. try {
111. String txt;
112. txts = folderPath;
113. StringTokenizer st = new StringTokenizer(paths, "|");
114. for (int i = 0; st.hasMoreTokens(); i++) {
115. txt = st.nextToken().trim();
116. if (txts.lastIndexOf("/") != -1) {
117. txts = createFolder(txts + txt);
118. } else {
119. txts = createFolder(txts + txt + "/");
120. }
121. }
122. } catch (Exception e) {
123. message = "创建目录操作出错";
124. }
125. return txts;
126. }
127. /**
128. * 新建文件
129. *
130. * @param filePathAndName
131. *            文本文件完整绝对路径及文件名
132. * @param fileContent
133. *            文本文件内容
134. * @return
135. */
136. public void createFile(String filePathAndName, String fileContent) {
137. try {
138. String filePath = filePathAndName;
139. filePath = filePath.toString();
140. File myFilePath = new File(filePath);
141. if (!myFilePath.exists()) {
142. myFilePath.createNewFile();
143. }
144. FileWriter resultFile = new FileWriter(myFilePath);
145. PrintWriter myFile = new PrintWriter(resultFile);
146. String strContent = fileContent;
147. myFile.println(strContent);
148. myFile.close();
149. resultFile.close();
150. } catch (Exception e) {
151. message = "创建文件操作出错";
152. }
153. }
154. /**
155. * 有编码方式的文件创建
156. *
157. * @param filePathAndName
158. *            文本文件完整绝对路径及文件名
159. * @param fileContent
160. *            文本文件内容
161. * @param encoding
162. *            编码方式 例如 GBK 或者 UTF-8
163. * @return
164. */
165. public void createFile(String filePathAndName, String fileContent,
166. String encoding) {
167. try {
168. String filePath = filePathAndName;
169. filePath = filePath.toString();
170. File myFilePath = new File(filePath);
171. if (!myFilePath.exists()) {
172. myFilePath.createNewFile();
173. }
174. PrintWriter myFile = new PrintWriter(myFilePath, encoding);
175. String strContent = fileContent;
176. myFile.println(strContent);
177. myFile.close();
178. } catch (Exception e) {
179. message = "创建文件操作出错";
180. }
181. }
182. /**
183. * 删除文件
184. *
185. * @param filePathAndName
186. *            文本文件完整绝对路径及文件名
187. * @return Boolean 成功删除返回true遭遇异常返回false
188. */
189. public boolean delFile(String filePathAndName) {
190. boolean bea = false;
191. try {
192. String filePath = filePathAndName;
193. File myDelFile = new File(filePath);
194. if (myDelFile.exists()) {
195. myDelFile.delete();
196. bea = true;
197. } else {
198. bea = false;
199. message = (filePathAndName + "删除文件操作出错");
200. }
201. } catch (Exception e) {
202. message = e.toString();
203. }
204. return bea;
205. }
206. /**
207. * 删除文件
208. *
209. * @param folderPath
210. *            文件夹完整绝对路径
211. * @return
212. */
213. public void delFolder(String folderPath) {
214. try {
215. delAllFile(folderPath); // 删除完里面所有内容
216. String filePath = folderPath;
217. filePath = filePath.toString();
218. java.io.File myFilePath = new java.io.File(filePath);
219. myFilePath.delete(); // 删除空文件夹
220. } catch (Exception e) {
221. message = ("删除文件夹操作出错");
222. }
223. }
224. /**
225. * 删除指定文件夹下所有文件
226. *
227. * @param path
228. *            文件夹完整绝对路径
229. * @return
230. * @return
231. */
232. public boolean delAllFile(String path) {
233. boolean bea = false;
234. File file = new File(path);
235. if (!file.exists()) {
236. return bea;
237. }
238. if (!file.isDirectory()) {
239. return bea;
240. }
241. String[] tempList = file.list();
242. File temp = null;
243. for (int i = 0; i < tempList.length; i++) {
244. if (path.endsWith(File.separator)) {
245. temp = new File(path + tempList[i]);
246. } else {
247. temp = new File(path + File.separator + tempList[i]);
248. }
249. if (temp.isFile()) {
250. temp.delete();
251. }
252. if (temp.isDirectory()) {
253. delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
254. delFolder(path + "/" + tempList[i]);// 再删除空文件
255. bea = true;
256. }
257. }
258. return bea;
259. }
260. /**
261. * 复制单个文件
262. *
263. * @param oldPathFile
264. *            准备复制的文件源
265. * @param newPathFile
266. *            拷贝到新绝对路径带文件名
267. * @return
268. */
269. public void copyFile(String oldPathFile, String newPathFile) {
270. try {
271. int bytesum = 0;
272. int byteread = 0;
273. File oldfile = new File(oldPathFile);
274. if (oldfile.exists()) { // 文件存在
275. InputStream inStream = new FileInputStream(oldPathFile); // 读入源文件
276. FileOutputStream fs = new FileOutputStream(newPathFile);
277. byte[] buffer = new byte[1444];
278. while ((byteread = inStream.read(buffer)) != -1) {
279. bytesum += byteread; // 字节 文件大小
280. System.out.println(bytesum);
281. fs.write(buffer, 0, byteread);
282. }
283. inStream.close();
284. }
285. } catch (Exception e) {
286. message = ("复制单个文件操作出错");
287. }
288. }
289. /**
290. * 复制整个文件夹的内容
291. *
292. * @param oldPath
293. *            准备拷贝的目录
294. * @param newPath
295. *            指定绝对路径的新目录
296. * @return
297. */
298. public void copyFolder(String oldPath, String newPath) {
299. try {
300. new File(newPath).mkdirs(); // 如果文件夹不存在 则建立新文件
301. File a = new File(oldPath);
302. String[] file = a.list();
303. File temp = null;
304. for (int i = 0; i < file.length; i++) {
305. if (oldPath.endsWith(File.separator)) {
306. temp = new File(oldPath + file[i]);
307. } else {
308. temp = new File(oldPath + File.separator + file[i]);
309. }
310. if (temp.isFile()) {
311. FileInputStream input = new FileInputStream(temp);
312. FileOutputStream output = new FileOutputStream(newPath
313. + "/" + (temp.getName()).toString());
314. byte[] b = new byte[1024 * 5];
315. int len;
316. while ((len = input.read(b)) != -1) {
317. output.write(b, 0, len);
318. }
319. output.flush();
320. output.close();
321. input.close();
322. }
323. if (temp.isDirectory()) {// 如果是子文件
324. copyFolder(oldPath + "/" + file[i], newPath + "/" + file[i]);
325. }
326. }
327. } catch (Exception e) {
328. message = "复制整个文件夹内容操作出错";
329. }
330. }
331. /**
332. * 移动文件
333. *
334. * @param oldPath
335. * @param newPath
336. * @return
337. */
338. public void moveFile(String oldPath, String newPath) {
339. copyFile(oldPath, newPath);
340. delFile(oldPath);
341. }
342. /**
343. * 移动目录
344. *
345. * @param oldPath
346. * @param newPath
347. * @return
348. */
349. public void moveFolder(String oldPath, String newPath) {
350. copyFolder(oldPath, newPath);
351. delFolder(oldPath);
352. }
353. /**
354. * 建立一个可以追加的bufferedwriter
355. *
356. * @param fileDir
357. * @param fileName
358. * @return
359. */
360. public BufferedWriter getWriter(String fileDir, String fileName) {
361. try {
362. File f1 = new File(fileDir);
363. if (!f1.exists()) {
364. f1.mkdirs();
365. }
366. f1 = new File(fileDir, fileName);
367. if (!f1.exists()) {
368. f1.createNewFile();
369. }
370. BufferedWriter bw = new BufferedWriter(new FileWriter(f1.getPath(),
371. true));
372. return bw;
373. } catch (Exception e) {
374. System.out.println(e.getLocalizedMessage());
375. return null;
376. }
377. }
378. /**
379. * 得到一个bufferedreader
380. *
381. * @param fileDir
382. * @param fileName
383. * @param encoding
384. * @return
385. */
386. public BufferedReader getReader(String fileDir, String fileName,
387. String encoding) {
388. try {
389. File file = new File(fileDir, fileName);
390. InputStreamReader read = new InputStreamReader(new FileInputStream(
391. file), encoding);
392. BufferedReader br = new BufferedReader(read);
393. return br;
394. } catch (FileNotFoundException ex) {
395. ex.printStackTrace();
396. return null;
397. } catch (IOException e) {
398. e.printStackTrace();
399. return null;
400. }
401. }
402. public String getMessage() {
403. return this.message;
404. }
405. }