FileInputStream，FileOutputStream，FileReader，FileWriter，BufferedReader，BufferedWriter相关的IO技术



参考http://blog.csdn.net/gyflyx/article/details/6439719

• FileInputStream和FileOutputStream类分别用来创建磁盘文件的输入流和输出流对象，通过它们的构造函数来指定文件路径和文件名。
• 创建FileInputStream实例对象时，指定的文件应当是存在和可读的。创建FileOutputStream实例对象时，如果指定的文件已经存在，这个文件中的原来内容将被覆盖清除。
• 对同一个磁盘文件创建FileInputStream对象的两种方式：   (1)FileInputStream inOne = new FileInputStream("hello.test");     (2)File f = new File("hello.test");      FileInputStream inTwo = new FileInputStream(f);
• 创建FileOutputStream实例对象时，可以指定还不存在的文件名，但不能指定一个已被其他程序打开了的文件。

 

思考：要将A文件的内容写入B文件，在程序代码中，是用输出类对象，还是用输入类对象来连接A文件并完成对A文件的操作呢？

 

（要记住：这里说的输入和输出的概念都是相对这个应用程序而言的，而不相对这个文件而言的。如下图）

所以我们应该创建一个输入类来读取A文件的内容，然后创建一个输出类将这些内容输出到B文件中。(如下图）

 

编程实例：用FileOutputStream类向文件中写入一个串字符，然后用FileInputStream读出写入的内容。

 

//FileStream.java

 

import java.io.*;

 

public class FileStream{

   public static void main(String[] args) throws Exception {

      FileOutputStream out = new FileOutputStream("hello.txt");

      out.write(" www.sina.com.cn".getBytes()); //把字符串转化为字节数组并写入到流中

      out.close();

 

      byte[] buf = new byte[1024];

      File f = new File("hello.txt");

      FileInputStream in = new FileInputStream(f);

      int len = in.read(buf); //读取内容到字节数组中

      System.out.println(new String(buf,0,len)); //String构造函数把字节数组转化为字符串

      in.close();

   }

}

 

 

 

Reader类和Writer类

 

• Reader和Writer是所有字符流类的抽象基类，用于简化对字符串的输入输出编程，即用于读写文本数据。
• 二进制文件和文本文件的区别。严格的说文件系统中的每个文件都是二进制文件。各种文本字符是由一个或几个字节组成的，其中每个字节的数 据不能是任意的。如果一个文件中的每个字节或每相邻的几个字节中的数据都可以表示成某种字符，我们就可以称这个文件为文本文件。可见文本文件只是二进制文 件的一种特例。为了与文本文件相区别，人们又把文本文件以外的文件称之为二进制文件。在概念上我们可以简单的认为：如果一个文件专用于存储文本字符而没有 包含字符之外的其他数据，就称之为文本文件，除此之外的文件就是二进制文件。

 

Reader与Writer类及其子类（FileReader和FileWriter类等）主要用于读取文本格式的内容，而InputStream和OutputStream类及它们的子类主要读取二进制格式的内容。

 

编程实例：用FileWriter类向文件中写入一个串字符，然后用FileReader读出写入的内容。

 

//FileStream2.java

 

import java.io.*;

 

public class FileStream2{

   public static void main(String[] args) throws Excetpion {

      FileWriter out = new FileWriter("hello2.txt");

      out. write(" www.sina.com.cn"); //在此可以直接写入字符串，不用转化为字节数组

      out.close();

 

      char[] buf = new char[1024];  //字符数组

      FileReader in = new FileReader("hello2.txt");

      int len = in.read(buf); //此时的read方法可以读取一个字符或几个字符,len代表实际读取到的字符的个数。

      System.out.println(new String(buf,0,1024)); //String构造函数把字符数组转化为字符串。

      in.close();

   }

}

以上内容转载 http://www.cnblogs.com/kyxyes/archive/2013/02/16/2913424.html

java.io.BufferedReader和java.io.BufferedWriter类各拥有8192字符的缓冲区。当BufferedReader在读取文本文件时，会先尽量从文件中读入字符数据并置入缓冲区，而之后若使用read()方法，会先从缓冲区中进行读取。如果缓冲区数据不足，才会再从文件中读取，使用BufferedWriter时，写入的数据并不会先输出到目的地，而是先存储至缓冲区中。如果缓冲区中的数据满了，才会一次对目的地进行写出。从标准输入流System.in中直接读取使用者输入时，使用者每输入一个字符，System.in就读取一个字符。为了能一次读取一行使用者的输入，使用了BufferedReader来对使用者输入的字符进行缓冲。readLine()方法会在读取到使用者的换行字符时，再一次将整行字符串传入。

BufferedReader和BufferedWriter实例

import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.lang.SecurityException;

public class BufferedReaderTest {

  private static final int LEN = 5;

  public static void main(String[] args) {
    testBufferedReader() ;
  }

  /**
   * BufferedReader的API测试函数
   */
  private static void testBufferedReader() {

    // 创建BufferedReader字符流，内容是ArrayLetters数组
    try {
      File file = new File("bufferedreader.txt");
      BufferedReader in =
         new BufferedReader(
           new FileReader(file));

      // 从字符流中读取5个字符。“abcde”
      for (int i=0; i<LEN; i++) {
        // 若能继续读取下一个字符，则读取下一个字符
        if (in.ready()) {
          // 读取“字符流的下一个字符”
          int tmp = in.read();
          System.out.printf("%d : %c\n", i, tmp);
        }
      }

      // 若“该字符流”不支持标记功能，则直接退出
      if (!in.markSupported()) {
        System.out.println("make not supported!");
        return ;
      }

      // 标记“当前索引位置”，即标记第6个位置的元素--“f”
      // 1024对应marklimit
      in.mark(1024);

      // 跳过22个字符。
      in.skip(22);

      // 读取5个字符
      char[] buf = new char[LEN];
      in.read(buf, 0, LEN);
      System.out.printf("buf=%s\n", String.valueOf(buf));
      // 读取该行剩余的数据
      System.out.printf("readLine=%s\n", in.readLine());

      // 重置“输入流的索引”为mark()所标记的位置，即重置到“f”处。
      in.reset();
      // 从“重置后的字符流”中读取5个字符到buf中。即读取“fghij”
      in.read(buf, 0, LEN);
      System.out.printf("buf=%s\n", String.valueOf(buf));

      in.close();
    } catch (FileNotFoundException e) {
      e.printStackTrace();
    } catch (SecurityException e) {
      e.printStackTrace();
    } catch (IOException e) {
      e.printStackTrace();
    }
  }
}

BufferedReader和BufferedWriter在socket中的应用

import java.io.BufferedInputStream; 
import java.io.BufferedReader; 
import java.io.BufferedWriter; 
import java.io.IOException; 
import java.io.InputStreamReader; 
import java.io.OutputStreamWriter; 
import java.net.InetSocketAddress; 
import java.net.Socket; 
import java.net.SocketAddress; 
import java.net.URLEncoder;   
public class analogsocket {        
    public String sendGet(String host, int port, String message) 
    {  
     String result = null;
     Socket socket = new Socket();
        BufferedReader bufferedReader = null;  //带有默认缓冲区的字符输入流
        BufferedWriter bufferedWriter;  //输出流
        System.out.println(host +"=="+port);
        SocketAddress dest = new InetSocketAddress(host,port); 
        try {
   socket.connect(dest);
  } catch (IOException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
  }  //建立socket连接
        OutputStreamWriter streamWriter = null;
  try {
   streamWriter = new OutputStreamWriter(socket.getOutputStream());
  } catch (IOException e2) {
   // TODO Auto-generated catch block
   e2.printStackTrace();
  }  //将字节流转换为字符流
        bufferedWriter = new BufferedWriter(streamWriter);
         
        try {
   bufferedWriter.write("GET " + message + " HTTP/1.1\r\n");
         bufferedWriter.write("Host: " + host + "\r\n"); 
         bufferedWriter.write("\r\n");  
         bufferedWriter.write(message); 
         //bufferedWriter.flush(); 
         bufferedWriter.write("\r\n");
         bufferedWriter.flush();
  } catch (IOException e1) {
   // TODO Auto-generated catch block
   e1.printStackTrace();
  } 
 
         
      BufferedInputStream streamReader;
 try {
    streamReader = new BufferedInputStream(socket.getInputStream());
       bufferedReader = new BufferedReader(new InputStreamReader(streamReader, "utf-8")); 
 } catch (IOException e1) {
  // TODO Auto-generated catch block
  e1.printStackTrace();
 }  //将字节流转换为字符流

      String line = null; 
      try {
      while((line = bufferedReader.readLine())!= null) 
      { 
         System.out.println("result="+line); 
         result = line;
      }
      bufferedReader.close(); 

      bufferedReader.close(); 
      bufferedWriter.close(); 
      socket.close();
   } catch (IOException e) {
  // TODO Auto-generated catch block
   e.printStackTrace();
   }
        return result;
    } 
     
}

参考http://375940084.blog.51cto.com/2581965/751040