热门：华为支持参数分辨率解决方法控制属性启动升级错误平台推荐步骤模式查询运行空间文件夹鼠标图标重启激活联想检查状态应用程序

java 读写文件-java读写文件

2022-09-28 15:44:32

  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. }

java 读写文件

读写文件javaStringUTFException

推荐阅读