Java文本编辑器中遇到的问题详解

今天介绍文件的读取和写入,分别用FileReader,FileWriter

1,FileWriter类(字符输出流类)

构造方法:FileWriter fw = new FileWriter(String fileName);//创建字符输出流类对象和已存在的文件相关联。文件不存在的话,并创建。

                                             如:FileWriter fw = new FileWriter("C:\\demo.txt");

                  FileWriter fw = new FileWriter(String fileName,boolean append);//创建字符输出流类对象和已存在的文件相关联,并设置该该流对文件的操作是否为续写。

                                             如:FileWriter fw = new FileWriter("C:\\demo.txt",ture); //表示在fw对文件再次写入时,会在该文件的结尾续写,并不会覆盖掉。

主要方法: void write(String str)   //写入字符串。当执行完此方法后,字符数据还并没有写入到目的文件中去。此时字符数据会保存在缓冲区中。

                                                        此时在使用刷新方法就可以使数据保存到目的文件中去。

                  viod flush()                //刷新该流中的缓冲。将缓冲区中的字符数据保存到目的文件中去。

                  viod close()               //关闭此流。在关闭前会先刷新此流的缓冲区。在关闭后,再写入或者刷新的话,会抛IOException异常。

 1 package filewriter;
 2 
 3 import java.io.FileWriter;
 4 import java.io.IOException;
 5 
 6 public class Filewriter {
 7 
 8     private static final String LINE_SEPARATOR = System.getProperty("line.separator");
 9 
10     /**
11      * 
12      * @param args
13      * @throws IOException 
14      */
15     public static void main(String[] args) throws IOException {
16         /**
17          * 创建一个可以往文件中写入字符数据的字符流输出流对象
18          * 创建时必须明确文件的目的地
19          * 如果文件不存在,这回自动创建。如果文件存在,则会覆盖。
20          * 当路径错误时会抛异常
21          * 
22          * 当在创建时加入true参数,回实现对文件的续写。
23          */
24         FileWriter fw = new FileWriter("C:\\demo1.txt",false);
25         /**
26          * 调用该对象的write方法,向文件写入字符。
27          * 
28          * 其实写入到了临时存储缓冲区中
29          */
30 //        fw.write("hello \r\nworld!");//windows中的换行为\r\n    unix下为\r。
31         fw.write("aello"+LINE_SEPARATOR+"world!");
32         fw.write("hahaha");
33         /**
34          * 进行刷新,将字符写到目的地中。
35          */
36 //        fw.flush();
37         /**
38          * 关闭流,关闭资源。在关闭前会调用flush方法 刷新缓冲区。关闭后在写的话,会抛IOException
39          */
40         fw.close();
41         
42 
43     }
44 
45 }

2,FileReader类

1,构造方法

FileReader fr = new FileReader(String fileName);//使用带有指定文件的String参数的构造方法。创建该输入流对象。并关联源文件。

2,主要方法

int read(); // 读取单个字符。返回作为整数读取的字符,如果已达到流末尾,则返回 -1。

int read(char []cbuf);//将字符读入数组。返回读取的字符数。如果已经到达尾部,则返回-1。

void close();//关闭此流对象。释放与之关联的所有资源。

 1 package Filereader;
 2 
 3 import java.io.FileReader;
 4 import java.io.IOException;
 5 
 6 public class FileReaderDemo {
 7 
 8     public static void main(String[] args) throws IOException {
 9         /**
10          * 创建读取字符数据的流对象。
11          * 读取路径不正确时会抛 IOException
12          * 用以个读取流对象关联一个已存在文件。
13          */
14         FileReader fr = new FileReader("demo.txt");
15         /**
16          * 用Reader中的read方法读取字符。
17          */
18         /*int ch = fr.read();
19         System.out.print((char)ch);
20         int ch1 = fr.read();
21         System.out.print((char)ch1);
22         int ch2 = fr.read();
23         System.out.print((char)ch2);*/
24         int ch = 0;
25         while((ch = fr.read()) != -1){//读取所有内容
26             System.out.print((char)ch);
27         }
28         fr.close();
29         }
30 }

 

BufferedWriter 和 BufferedReader的介绍

BufferedWriter 和 BufferedReader 为带有默认缓冲的字符输出输入流,因为有缓冲区所以很效率比没有缓冲区的很高。

一、BufferedWriter 类

构造方法:bufferedWriter bf = new bufferedWriter(Writer out );

主要方法:void write(char ch);//写入单个字符。

                  void write(char []cbuf,int off,int len)//写入字符数据的某一部分。

                  void write(String s,int off,int len)//写入字符串的某一部分。

                  void newLine()//写入一个行分隔符。

                  void flush();//刷新该流中的缓冲。将缓冲数据写到目的文件中去。

                  void close();//关闭此流,再关闭前会先刷新他。

 1 package Buffered;
 2 
 3 import java.io.BufferedWriter;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 public class BufferedWriterDemo {
 8     public static void main(String[] args) throws IOException {
 9         FileWriter fw = new FileWriter("Buffered.txt");
10 //        fw.write("ok168");
11 //        fw.close();
12         /**
13          * 为了提高写入的效率,使用了字符流的缓冲区。
14          * 创建了一个字符写入流的缓冲区对象,并和指定要被缓冲的流对象相关联。
15          */
16         BufferedWriter bufw = new BufferedWriter(fw);
17         
18         //使用缓冲区中的方法将数据写入到缓冲区中。
19         bufw.write("hello world !");
20         bufw.newLine();
21         bufw.newLine();
22         bufw.write("!hello world !");
23         bufw.write("!hello world !");
24         //使用缓冲区中的方法,将数据刷新到目的地文件中去。
25         bufw.flush();
26         //关闭缓冲区,同时关闭了fw流对象
27         bufw.close();    
28     }
29 }

