1. import java.io.BufferedReader;
2. import java.io.BufferedWriter;
3. import java.io.File;
4. import java.io.FileInputStream;
5. import java.io.FileOutputStream;
6. import java.io.IOException;
7. import java.io.InputStreamReader;
8. import java.io.OutputStreamWriter;
9. import org.apache.commons.io.FileUtils;
11. /**
12. * 文件工具类
13. */
14. public class FileUtil {
16. /**
17. * 创建文件（文件存在，则删除）
18. *
19. * @param fileName
20. * @return
21. */
22. public static File makeNewFile(String fileName) {
23. try {
24. File file = new File(fileName);
25. if (file.exists()) {
26. //文件存在，删除
27. file.delete();
28. } else {
29. //文件不存在，先创建路径
30. String filePath = fileName.substring(0, fileName.lastIndexOf(System.getProperty("file.separator")));
31. file = new File(filePath);
32. if (!file.exists()) {
33. file.mkdirs();
34. }
35. }
37. //创建文件
38. file = new File(fileName);
39. if (!file.exists()) {
40. file.createNewFile();
41. }
42. return file;
43. } catch (Exception e) {
44. e.printStackTrace();
45. return null;
46. }
47. }
49. /**
50. * 创建文件（文件存在，则删除）
51. *
52. * @param fileName
53. * @param content
54. * @return
55. */
56. public static int makeNewFile(String fileName, String content) {
57. try {
58. File file = new File(fileName);
59. if (file.exists()) {
60. //文件存在，删除
61. file.delete();
62. } else {
63. //文件不存在，先创建路径
64. String filePath = fileName.substring(0, fileName.lastIndexOf(System.getProperty("file.separator")));
65. file = new File(filePath);
66. if (!file.exists()) {
67. file.mkdirs();
68. }
69. }
71. //创建文件
72. file = new File(fileName);
73. if (!file.exists()) {
74. file.createNewFile();
75. }
76. FileUtils.writeStringToFile(file, content, "UTF-8");
77. return 0;
78. } catch (Exception e) {
79. e.printStackTrace();
80. return -1;
81. }
82. }
84. /**
85. * 文件追加内容
86. *
87. * @param fileName
88. * @param content
89. * @return
90. */
91. public static int fileAppend(String fileName, String content) {
92. BufferedWriter writer = null;
93. try {
94. //创建路径
95. String filePath = fileName.substring(0, fileName.lastIndexOf(System.getProperty("file.separator")));
96. File file = new File(filePath);
97. if (!file.exists()) {
98. file.mkdirs();
99. }
101. //创建文件
102. file = new File(fileName);
103. if (!file.exists()) {
104. file.createNewFile();
105. }
107. //追加日志
108. writer = new BufferedWriter(new OutputStreamWriter(
109. new FileOutputStream(file, true), "UTF-8"));
110. if (file.length() != 0) {//空文件
111. writer.write("\r\n");
112. }
113. writer.write(content);
115. } catch (IOException e) {
116. e.printStackTrace();
117. return -1;
118. } finally {
119. if (writer != null) {
120. try {
121. writer.close();
122. } catch (IOException ex) {
123. ex.printStackTrace();
124. }
125. }
126. }
128. return 0;
129. }
131. /**
132. * 文件追加内容
133. *
134. * @param fileName
135. * @param content
136. * @return
137. */
138. public static int fileAppendGBK(String fileName, String content) {
139. BufferedWriter writer = null;
140. try {
141. //创建路径
142. String filePath = fileName.substring(0, fileName.lastIndexOf(System.getProperty("file.separator")));
143. File file = new File(filePath);
144. if (!file.exists()) {
145. file.mkdirs();
146. }
148. //创建文件
149. file = new File(fileName);
150. if (!file.exists()) {
151. file.createNewFile();
152. }
154. //追加日志
155. writer = new BufferedWriter(new OutputStreamWriter(
156. new FileOutputStream(file, true), "GBK"));
157. if (file.length() != 0) {//空文件
158. writer.write("\r\n");
159. }
160. writer.write(content);
162. } catch (IOException e) {
163. e.printStackTrace();
164. return -1;
165. } finally {
166. if (writer != null) {
167. try {
168. writer.close();
169. } catch (IOException ex) {
170. ex.printStackTrace();
171. }
172. }
173. }
175. return 0;
176. }
178. /**
179. * 把串内容写到文件指定行上，如果插入行与该行内容相同则覆盖，不同则插入到该行<br>
180. * 如果插入行号<=0，则在文件最后追加一行
181. *
182. * @param fileName 文件名称，全路径
183. * @param content 插入的行内容
184. * @param insertLineNum 要插入到文件的行号
185. * @return
186. */
187. public static int insertAssignedLineWithCompare(String fileName, String content,
188. int insertLineNum) {
189. BufferedWriter writer = null;
190. BufferedReader reader = null;
191. try {
192. // 创建路径
193. String filePath = fileName.substring(0, fileName.lastIndexOf(System
194. .getProperty("file.separator")));
195. File file = new File(filePath);
196. if (!file.exists()) {
197. file.mkdirs();
198. }
200. file = new File(fileName);
201. if (!file.exists()) {
202. // 文件不存在，新建文件，直接写入内容为一行
203. file.createNewFile();
205. writer = new BufferedWriter(new OutputStreamWriter(
206. new FileOutputStream(file, true), "UTF-8"));
207. writer.write(content);
208. } else {
209. // 文件已存在
210. if (insertLineNum <= 0) {
211. // 把内容追加到文件最后
212. writer = new BufferedWriter(new OutputStreamWriter(
213. new FileOutputStream(file, true), "UTF-8"));
214. if (file.length() != 0) {// 非空文件
215. writer.write("\r\n");//换行
216. }
217. writer.write(content);
218. } else {
219. // 把内容插入到指定行
220. reader = new BufferedReader(new InputStreamReader(
221. new FileInputStream(file), "UTF-8"));
223. StringBuilder front = new StringBuilder();// 第insertLineNum行前面的内容
224. StringBuilder back = new StringBuilder();// 第insertLineNum行后面的内容
225. String insertLineStr = "";// 第insertLineNum行的内容
226. String currentLineStr = reader.readLine();// 每一行内容
227. int currentLineNum = 0;// 当前行号
228. while (currentLineStr != null && !"".equals(currentLineStr)) {
229. currentLineNum++;
230. if (currentLineNum < insertLineNum) {
231. front.append(currentLineStr).append("\r\n");
232. } else if (currentLineNum == insertLineNum) {
233. insertLineStr = currentLineStr;
234. } else {
235. back.append(currentLineStr).append("\r\n");
236. }
237. currentLineStr = reader.readLine();
238. }
240. //currentLineNum目前为文件最大行号
241. if (currentLineNum < insertLineNum) {
242. // 写入行号大于文件最大行号，把内容追加到文件最后
243. front.append(content);
244. } else {
245. // 把内容追加到文件指定行
246. if (content.indexOf(insertLineStr) < 0) {
247. // 没有插入过此行，插入
248. front.append(content).append("\r\n").append(insertLineStr);
249. if (back.toString() != null && !"".equals(back.toString())) {
250. front.append("\r\n").append(back.substring(0, back.lastIndexOf("\r\n")));
251. }
252. } else {
253. // 插入过此行，覆盖
254. front.append(content);
255. if (back.toString() != null && !"".equals(back.toString())) {
256. front.append("\r\n").append(back.substring(0, back.lastIndexOf("\r\n")));
257. }
258. }
259. }
261. // 重新创建文件
262. try {
263. reader.close();
264. } catch (IOException ex) {
265. ex.printStackTrace();
266. return -1;
267. }
268. file.delete();
269. file.createNewFile();
271. writer = new BufferedWriter(new OutputStreamWriter(
272. new FileOutputStream(file, true), "UTF-8"));
273. writer.write(front.toString());
274. }
275. }
276. } catch (Exception e) {
277. e.printStackTrace();
278. return -2;
279. } finally {
280. if (writer != null) {
281. try {
282. writer.close();
283. } catch (IOException ex) {
284. ex.printStackTrace();
285. }
286. }
287. }
289. return 0;
290. }
292. /**
293. * 获取文件
294. *
295. * @param filePath
296. * @return
297. */
298. public static File getFile(String filePath) {
299. try {
300. File file = new File(filePath);
301. if (!file.exists()) {
302. file.getParentFile().mkdirs();
303. file.createNewFile();
304. }
305. return file;
306. } catch (Exception ex) {
307. ex.printStackTrace();
308. return null;
309. }
310. }
312. /**
313. * 读取文件内容
314. *
315. * @param file
316. * @return
317. */
318. public static String getFileContent(File file) {
319. StringBuilder fileContent = new StringBuilder();
320. try {
321. if (file.isFile() && file.exists()) {
322. InputStreamReader read = new InputStreamReader(new FileInputStream(file), "UTF-8");
323. BufferedReader reader = new BufferedReader(read);
324. String line;
325. while ((line = reader.readLine()) != null) {
326. fileContent.append(line);
327. }
328. read.close();
329. }
330. } catch (Exception ex) {
331. ex.printStackTrace();
332. }
333. return fileContent.toString();
334. }
336. }