java读写文件大全

      注意：当你写文件的时候，为了提高效率，写入的数据会先放入缓冲区，然后写入文件。因此有时候你需要主动调用flush()方法。与上面对应的写文件的方法为：

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系统是需要我们多记记的，不然哪天就生疏了。

FileWriter fw = new FileWriter("hello.txt"); String s = "hello world"; fw.write(s,0,s.length()); fw.flush(); OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("hello2.txt")); osw.write(s,0,s.length()); osw.flush(); PrintWriter pw = new PrintWriter(new OutputStreamWriter(new FileOutputStream("hello3.txt")),true); pw.println(s);

 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、随机读取文件内容

  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  }

二、将内容追加到文件尾部

 1  import  java.io.FileWriter;
 2  import  java.io.IOException;
 3  import  java.io.RandomAccessFile;
 4  /**
 5  * 将内容追加到文件尾部
 6  */
 7  public   class  AppendToFile {
 8  /**
 9  * A方法追加文件：使用RandomAccessFile
10  *  @param  fileName 文件名
11  *  @param  content 追加的内容
12  */
13  public   static   void  appendMethodA(String fileName,
14 
15  String content){
16  try  {
17  //  打开一个随机访问文件流，按读写方式
18  RandomAccessFile randomFile  =   new  RandomAccessFile(fileName,  " rw " );
19  //  文件长度，字节数
20  long  fileLength  =  randomFile.length();
21  // 将写文件指针移到文件尾。
22  randomFile.seek(fileLength);
23  randomFile.writeBytes(content);
24  randomFile.close();
25  }  catch  (IOException e){
26  e.printStackTrace();
27  }
28  }
29  /**
30  * B方法追加文件：使用FileWriter
31  *  @param  fileName
32  *  @param  content
33  */
34  public   static   void  appendMethodB(String fileName, String content){
35  try  {
36  // 打开一个写文件器，构造函数中的第二个参数true表示以追加形式写文件
37  FileWriter writer  =   new  FileWriter(fileName,  true );
38  writer.write(content);
39  writer.close();
40  }  catch  (IOException e) {
41  e.printStackTrace();
42  }
43  }
44  public   static   void  main(String[] args) {
45  String fileName  =   " C:/temp/newTemp.txt " ;
46  String content  =   " new append! " ;
47  // 按方法A追加文件
48  AppendToFile.appendMethodA(fileName, content);
49  AppendToFile.appendMethodA(fileName,  " append end. n " );
50  // 显示文件内容
51  ReadFromFile.readFileByLines(fileName);
52  // 按方法B追加文件
53  AppendToFile.appendMethodB(fileName, content);
54  AppendToFile.appendMethodB(fileName,  " append end. n " );
55  // 显示文件内容
56  ReadFromFile.readFileByLines(fileName);
57  }
58  }

java lover