二、BufferedReader类。

构造方法:BufferedReader br = new BufferReader(Reader in);

主要方法:int read();//读取单个字符。

                  int read(char[] cbuf,int off,int len);//将字符读入到数组的某一部分。返回读取的字符数。达到尾部 ,返回-1。

                  String readLine();                        //读取一个文本行。

                  void close();                                //关闭该流。并释放与该流相关的所有资源。

 1 package Buffered;
 2 
 3 import java.io.BufferedWriter;
 4 import java.io.FileWriter;
 5 import java.io.IOException;
 6 
 7 public class BufferedWriterDemo {
 8     public static void main(String[] args) throws IOException {
 9         FileWriter fw = new FileWriter("Buffered.txt");
10 //        fw.write("ok168");
11 //        fw.close();
12         /**
13          * 为了提高写入的效率,使用了字符流的缓冲区。
14          * 创建了一个字符写入流的缓冲区对象,并和指定要被缓冲的流对象相关联。
15          */
16         BufferedWriter bufw = new BufferedWriter(fw);
17         
18         //使用缓冲区中的方法将数据写入到缓冲区中。
19         bufw.write("hello world !");
20         bufw.newLine();
21         bufw.newLine();
22         bufw.write("!hello world !");
23         bufw.write("!hello world !");
24         //使用缓冲区中的方法,将数据刷新到目的地文件中去。
25         bufw.flush();
26         //关闭缓冲区,同时关闭了fw流对象
27         bufw.close();    
28     }
29 }

 

 

 

FileInputStream和FileOutputStream用法的简介

    前面提到过FileReader、FileWriter以字符流的形式读写数据,现在来说说以字节流的形式操作数据

 

 1 import java.io.File;
 2 import java.io.FileInputStream;
 3 import java.io.FileNotFoundException;
 4 import java.io.IOException;
 5 
 6 
 7 public class FInputStream {
 8 
 9     /**
10      * @param args
11      */
12     public static void main(String[] args) {
13         // TODO Auto-generated method stub
14        try {
15         FileInputStream fis=new FileInputStream(new File("D:\\123.txt"));//新建一个FileInputStream对象
16         try {
17             byte[] b=new byte[fis.available()];//新建一个字节数组
18             fis.read(b);//将文件中的内容读取到字节数组中
19             fis.close();
20             String str2=new String(b);//再将字节数组中的内容转化成字符串形式输出
21             System.out.println(str2);
22         } catch (IOException e) {
23             // TODO Auto-generated catch block
24             e.printStackTrace();
25         }
26         
27     } catch (FileNotFoundException e) {
28         // TODO Auto-generated catch block
29         e.printStackTrace();
30     }
31     }
32 }

一、FileOutputStream类。

 

构造函数:FileOutputStream fos = new FileOutputStream(String fileName);//参数为相关联的文件路径及名称。

主要方法:viod write(byte []b);//将b.length 个字节写入到目的文件中去。

                  void write(byte []b,int off,int len);//将指定数组中偏移量off开始的len个字节写入该文件中。(未演示)

                  void fiush();//刷新该流,将该流中的字节刷到目的文件中去。

                  void close();//关闭此流,并释放所有与该流相关的资源。同样关闭前先调用flush()方法。

 

二、FileInputStrean类

构造函数:FileInputStream fis = new FileInputStream(String fileName);//参数为相关联的文件路径及名称。

主要方法:int read();//从此流中读取下一个数据字节。

                  int read(byte[] b);//从此流中读取b.length个字符到该byte数组中。

                  int read(byte[] b,int off,int len);//将此流中的len个字节数据读入到byte数组偏移off(含off)向后位置中。(未演示)

                  int available();//返回剩余的文件字节数。   

package ByteStream;  
  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
  
public class ByteStreamDemo {  
  
    /** 
     * @param args 
     * @throws IOException  
     */  
    public static void main(String[] args) throws IOException {  
//      demo_Write();  
        demo_Read();  
              
    }  
  
    public static void demo_Read() throws IOException {  
        FileInputStream fis = new FileInputStream("C:\\out_Stream.txt");  
          
//      System.out.println(fis.available());//打印文件所占字节数。  
//      byte []bfr = new byte[fis.available()];//不建议使用,当文件过大时,会照成内存不足。  
//      fis.read(bfr);  
//      System.out.println(new String(bfr));  
          
          
        //推荐使用这个。  
        byte[]ch = new byte[1024];  
        int len = 0;  
        while((len = fis.read(ch)) != -1){  
            System.out.println(new String(ch,0,len));  
        }  
          
          
          
//      int ch = 0;  
//      while((ch = fis.read()) != -1){  
//          System.out.print((char)ch);  
//      }  
          
          
          
//      int ch = fis.read();  
//      System.out.println((char)ch);  
          
        fis.close();  
          
          
          
    }  
  
    public static void demo_Write() throws IOException {  
        //创建字节输出流对象。用于操作文件。  
        FileOutputStream fos = new FileOutputStream("C:out_Stream.txt");  
        //写字节数据。  
        fos.write("hello!FileOuyputStream!".getBytes());  
        fos.close();  
    }  
  
}  

原文链接地址:http://blog.csdn.net/liuhenghui5201/article/details/8279557

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。