I/O流

在Java中，这个概念很清楚，就是一个字符占16位，一个字节占8位,java中用的是unicode，一个字符占两个字节，16位

一.java 流式输入/输出原理：在java程序中，对于数据的输入/输出操作以"流"(stream)方式进行；J2SDK提供了各种各样的"流"类，用以获取不同 种类的数据；程序中通过标准的方法输入或输出数据

二.java流类的分类：java.io包中定义了多个流类型(类或抽象类)来实现输入 /输出功能；可以从不同的角度对其进行分类：
<1>.按数据流的方向不同可以分为输入流和输出流(站在程序的角度看)。
<2>. 按处理数据单位不同可以分为字节流和字符流

<3>.按照功能不同可以分为节点流和处理流
节点流：为可以从一个特定的 数据源(节点)读写数据(如：文件，内存)
处理流：是"连接"在已存在的流(节点流或处理流)之上，通过对数据的处理为程序提供更为强大的读写功 能

 

三.输入/输出流类

1。J2SDK所提供的所有流类型位于包java.io内都分别继承自 一下四种抽象流类型
           字节流         字符流
输入流  inputstream        Reader
输出流  OutputStream       Writer
2.继承自InputStream的流都是用于向程序中输入 数据，且数据的单位为字节(8 bit)；
(1).
InputStream{FilterInputStream{LineNumberInputStream,DateInputStream,BufferedInputStream,PushbackInputStream},FileInputStream,PipedInputStream,ByteArrayInputStream,SequenceInputStream,StringBufferInputStream,ObjectInputStream}
(2).InputStream 的基本方法：
  <1>.int read() throws IOException
   //读取一个字节并以整数的形式返回(0~255)，如果返回-1已到输入流的末尾
  <2>.int read (byte[] buffer)throws IOException
   //读取一系列字节并存储到一个数组buffer,返回实际读取的字节数，如果读取前已到输入流的 末尾返回-1
  <3>.int read(byte[] buffer,int offset,int length) throws IOException
    //读取Length个字节，并存储到一个字节数组buffer，从Length位置开始，返回实际读取的字     节数，如果读取前以到输入流的末尾返回-1
  <4>.void close() thorws IOException
     //关闭流释放内存资源
  <5>long skip(long n) throws IOException
    //跳过n个字节不读，返回实际跳过的字节数
3.继承自OutputStream的流是用于程序中输入数据，且数据的单位为字节(8 bit);
(1)OutputStream{FilterOutputStream{DataOutPutStream,BufferedOutputStream,PrintStream},FileOutputStream,PipedOutputStream,ByteArrayOutputStream,ObjectOutputStream}
(2)OutputStream 的基本方法
  <1>.void write(int b) throws IOException //向输出流中写入一个字节数据，该字节数据为参数b的低8位
  <2>.void write(byte[]b )throws IOException //将一个字节类型的数组中的数据写入输出流
  <3>.void write(byte[]b,int off,int len)throws IOException //将一个字节类型的数组中的从指定位置(off)开始的，len个字节写入到输出流
  <4>.void close()throws IOException//关闭流释放内存资源
  <5>.void flush()throws IOException//将输出流中缓冲的数据全部写出到目的地
