`

java读写文本文件大全

 
阅读更多
使用Java操作文本文件的方法详解
摘要: 最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类
最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int
length)，flush()和close()方法为抽象方法，Reader中read(char[] ch,int off,int length)和close()方法是抽象方法。子类应该分别实现他们。
　　当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader，
它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。当使用FileReader读取文件
的时候。
view plain
  1. FileReader fr = new FileReader("ming.txt");
  2. int ch = 0;
  3. while((ch = fr.read())!=-1 )
  4. {
  5. System.out.print((char)ch);
  6. }

其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用
InputStreamReader来读取文件的时候
while((ch = isr.read())!=-1)
{
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率
我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先
放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
view plain
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
  1. FileWriter fw = new FileWriter("hello.txt");
  2. String s = "hello world";
  3. fw.write(s,0,s.length());
  4. fw.flush();
  5. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
  6. osw.write(s,0,s.length());
  7. osw.flush();
  8. PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
  9. pw.println(s);

不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。

view plain
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
  1. import java.io.*;
  2. public class TestFile2
  3. {
  4. public static void main(String[] args) throws IOException
  5. {
  6. FileReader fr = new FileReader("ming.txt");
  7. char[] buffer = new char[1024];
  8. int ch = 0;
  9. while((ch = fr.read())!=-1 )
  10. {
  11. System.out.print((char)ch);
  12. }
  13. 　　InputStreamReader isr = new InputStreamReader(new FileInputStream("ming.txt"));
  14. while((ch = isr.read())!=-1)
  15. {
  16. System.out.print((char)ch);
  17. }
  18. 　　BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
  19. String data = null;
  20. while((data = br.readLine())!=null)
  21. {
  22. System.out.println(data);
  23. }
  24. 　　FileWriter fw = new FileWriter("hello.txt");
  25. String s = "hello world";
  26. fw.write(s,0,s.length());
  27. fw.flush();
  28. 　　OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
  29. osw.write(s,0,s.length());
  30. osw.flush();
  31. 　　PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
  32. pw.println(s);
  33. 　　fr.close();
  34. isr.close();
  35. br.close();
  36. fw.close();
  37. osw.close();
  38. pw.close();
  39. }
  40. }

java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容

view plain
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.InputStreamReader;
  8. import java.io.RandomAccessFile;
  9. import java.io.Reader;
  10. public class ReadFromFile {
  11. /**
  12. * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
  13. * @param fileName 文件的名
  14. */
  15. public static void readFileByBytes(String fileName){
  16. File file = new File(fileName);
  17. InputStream in = null;
  18. try {
  19. System.out.println("以字节为单位读取文件内容，一次读一个字节：");
  20. // 一次读一个字节
  21. in = new FileInputStream(file);
  22. int tempbyte;
  23. while((tempbyte=in.read()) != -1){
  24. System.out.write(tempbyte);
  25. }
  26. in.close();
  27. } catch (IOException e) {
  28. e.printStackTrace();
  29. return;
  30. }
  31. try {
  32. System.out.println("以字节为单位读取文件内容，一次读多个字节：");
  33. //一次读多个字节
  34. byte[] tempbytes = new byte[100];
  35. int byteread = 0;
  36. in = new FileInputStream(fileName);
  37. ReadFromFile.showAvailableBytes(in);
  38. //读入多个字节到字节数组中，byteread为一次读入的字节数
  39. while ((byteread = in.read(tempbytes)) != -1){
  40. System.out.write(tempbytes, 0, byteread);
  41. }
  42. } catch (Exception e1) {
  43. e1.printStackTrace();
  44. } finally {
  45. if (in != null){
  46. try {
  47. in.close();
  48. } catch (IOException e1) {
  49. }
  50. }
  51. }
  52. }
  53. /**
  54. * 以字符为单位读取文件，常用于读文本，数字等类型的文件
  55. * @param fileName 文件名
  56. */
  57. public static void readFileByChars(String fileName){
  58. File file = new File(fileName);
  59. Reader reader = null;
  60. try {
  61. System.out.println("以字符为单位读取文件内容，一次读一个字节：");
  62. // 一次读一个字符
  63. reader = new InputStreamReader(new FileInputStream(file));
  64. int tempchar;
  65. while ((tempchar = reader.read()) != -1){
  66. //对于windows下，rn这两个字符在一起时，表示一个换行。
  67. //但如果这两个字符分开显示时，会换两次行。
  68. //因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
  69. if (((char)tempchar) != 'r'){
  70. System.out.print((char)tempchar);
  71. }
  72. }
  73. reader.close();
  74. } catch (Exception e) {
  75. e.printStackTrace();
  76. }
  77. try {
  78. System.out.println("以字符为单位读取文件内容，一次读多个字节：");
  79. //一次读多个字符
  80. char[] tempchars = new char[30];
  81. int charread = 0;
  82. reader = new InputStreamReader(new FileInputStream(fileName));
  83. //读入多个字符到字符数组中，charread为一次读取字符数
  84. while ((charread = reader.read(tempchars))!=-1){
  85. //同样屏蔽掉r不显示
  86. if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
  87. System.out.print(tempchars);
  88. }else{
  89. for (int i=0; i<charread; i++){
  90. if(tempchars[i] == 'r'){
  91. continue;
  92. }else{
  93. System.out.print(tempchars[i]);
  94. }
  95. }
  96. }
  97. }
  98. } catch (Exception e1) {
  99. e1.printStackTrace();
  100. }finally {
  101. if (reader != null){
  102. try {
  103. reader.close();
  104. } catch (IOException e1) {
  105. }
  106. }
  107. }
  108. }
  109. /**
  110. * 以行为单位读取文件，常用于读面向行的格式化文件
  111. * @param fileName 文件名
  112. */
  113. public static void readFileByLines(String fileName){
  114. File file = new File(fileName);
  115. BufferedReader reader = null;
  116. try {
  117. System.out.println("以行为单位读取文件内容，一次读一整行：");
  118. reader = new BufferedReader(new FileReader(file));
  119. String tempString = null;
  120. int line = 1;
  121. //一次读入一行，直到读入null为文件结束
  122. while ((tempString = reader.readLine()) != null){
  123. //显示行号
  124. System.out.println("line " + line + ": " + tempString);
  125. line++;
  126. }
  127. reader.close();
  128. } catch (IOException e) {
  129. e.printStackTrace();
  130. } finally {
  131. if (reader != null){
  132. try {
  133. reader.close();
  134. } catch (IOException e1) {
  135. }
  136. }
  137. }
  138. }
  139. /**
  140. * 随机读取文件内容
  141. * @param fileName 文件名
  142. */
  143. public static void readFileByRandomAccess(String fileName){
  144. RandomAccessFile randomFile = null;
  145. try {
  146. System.out.println("随机读取一段文件内容：");
  147. // 打开一个随机访问文件流，按只读方式
  148. randomFile = new RandomAccessFile(fileName, "r");
  149. // 文件长度，字节数
  150. long fileLength = randomFile.length();
  151. // 读文件的起始位置
  152. int beginIndex = (fileLength > 4) ? 4 : 0;
  153. //将读文件的开始位置移到beginIndex位置。
  154. randomFile.seek(beginIndex);
  155. byte[] bytes = new byte[10];
  156. int byteread = 0;
  157. //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
  158. //将一次读取的字节数赋给byteread
  159. while ((byteread = randomFile.read(bytes)) != -1){
  160. System.out.write(bytes, 0, byteread);
  161. }
  162. } catch (IOException e){
  163. e.printStackTrace();
  164. } finally {
  165. if (randomFile != null){
  166. try {
  167. randomFile.close();
  168. } catch (IOException e1) {
  169. }
  170. }
  171. }
  172. }
  173. /**
  174. * 显示输入流中还剩的字节数
  175. * @param in
  176. */
  177. private static void showAvailableBytes(InputStream in){
  178. try {
  179. System.out.println("当前字节输入流中的字节数为:" + in.available());
  180. } catch (IOException e) {
  181. e.printStackTrace();
  182. }
  183. }
  184. public static void main(String[] args) {
  185. String fileName = "C:/temp/newTemp.txt";
  186. ReadFromFile.readFileByBytes(fileName);
  187. ReadFromFile.readFileByChars(fileName);
  188. ReadFromFile.readFileByLines(fileName);
  189. ReadFromFile.readFileByRandomAccess(fileName);
  190. }
  191. }
  192. 二、将内容追加到文件尾部
  193. import java.io.FileWriter;
  194. import java.io.IOException;
  195. import java.io.RandomAccessFile;
  196. /**
  197. * 将内容追加到文件尾部
  198. */
  199. public class AppendToFile {
  200. /**
  201. * A方法追加文件：使用RandomAccessFile
  202. * @param fileName 文件名
  203. * @param content 追加的内容
  204. */
  205. public static void appendMethodA(String fileName,
  207. String content){
  208. try {
  209. // 打开一个随机访问文件流，按读写方式
  210. RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
  211. // 文件长度，字节数
  212. long fileLength = randomFile.length();
  213. //将写文件指针移到文件尾。
  214. randomFile.seek(fileLength);
  215. randomFile.writeBytes(content);
  216. randomFile.close();
  217. } catch (IOException e){
  218. e.printStackTrace();
  219. }
  220. }
  221. /**
  222. * B方法追加文件：使用FileWriter
  223. * @param fileName
  224. * @param content
  225. */
  226. public static void appendMethodB(String fileName, String content){
  227. try {
  228. //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
  229. FileWriter writer = new FileWriter(fileName, true);
  230. writer.write(content);
  231. writer.close();
  232. } catch (IOException e) {
  233. e.printStackTrace();
  234. }
  235. }
  236. public static void main(String[] args) {
  237. String fileName = "C:/temp/newTemp.txt";
  238. String content = "new append!";
  239. //按方法A追加文件
  240. AppendToFile.appendMethodA(fileName, content);
  241. AppendToFile.appendMethodA(fileName, "append end. n");
  242. //显示文件内容
  243. ReadFromFile.readFileByLines(fileName);
  244. //按方法B追加文件
  245. AppendToFile.appendMethodB(fileName, content);
  246. AppendToFile.appendMethodB(fileName, "append end. n");
  247. //显示文件内容
  248. ReadFromFile.readFileByLines(fileName);
  249. }
  250. }
最初java是不支持对文本文件的处理的，为了弥补这个缺憾而引入了Reader和Writer两个类，这两个类都是抽象类，Writer中 write(char[] ch,int off,int
length)，flush()和close()方法为抽象方法，Reader中read(char[] ch,int off,int length)和close()方法是抽象方法。子类应该分别实现他们。
　　当我们读写文本文件的时候，采用Reader是非常方便的，比如FileReader，InputStreamReader和BufferedReader。其中最重要的类是InputStreamReader，
它是字节转换为字符的桥梁。你可以在构造器重指定编码的方式，如果不指定的话将采用底层操作系统的默认编码方式，例如GBK等。当使用FileReader读取文件
的时候。
view plain
  1. FileReader fr = new FileReader("ming.txt");
  2. int ch = 0;
  3. while((ch = fr.read())!=-1 )
  4. {
  5. System.out.print((char)ch);
  6. }

其中read()方法返回的是读取得下个字符。当然你也可以使用read(char[] ch,int off,int length)这和处理二进制文件的时候类似，不多说了。如果使用
InputStreamReader来读取文件的时候
while((ch = isr.read())!=-1)
{
System.out.print((char)ch);
}
这和FileReader并没有什么区别，事实上在FileReader中的方法都是从InputStreamReader中继承过来的。read()方法是比较好费时间的，如果为了提高效率
我们可以使用BufferedReader对Reader进行包装，这样可以提高读取得速度，我们可以一行一行的读取文本，使用readLine()方法。
BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
String data = null;
while((data = br.readLine())!=null)
{
System.out.println(data);
}
当你明白了如何用Reader来读取文本文件的时候那么用Writer写文件同样非常简单。有一点需要注意，当你写文件的时候，为了提高效率，写入的数据会先
放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：
view plain
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
  1. FileWriter fw = new FileWriter("hello.txt");
  2. String s = "hello world";
  3. fw.write(s,0,s.length());
  4. fw.flush();
  5. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
  6. osw.write(s,0,s.length());
  7. osw.flush();
  8. PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
  9. pw.println(s);

不要忘记用完后关闭流！下面是个小例子，帮助新手理解。其实有的时候java的IO系统是需要我们多记记的，不然哪天就生疏了。

view plain
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
  1. import java.io.*;
  2. public class TestFile2
  3. {
  4. public static void main(String[] args) throws IOException
  5. {
  6. FileReader fr = new FileReader("ming.txt");
  7. char[] buffer = new char[1024];
  8. int ch = 0;
  9. while((ch = fr.read())!=-1 )
  10. {
  11. System.out.print((char)ch);
  12. }
  13. 　　InputStreamReader isr = new InputStreamReader(new FileInputStream("ming.txt"));
  14. while((ch = isr.read())!=-1)
  15. {
  16. System.out.print((char)ch);
  17. }
  18. 　　BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("ming.txt")));
  19. String data = null;
  20. while((data = br.readLine())!=null)
  21. {
  22. System.out.println(data);
  23. }
  24. 　　FileWriter fw = new FileWriter("hello.txt");
  25. String s = "hello world";
  26. fw.write(s,0,s.length());
  27. fw.flush();
  28. 　　OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt"));
  29. osw.write(s,0,s.length());
  30. osw.flush();
  31. 　　PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true);
  32. pw.println(s);
  33. 　　fr.close();
  34. isr.close();
  35. br.close();
  36. fw.close();
  37. osw.close();
  38. pw.close();
  39. }
  40. }

java中多种方式读文件
一、多种方式读文件内容。
1、按字节读取文件内容
2、按字符读取文件内容
3、按行读取文件内容
4、随机读取文件内容

view plain
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
  1. import java.io.BufferedReader;
  2. import java.io.File;
  3. import java.io.FileInputStream;
  4. import java.io.FileReader;
  5. import java.io.IOException;
  6. import java.io.InputStream;
  7. import java.io.InputStreamReader;
  8. import java.io.RandomAccessFile;
  9. import java.io.Reader;
  10. public class ReadFromFile {
  11. /**
  12. * 以字节为单位读取文件，常用于读二进制文件，如图片、声音、影像等文件。
  13. * @param fileName 文件的名
  14. */
  15. public static void readFileByBytes(String fileName){
  16. File file = new File(fileName);
  17. InputStream in = null;
  18. try {
  19. System.out.println("以字节为单位读取文件内容，一次读一个字节：");
  20. // 一次读一个字节
  21. in = new FileInputStream(file);
  22. int tempbyte;
  23. while((tempbyte=in.read()) != -1){
  24. System.out.write(tempbyte);
  25. }
  26. in.close();
  27. } catch (IOException e) {
  28. e.printStackTrace();
  29. return;
  30. }
  31. try {
  32. System.out.println("以字节为单位读取文件内容，一次读多个字节：");
  33. //一次读多个字节
  34. byte[] tempbytes = new byte[100];
  35. int byteread = 0;
  36. in = new FileInputStream(fileName);
  37. ReadFromFile.showAvailableBytes(in);
  38. //读入多个字节到字节数组中，byteread为一次读入的字节数
  39. while ((byteread = in.read(tempbytes)) != -1){
  40. System.out.write(tempbytes, 0, byteread);
  41. }
  42. } catch (Exception e1) {
  43. e1.printStackTrace();
  44. } finally {
  45. if (in != null){
  46. try {
  47. in.close();
  48. } catch (IOException e1) {
  49. }
  50. }
  51. }
  52. }
  53. /**
  54. * 以字符为单位读取文件，常用于读文本，数字等类型的文件
  55. * @param fileName 文件名
  56. */
  57. public static void readFileByChars(String fileName){
  58. File file = new File(fileName);
  59. Reader reader = null;
  60. try {
  61. System.out.println("以字符为单位读取文件内容，一次读一个字节：");
  62. // 一次读一个字符
  63. reader = new InputStreamReader(new FileInputStream(file));
  64. int tempchar;
  65. while ((tempchar = reader.read()) != -1){
  66. //对于windows下，rn这两个字符在一起时，表示一个换行。
  67. //但如果这两个字符分开显示时，会换两次行。
  68. //因此，屏蔽掉r，或者屏蔽n。否则，将会多出很多空行。
  69. if (((char)tempchar) != 'r'){
  70. System.out.print((char)tempchar);
  71. }
  72. }
  73. reader.close();
  74. } catch (Exception e) {
  75. e.printStackTrace();
  76. }
  77. try {
  78. System.out.println("以字符为单位读取文件内容，一次读多个字节：");
  79. //一次读多个字符
  80. char[] tempchars = new char[30];
  81. int charread = 0;
  82. reader = new InputStreamReader(new FileInputStream(fileName));
  83. //读入多个字符到字符数组中，charread为一次读取字符数
  84. while ((charread = reader.read(tempchars))!=-1){
  85. //同样屏蔽掉r不显示
  86. if ((charread == tempchars.length)&&(tempchars[tempchars.length-1] != 'r')){
  87. System.out.print(tempchars);
  88. }else{
  89. for (int i=0; i<charread; i++){
  90. if(tempchars[i] == 'r'){
  91. continue;
  92. }else{
  93. System.out.print(tempchars[i]);
  94. }
  95. }
  96. }
  97. }
  98. } catch (Exception e1) {
  99. e1.printStackTrace();
  100. }finally {
  101. if (reader != null){
  102. try {
  103. reader.close();
  104. } catch (IOException e1) {
  105. }
  106. }
  107. }
  108. }
  109. /**
  110. * 以行为单位读取文件，常用于读面向行的格式化文件
  111. * @param fileName 文件名
  112. */
  113. public static void readFileByLines(String fileName){
  114. File file = new File(fileName);
  115. BufferedReader reader = null;
  116. try {
  117. System.out.println("以行为单位读取文件内容，一次读一整行：");
  118. reader = new BufferedReader(new FileReader(file));
  119. String tempString = null;
  120. int line = 1;
  121. //一次读入一行，直到读入null为文件结束
  122. while ((tempString = reader.readLine()) != null){
  123. //显示行号
  124. System.out.println("line " + line + ": " + tempString);
  125. line++;
  126. }
  127. reader.close();
  128. } catch (IOException e) {
  129. e.printStackTrace();
  130. } finally {
  131. if (reader != null){
  132. try {
  133. reader.close();
  134. } catch (IOException e1) {
  135. }
  136. }
  137. }
  138. }
  139. /**
  140. * 随机读取文件内容
  141. * @param fileName 文件名
  142. */
  143. public static void readFileByRandomAccess(String fileName){
  144. RandomAccessFile randomFile = null;
  145. try {
  146. System.out.println("随机读取一段文件内容：");
  147. // 打开一个随机访问文件流，按只读方式
  148. randomFile = new RandomAccessFile(fileName, "r");
  149. // 文件长度，字节数
  150. long fileLength = randomFile.length();
  151. // 读文件的起始位置
  152. int beginIndex = (fileLength > 4) ? 4 : 0;
  153. //将读文件的开始位置移到beginIndex位置。
  154. randomFile.seek(beginIndex);
  155. byte[] bytes = new byte[10];
  156. int byteread = 0;
  157. //一次读10个字节，如果文件内容不足10个字节，则读剩下的字节。
  158. //将一次读取的字节数赋给byteread
  159. while ((byteread = randomFile.read(bytes)) != -1){
  160. System.out.write(bytes, 0, byteread);
  161. }
  162. } catch (IOException e){
  163. e.printStackTrace();
  164. } finally {
  165. if (randomFile != null){
  166. try {
  167. randomFile.close();
  168. } catch (IOException e1) {
  169. }
  170. }
  171. }
  172. }
  173. /**
  174. * 显示输入流中还剩的字节数
  175. * @param in
  176. */
  177. private static void showAvailableBytes(InputStream in){
  178. try {
  179. System.out.println("当前字节输入流中的字节数为:" + in.available());
  180. } catch (IOException e) {
  181. e.printStackTrace();
  182. }
  183. }
  184. public static void main(String[] args) {
  185. String fileName = "C:/temp/newTemp.txt";
  186. ReadFromFile.readFileByBytes(fileName);
  187. ReadFromFile.readFileByChars(fileName);
  188. ReadFromFile.readFileByLines(fileName);
  189. ReadFromFile.readFileByRandomAccess(fileName);
  190. }
  191. }
  192. 二、将内容追加到文件尾部
  193. import java.io.FileWriter;
  194. import java.io.IOException;
  195. import java.io.RandomAccessFile;
  196. /**
  197. * 将内容追加到文件尾部
  198. */
  199. public class AppendToFile {
  200. /**
  201. * A方法追加文件：使用RandomAccessFile
  202. * @param fileName 文件名
  203. * @param content 追加的内容
  204. */
  205. public static void appendMethodA(String fileName,
  207. String content){
  208. try {
  209. // 打开一个随机访问文件流，按读写方式
  210. RandomAccessFile randomFile = new RandomAccessFile(fileName, "rw");
  211. // 文件长度，字节数
  212. long fileLength = randomFile.length();
  213. //将写文件指针移到文件尾。
  214. randomFile.seek(fileLength);
  215. randomFile.writeBytes(content);
  216. randomFile.close();
  217. } catch (IOException e){
  218. e.printStackTrace();
  219. }
  220. }
  221. /**
  222. * B方法追加文件：使用FileWriter
  223. * @param fileName
  224. * @param content
  225. */
  226. public static void appendMethodB(String fileName, String content){
  227. try {
  228. //打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
  229. FileWriter writer = new FileWriter(fileName, true);
  230. writer.write(content);
  231. writer.close();
  232. } catch (IOException e) {
  233. e.printStackTrace();
  234. }
  235. }
  236. public static void main(String[] args) {
  237. String fileName = "C:/temp/newTemp.txt";
  238. String content = "new append!";
  239. //按方法A追加文件
  240. AppendToFile.appendMethodA(fileName, content);
  241. AppendToFile.appendMethodA(fileName, "append end. n");
  242. //显示文件内容
  243. ReadFromFile.readFileByLines(fileName);
  244. //按方法B追加文件
  245. AppendToFile.appendMethodB(fileName, content);
  246. AppendToFile.appendMethodB(fileName, "append end. n");
  247. //显示文件内容
  248. ReadFromFile.readFileByLines(fileName);
  249. }
  250. }
分享到：
| 经典SQL语句大全
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java 读写文件文本文件的示例

    根据给定的文件信息，我们将深入探讨Java读写文件文本文件的关键知识点，这些知识点主要集中在文件的读取、写入以及流的复制等操作上。 ### Java读取文本文件 在Java中，读取文本文件通常涉及到使用`InputStream`...

    java 读写文本文档源码，可自定义文件名称和路径

    java 读写文本文档源码，可自定义文件名称和路径，支持写入中文

    java读取文本文件

    在Java编程语言中，读取文本文件是一项基本且常见的任务，尤其在处理数据输入、日志分析或配置文件操作时。下面将详细讲解如何使用Java读取文本文件，包括多种常用的方法和注意事项。 1. 使用`BufferedReader` `...

    java读取文件方法大全

    此方法使用缓冲读取器`BufferedReader`，适用于以行为单位读取文本文件。 1. **按行读取**： 使用`BufferedReader`的`readLine()`方法读取每一行，直到返回`null`表示文件结束。 ### 实现细节与注意事项 1. **...

    JAVA简单的读写文本文件的代码

    通过上述四个主要部分的分析，我们可以看到Java语言在处理文件读写方面提供了丰富的API支持。使用合适的类库可以极大地简化开发工作并提高程序的性能。例如，使用`StringBuffer`可以有效地处理字符串的动态增长；而`...

    java解析各种文本文档

    java可以读取各种文本文档中的内容，也可以操作文本文档（word，excel，pdf，txt等格式的文档）

    Java读取文本文件内容

    Java读取文本文件内容Demo； 主要代码： char charArr[]=new char[1024]; //创建可容纳 1024 个字符的数组 FileReader b=new FileReader("D:\\temp\\test.txt"); int iNum=b.read(charArr); //将数据读入到数组 a ...

    java文本读取方法

    在Java编程语言中，读取文本文件是常见的操作之一，尤其是在处理大量数据或日志文件时。本文将详细介绍四种不同的Java文本读取方法：按字节读取文件内容、按字符读取文件内容、按行读取文件内容以及随机读取文件内容...

    Java读写文本文件的示例代码.rar

    首先，读取文本文件通常涉及`java.io`包中的`BufferedReader`类。以下是一个基本的读取文件内容的示例： ```java import java.io.BufferedReader; import java.io.FileReader; public class ReadFileExample { ...

    java如何读取文件

    本文将详细解析如何使用Java读取文本文件，基于提供的代码示例，深入探讨其工作原理及最佳实践。 ### Java读取文本文件的基础 在Java中，读取文件主要依赖于`java.io`包中的类，如`FileReader`和`BufferedReader`...

    java 读写文本的方法

    在Java编程语言中，读写文本文件是常见的操作。...以上代码展示了如何使用Java中的不同方法来读取文本文件。在实际开发中，应根据文件类型和需求选择合适的方法。同时，确保在读取文件后正确关闭输入流以避免资源泄漏。

    java读取超大文本文件

    `BufferedReader`是Java中读取文本文件的一种常见方法。它内部维护了一个字符缓冲区，可以有效减少磁盘I/O次数，提高读取效率。这种方式适用于文件大小适中，且不需要随机访问的情况。 示例代码中展示了如何使用`...

    java把文本文件内容导入到数据库

    在这个场景下，"java把文本文件内容导入到数据库"是一个典型的应用，它涉及到文本解析、数据库连接以及数据持久化等关键知识点。 首先，我们需要理解文本文件的格式。描述中提到文件内容的字段由“，”分隔，这种...

    JAVA源码Java读写文本文件的示例代码

    JAVA源码Java读写文本文件的示例代码

    Java读取TXT文本文件乱码解决方案.doc

    "Java读取TXT文本文件乱码解决方案" Java 读取 TXT 文本文件乱码解决方案中，主要讨论的是在 Java 中读取 TXT 文本文件时出现乱码的问题，并提供了解决方案。 首先，文章中提供了一个简单的读取 TXT 文件的代码，...

    java读取txt文件内容(java快速读取，程序已调试通)

    java读取txt文件，可以以文件路径构造这个流，:FileInputStream fin = new FileInputStream("d:/test.txt"); 然后使用这个流直接读取到文件，再使用reader构造BufferedReader，按行读取一整行的文本，作为字符串返回...

    Java读写文本文件的示例代码

    本文将深入探讨如何使用Java进行文本文件的读取和写入操作，这对初学者尤其重要。 首先，要读取一个文本文件，我们可以使用`java.io`包中的`BufferedReader`类。下面是一个基本的读取文件内容的例子： ```java ...

Magicbox
Global site tag (gtag.js) - Google Analytics