向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();
}
}
}
}
}
上一篇:Python easyGUI 文件浏览 显示文件内容


下一篇:python 机器学习中的数据处理学习记录