4.继承自Reader的流都是用于向程序中输 入数据，且数据的单位为字符(16 bit):
(1).
Reader{InputStreamReader{FileReader},FilterReader{PushbackReader},BufferedReader{LineNumberReader},CharArrayReader,PipedReader,StringReader}
(2)Reader 的基本方法：
<1>.int read() throws IOException//读取一个字节并以整数的形式返回(0~255),如果返回-1已到输入流的末尾
<2>.int read(char[] cbuf)throws IOException //读取一系列字符并存储到一个数组buffer,返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
<3>.int read(char[] cbuf,int offset,int length)throws IOException//读取length个字符，并存储到一个数组buffer,从offset位置开始，返回实际读取的字符数，如果读取前已到输入 的末尾返回-1
<4>.void close()throws IOException//关闭流释放内存资源
<5>.long skip(long n) throws IOException//跳过n个字符不读，返回实际跳过的字节数
5.Writer 继承自Writer的流都是用于程序中输出数据，且数据的单位为字符(16 bit)
(1).Writer{OutputStreamReader{FileWriter},BufferedWriter,CharArrayWriter,FilterWirter,PipedWriter,StringWriter,FilterWriter}
(2).Write 的基本方法
<1>.void write(int c) throws IOException //向输出流中写入一个字符数据，该字节数据为参数b的低16位
<2>.void write(char[] cbuf)throws IOException//将一个字符类型的数组中的数据写入输入流
<3>.void write(char[] cbuf，int offset,int length)throws IOException//将一个字符类型的数组中的从指定位置(offset)开始的，length个字符写入到输出流
<4>.void write(String string) throws IOException //将一个字符串中的字符写入到输出流
<5>.void write(String string ,int offset,int length)throws IOException//将一个字符串从offset开始的length个字符写入到输出流
<6>.void close() throws IOException//关闭流释放内存资源
<7>.void flush() throws IOException //将输出流中缓冲的数据全部写出到目的地

四.常见的节点流和处理流

1.节点流类型：

类型                 字符流                    字节流
     FileReader                FileInputStream
File(文件)         FileWriter                FileOutputStream

Memory Array      CharArrayReader           ByteArrayInputStream
                  CharArrayWriter           ByteArrayOutputStream

Memory String    StringReader   -----
   StringWriter 

Pipe(管道)  PipedReader                PipedInputStream
                 PipedWriter                PipedOutputStream

2.访问文件
<1>.FileInputStream 和FileOutputStream 分别继承自InputStream 和 OutputStream 用于向文件中输入和输出字节
 FileInputStream 和 FileOutputStream 的常用构造方法
  (1).FileInputStream(String name) throws FileNotFoundException
  (2).FileInputStream(File file) throws FileNotFoundException
  (3).FileOutputStream(String name) throws FileNotFountException
  (4).FileOutputStream(File file)throws FileNotFoundException
  (5).FileOutputStream(File file,boolean append) throws FileNotFoundException
<2>.FileInputStream 和 FileOutputStream 类支持其父类InputStream 和OutputStream 所提供的    数据读写方法
(1).在 实例化FileInputStream 和FileOutputStream 流时要用try--catch语句以处理其可能抛出的FileNotFoundException
 (2).在读写数据时也要用try-- catch语句以处理可能抛出的IOException
 (3).FileNotFoundException 是IOException 的子类
 
例题：1
public class TestFileInputStream {
 public static void main(String[] args) {
  int b = 0;
  FileInputStream in = null;
  //FileReader in = null;
   try{
    in = new FileInputStream("E:\\Eclipseworkspace\\FileAndIOTest1\\src\\testFileInputStream\\TestFileInputStream.java");
    //in =new FileReader("E:\\Eclipseworkspace\\FileAndIOTest1\\src\\testFileInputStream\\TestFileInputStream.java");
   }catch(FileNotFoundException e){
    System.out.println("找不到指定的文件");
    System.out.println(-1);
   }
   try{
    long num = 0;
    while((b = in.read())!= -1){
     System.out.print((char)b);
     num++;
    }
    in.close();
    System.out.println();
    System.out.println("共读取了" + num + "个字节");
   }catch(IOException e1){
    System.out.println("文件读取错误");
    System.exit(-1);
   }
 }
}

