字符流相关知识总结（Reader and Write）

Reader主要方法
FileReader示例
import java.io.*;
public class ReaderTest{
 public static void main(String args[]){
  try{
   char[] c = new char[100];
   FileReader f = new FileReader("Reader.txt");
   int len = f.read(c);
   while(len != -1){
    System.out.println(c);
    len = f.read(c);
   }
  }
  catch(Exception e){
   e.printStackTrace();
  }
 }
}
Write主要方法
FileWrite示例
import java.io.*;
public class WriterTest{
 public static void main(String args[]){
  try{
   char[] c = new char[100];
   String strTemp="";
   FileReader r = new FileReader("Reader.txt");
   FileWriter w = new FileWriter("Writer.txt");
   int len = r.read(c);
   while(len != -1){
    strTemp += new String(c,0,len);
    len = r.read(c);
   }   strTemp = strTemp.replaceAll("进","jin");
   w.write(strTemp);
   r.close();
   w.close();
  }
  catch(Exception e){
   System.out.println(e.getMessage());
  }
 }
}
InputStreamReader OutputStreamWriter
类InputStreamReader和OutputStreamWriter 用于处理字节流和字符流之间的转换。
为了达到最高效率，可以考虑在 BufferedReader 内包装 InputStreamReader。
构造及方法
InputStreamReader示例
import java.io.*;
public class InputStreamTest{
 public static void main(String args[]){
  try{
   char[] c = new char[100];
   InputStreamReader r = new InputStreamReader(new FileInputStream("Reader.txt"));
   int len = r.read(c);
   while(len != -1){
    System.out.println(c);
    len = r.read(c);
   }
  }
  catch(Exception e){
   System.out.println(e.getMessage());
  }
 }
}
OutputStreamWriter示例
import java.io.*;
public class OutputStreamTest{
 public static void main(String args[]){
  try{
   char[] c = {'a','b','c','d'};
   OutputStreamWriter w = new OutputStreamWriter(new FileOutputStream("out.txt"));
   w.write(c);
   w.close();
   
   FileInputStream in = new FileInputStream("out.txt");
   int len = in.read();
   while(len != -1){
    System.out.println(len);
    len = in.read();
   }
   in.close();
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}
BufferedReader BufferedWriter
为了提高字符流处理的效率，引入了类BufferedReader和BufferedWriter对字符成块的处理。
构造及方法
BufferedReader示例
import java.io.*;
public class BufferedReaderTest{
 public static void main(String args[]){
  try{
   BufferedReader r = new BufferedReader(new FileReader("Reader.txt"));
   String strLine = r.readLine();
   while(strLine != null){
    System.out.println(strLine);
    strLine = r.readLine();
   }
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}
BufferedWriter示例
import java.io.*;
public class BufferedWriterTest{
 public static void main(String args[]){
  try{
   BufferedReader r = new BufferedReader(new FileReader("Reader.txt"));
   BufferedWriter w = new BufferedWriter(new FileWriter("Writer.txt"));
   String strLine = r.readLine();
   while(strLine != null){
    w.write(strLine);
    w.newLine();
    strLine = r.readLine();
   }
   w.close();
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}
管道流
管道流用来把一个程序、线程或代码块的输出连接到另一个程序、线程或代码块的输入。
java.io包中提供了类PipedInputStream和PipedOutputStream。
管道输入流作为一个通信管道的接收端，管道输出流则作为发送端。
在使用管道前，管道输出流和管道输入流必须要进行连接。
管道流
管道输入/输出流连接的方式有： 1.在构造方法中给出对应的输入/输出流进行连接。 public PipedInputStream(PipedOutputStream src) public PipedOutputStream(PipedInputStream snk) 2.使用管道输入/输出流提供的方法connect()进行连接。 类PipedInputStream中的定义为：         public void connect(PipedOutputStream src) 类PipedOuputStream中的定义为：         public void connect(PipedInputStream snk)
管道流示例
import java.io.*;
class Sender extends Thread{
 private DataOutputStream dataout;
 public Sender(PipedOutputStream out){
  dataout = new DataOutputStream(out);
 }
 
 public void run(){
  try{
   System.out.println("准备发送数据...");
   dataout.writeUTF("Hello,Welcome to China");
   dataout.close();
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}
管道流示例
class Receiver extends Thread{
 private DataInputStream datain;
 String strData;
 public Receiver(PipedInputStream in){
  datain = new DataInputStream(in);
 }
 
 public void run(){
  try{
   System.out.println("准备接收数据...");
   strData = datain.readUTF();
   System.out.println(strData);
   datain.close();
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}
管道流示例
public class PipedStreamTest{
 public static void main(String args[]){
  try{
   PipedOutputStream out = new PipedOutputStream();
   PipedInputStream in = new PipedInputStream();
   out.connect(in);
   System.out.println("管道输入输出流已经连接好！");
   
   Thread t1 = new Sender(out);
   Thread t2 = new Receiver(in);
   t1.start();
   t2.start();
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}
ByteArrayInputStream ByteArrayOutputStream StringBufferInputStream
通过类ByteArrayInputStream可以从字节数组中读取数据，其初始化是在给定字节数组中完成的。
通过类ByteArrayOutputStream可以向字节数组中写入数据，类中提供了缓冲区以存放数据，并且该缓冲区的大小可随着数据的写入而自动增加。
类StringBufferInputStream和ByteArrayInputStream基本类似，区别在于StringBufferInputStream是从字符串缓冲区StringBuffer中读取16位的Unicode数据，而不是8位的字节数据。
ByteArrayInputStream示例
import java.io.*;
public class ByteArrayTest{
 public static void main(String args[]){
  try{
   byte[] b1 = {97,98,99,100,101,102};
   byte[] b2 = new byte[100];
   
   ByteArrayInputStream in = new ByteArrayInputStream(b1);
   int len = in.read(b2);
   while(len != -1){
    System.out.println(new String(b2,0,len));
    len = in.read(b2);
   }
   in.close();
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}
顺序输入流
java.io包中提供了类SequenceInputStream，使应用程序可以把几个输入流顺序地连接起来。
顺序输入流提供了把若干个不同的流统一成同一个流的功能，这使得程序可能变得更加简洁。
SequenceInputStream示例
import java.io.*;
public class SequenceTest{
 public static void main(String args[]){
  try{
   String strData;
   
   FileInputStream f1 = new FileInputStream("input1.txt");
   FileInputStream f2 = new FileInputStream("input2.txt");
   SequenceInputStream s = new SequenceInputStream(f1,f2);
   DataInputStream d = new DataInputStream(s);
   while ((strData = d.readLine()) != null){
    System.out.println(strData);    
   }   
  }
  catch(Exception e){
   System.out.println(e.toString());
  }
 }
}