搞定JavaIO

输入流，输出流 按方向
字节流，字符流 按大小（中文一个字符是两个字节）
节点流，处理流 按功能 在节点流（处理流）上再加管道那叫处理流。


我们得先分清哪些是节点流，因为节点流是可以直接连到文件上的，处理流只能在节点流上。


字节流的基类
InputStream
read() 
          从输入流读取下一个数据字节。 
 int read(byte[] b) 
          从输入流中读取一定数量的字节并将其存储在缓冲区数组 b 中。 
 int read(byte[] b, int off, int len) 
          将输入流中最多 len 个数据字节读入字节数组。 


OutputStream


void close() 
          关闭此输出流并释放与此流有关的所有系统资源。 
 void flush() 
          刷新此输出流并强制写出所有缓冲的输出字节。 
 void write(byte[] b) 
          将 b.length 个字节从指定的字节数组写入此输出流。 
 void write(byte[] b, int off, int len) 
          将指定字节数组中从偏移量 off 开始的 len 个字节写入此输出流。 
abstract  void write(int b) 
          将指定的字节写入此输出流。 








字符流的基类
Reader
 int read() 
          读取单个字符。 
 int read(char[] cbuf) 
          将字符读入数组。 
abstract  int read(char[] cbuf, int off, int len) 
          将字符读入数组的某一部分。 
 int read(CharBuffer target) 
          试图将字符读入指定的字符缓冲区。 


Writer
close() 
          关闭此流，但要先刷新它。 
abstract  void flush() 
          刷新此流。 
 void write(char[] cbuf) 
          写入字符数组。 
abstract  void write(char[] cbuf, int off, int len) 
          写入字符数组的某一部分。 
 void write(int c) 
          写入单个字符。 
 void write(String str) 
          写入字符串。 
 void write(String str, int off, int len) 
 
 
 当然了，本来就直接用我们的节点流就可以了，为什么还要我们的处理流呢？
 因为我们要过滤一些杂质。
 
 字符流的节点流
 FileReader FileReader
 CharArrayReader charArrayWriter
 StringReader StringWriter
 PipedReader PipedWriter
 字节流的节点流
 FileOutputStream FileInputStream
 ByteArrayOutputStream ByteArrayInputStream
 PipedInputStream PipedOutputStream
 
 
 public class TestFileInputStream{
 public static void main(String args[]) throws Exception{
FileInputStream in=new FileInputStream("d:/lixiyuan/hello.txt");
int b=0;
int sum=0;
while(b==in.read()!=-1){
System.out.println(in.read());
sum++;
}
in.close();
System.out.println("一共有"+sum+"个字节");
 }
 
 }
 
 
 public class TestOutputStream{
 public static void main(String args[])throws Exception{
 FileInputStream in=new FileInputStream("d:/lixiyuan.txt");
 FileOutputStream out=new FileOutputStream("d:/newliixyuan.txt");
 int b=0;
 while(b==in.read()!=-1){
 out.write(b);
 in.close();
 out.close();
 }
 
 }
 }
 
public class TestFileReader{
public static void main(String args[]){
FileReader in=new FileReader("d:/lixiyuan.txt");
int b=0;
while(b==in.read()!=-1){
System.out.println((char)b);
}
}
}




public class TestFileWriter{
public static void main(String args[]){
FileWriter out=new FIleWriter("d:/newlixiyuan.txt
int sum=0;
while(sum<5000){
out.write(sum);
}
out.close();


}
}


处理流
那么处理流当然是因为处理的问题不同所以流也不同（我下面的例子我只说一个，因为对应的也有一个）
1：buffer（这是缓冲流）
BufferReader
BufferIinputStream
2:数据流
DataInputStream






public class TestDataOutputStream{
public static void main(String args[]){
ByteArrayOutputStream bot=new ByteArrayOutputStream();
DataOutputStram do=new DataOutputStream(bot);
do.WriteDouble(Math.random());
do.WriteBoolean(true);
ByteArrayInputStream bit=new ByteArrayInputStream(bot.toArray());
DataInputStream di=new DataInputStream(bit);

System.out.println(dis.readDboule());
System.out.pritnln(dis.readBoolean());
do.close();
di.close();

}
}
 


public class TestPrintWriter{
public static void main(String args[])throws Exception{
BufferedRead br=new BufferedRead(new InputStreamReader(System.in));
PrintWriter pw=new PrintWriter(new FileWriter("d:/log.txt",true));
String s=null;
while(s==br.readLine!=null)){
if(s.equalsIgnoreCase("exit"))break;
pw.println(s);
}
pw.write(new Date());
br.close();
pw.flush();
pw.close();


}
}