例题2：
public class TestFileOutputStream {
 public static void main(String[] args) {
  int b = 0;
  //FileInputStream in = null;
  //FileOutputStream out = null;
  FileReader in = null;
  FileWriter out = null;
  try{
   //in = new FileInputStream("E:\\javaLearn\\fileTest\\aa.txt");
   //out = new FileOutputStream("E:\\javaLearn\\fileTest\\bb.txt");
   in = new FileReader("E:\\javaLearn\\fileTest\\aa.txt");//能自动建文件，不能建目录
   out = new FileWriter("E:\\javaLearn\\fileTest\\bb.txt");
   while((b = in.read())!= -1){
    out.write(b);
   }
   in.close();
   out.close();
  }catch(FileNotFoundException e2){
   System.out.println("找不到指定的文件");
   System.exit(-1);
  }catch(IOException e1){
   System.out.println("文件复制错误");
   System.exit(-1);
  }
  System.out.println(" 文件已经复制");
 }
}

处理流：包裹在别的流上的流
处理类型                       字符流                       字节流
Buffering     BufferedReader                BufferedInputStream
                           BufferedWriter                BufferedOutputStream

Filtering     FilterReader                  FilterInputStream
                           FilterWriter    FilterOutputStream

Converting between         InputStreamReader
bytes and character        OutputStreamWriter

Object Serialization                                    ObjectInputStream
       ObjectOutputStream

Date conversion                                         DateInputStream
       DateOutputStream

counting                  LineNumberReader              LineNumberInputStream

peeking ahead             pusbackReader                PushbackInputStream
pringting                 PrintWriter                   PrintStream

五.文件流

六.缓冲流
<1>. 缓冲流要"套接"在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法
<2>.J2SDK 提供了四种缓存流，其常用的构造方法为：
  BufferedReader(Reader in)
  BufferedReader(Reader in ,int sz)//sz 为自定义缓存区的大小
  BufferedWriter(Writer out)
  BufferedWriter(Writer out,int sz)
  BufferedInputStream(InputStream in)
  BufferedInputStream(InputStream in,int size)
  BufferedOutputStream(OutputStream out)
  BufferedOutputStream(OutoutStream out,int size)

 

七.数据流
<1>.DataInputStream 和DateOutputStream分别继承自InputStream 和OutputStream，它属于处理流，需要分别"套接"在InputStream 和OutputStream类型的节点流上
<2>.DateInputStream 和DateOutputStream提供了可以存取与机器无关的java原始类型数据(如：int ,double等)的方法
<3>.DataInputStream 和DataOutputStream 的构造方法为：
DateInputStream(InputStream in)
DateOutputStream(OutputStream out)

八.转换流
1.InputStreamReader 和 OutputStreamWriter用于字节数据到字符数据之间的转换
2.InputStreamReader 需要和 InputStream"套接"。
3.OutputStreamWriter 需要和OutputStream"套接"。
4.转换流在构 造时可以指定其编码集合，例如：
InputStream isr = new InputStreamReader(System.in,"ISO8859_1");

九.Print流：打印流
<1>.PrintWriter 和 printStream 都属于输出流，分别针对与字符和字节
<2>.PrintWriter 和PrintStream 提供了重载的print
<3>.Println方法用于多种数据类型的输出
<4>.PrintWriter和 PrintStream的输出操作不会抛出异常，用户通过检测错误状态取错误信息
<5>.PrintWriter和 PrintStream有自动flush功能
<6>.PrintWriter(Writer out)
    PrintWriter(Writer out,boolean autoFlush)
    PrintWriter(OutputStream  out)
    PrintWriter(OutputStream out,boolean autoFlush)
    PrintWriter(OutputStream out)
    PrintWriter(OutputStream out,boolean autoFlush)

十Object流
直 接将Object写入或读出
<1>.transient关键字：此关键字修饰时不能序列化
<2>serializable 接口：类通过实现 java.io.Serializable 接口以启用其序列化功能。未实现此接口的类将无法使其任何状态序列化或反序列化。可序列化类的所有子类型本身都是可序列化的。序列化接口没有方法或字段， 仅用于标识可序列化的语义；标记性接口，说明可以序列化

<3>.externalizable接口：实例类的惟一特性是可以 被写入序列化流中，该类负责保存和恢复实例内容；自己控制自己序列化过程

调用外部类的方法来生成内部类的对象，实现封装