向txt文件中写入内容（覆盖重写与在末尾续写+FileOutputStream与FileWriter）（转发：https://blog.csdn.net/bestcxx/article/details/51381460）

！！！！

读取txt文件中的内容

1. import java.io.BufferedReader;
2. import java.io.File;
3. import java.io.FileReader;
4. /**
5. * 2016年05月11日
6. * 本类模拟从txt文件读取内容的过程
7. * @author WuJieJecket
8. *
9. */
10. public class PrintFromTxt {
11. public static void main(String[] args) throws Exception {
12. //读取全部文件内容
13. File file = new File("d:\\a\\123.txt");
14. StringBuilder sb = new StringBuilder();
15. String s ="";
16. BufferedReader br = new BufferedReader(new FileReader(file));
17. while( (s = br.readLine()) != null) {
18. sb.append(s + "\n");
19. }
20. br.close();
21. String str = sb.toString();
22. System.out.println(str);
23. }
24. }

！！！向文件中写入内容-如果指定文件不存在，会被创建

在main方法中使用if做判断，是否运行测试方法，测试方法有四个，FileOutputStream与FileWriter都是写入到txt文件，区别是后者先写在缓存，清缓存或者缓存已满才会最终把内容放入到txt中。

1. import java.io.FileNotFoundException;
2. import java.io.FileOutputStream;
3. import java.io.FileWriter;
4. import java.io.IOException;
5. /**
6. * 2016年05月11日
7. * 本类模拟将字符串写入到txt文件的过程
8. * @author WuJieJecket
9. *
10. */
11. public class WriteToTxt {
12. public static void main(String[] args) throws FileNotFoundException {
13. //要写入到文件中的内容  \r是换行
14. String str1="\r张三1 0 3000\r李四1 1 5000\r王五1 0 4000";
15. String str2="\r张三2 0 3000\r李四2 1 5000\r王五2 0 4000";
16. String str3="\r张三3 0 3000\r李四3 1 5000\r王五3 0 4000";
17. String str4="\r张三4 0 3000\r李四4 1 5000\r王五4 0 4000";
18. WriteToTxt wtt=new WriteToTxt();
19. //FileWriter-缓存写入-字符-覆盖重写
20. if(!true){
21. wtt.FileWriterTest(str1);
22. }
23. //FileOutputStream-直接写入-字节-覆盖重写
24. if(!true){
25. wtt.FileOutputStreamTest(str2);
26. }
27. //FileWriter-缓存写入-字符-末尾续接
28. if(!true){
29. wtt.FileWriterTest2(str3);
30. }
31. //FileOutputStream-直接写入-字节-末尾续接
32. if(!true){
33. wtt.FileOutputStreamTest2(str4);
34. }
35. }
36. /*
37. * 写文件
38. * 覆盖重写
39. * FileWriter
40. * 先写在缓存中,需要flush
41. * 字符 eg:1,2,a,b
42. */
43. public void FileWriterTest(String str){
44. FileWriter writer;
45. try {
46. // writer = new FileWriter("/home/1.txt");
47. writer = new FileWriter("d:\\a\\1231.txt");
48. writer.write(str);
49. writer.flush();     //这一个比较重要，是清理缓存的过程，之后需要写入的信息被写到txt文件中
50. writer.close();
51. } catch (IOException e) {
52. e.printStackTrace();
53. }
54. }
55. /*
56. *写文件
57. *覆盖重写
58. *FileOutputStream
59. *直接写入到文件中，不存在缓存
60. *字节 byte
61. */
62. public void FileOutputStreamTest(String str){
63. FileOutputStream fos;
64. try {
65. fos=new FileOutputStream("d:\\a\\1232.txt");
66. fos.write(str.getBytes());
67. fos.close();
68. } catch (FileNotFoundException e) {
69. // TODO Auto-generated catch block
70. e.printStackTrace();
71. } catch (IOException e) {
72. // TODO Auto-generated catch block
73. e.printStackTrace();
74. }
75. }
76. /*
77. * 写文件
78. * 末尾续接
79. * FileWriter
80. * 先写在缓存中,需要flush
81. * 字符 eg:1,2,a,b
82. */
83. public void FileWriterTest2(String str){
84. FileWriter writer;
85. try {
86. // writer = new FileWriter("/home/1.txt");
87. writer = new FileWriter("d:\\a\\1233.txt",true);
88. writer.write(str);
89. writer.flush();     //这一个比较重要，是清理缓存的过程，之后需要写入的信息被写到txt文件中
90. writer.close();
91. } catch (IOException e) {
92. e.printStackTrace();
93. }
94. }
95. /*
96. *写文件
97. *末尾续接
98. *FileOutputStream
99. *直接写入到文件中，不存在缓存
100. *字节 byte
101. */
102. public void FileOutputStreamTest2(String str){
103. FileOutputStream fos;
104. try {
105. fos=new FileOutputStream("d:\\a\\1234.txt",true);
106. fos.write(str.getBytes());
107. fos.close();
108. } catch (FileNotFoundException e) {
109. // TODO Auto-generated catch block
110. e.printStackTrace();
111. } catch (IOException e) {
112. // TODO Auto-generated catch block
113. e.printStackTrace();
114. }
115. }
116. }

txt的按行、列读

http://blog.csdn.net/bestcxx/article/details/65446489

最后附上自己写的一个封装好的方法，可以直接使用，不会覆盖原文件（即末尾续接）

package com.zhaowu.renwu2;

import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

public class FileUtil {
    public static void toFile (String content) {
        File file = null;
        FileWriter fw = null;
        file = new File("/home/acer/桌面/aaa");
        try {
            if (!file.exists()) {
                file.createNewFile();
            }
            fw = new FileWriter(file,true);
            fw.write(content);//向文件中复制内容
            fw.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            if(fw != null){
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}