【iO流总结】

 

io流分为 ：

输入流和输出流，字节流、字符流、缓冲流、转换流、对象流、打印流。

                        

1.字节和字符流

 字节输入流(InputStream)：
 常用方法：
             int read();//读取一个字节的数据，如果没有数据则返回-1
              int read(byte[] b);//将读入的数据存入byte数组，返回读取的长度，如果没有数据则返                      回-1
              void close();//关闭流，释放资源
 
 常用子类：FileInputStream
 构造方法：
                   public FileInputStream(String pathname);
                   public FileInputStream(File pathname);

字节输出流(OutputStream)：
常用方法：
            void write(int i);//写出一个字节的数据
            void write(byte[] b);//把byte数组中的数据写出去
            void write(byte[] b,int offset,int len);//把byte数组中从offset位置开始，长度是len的数                        据写出去
            void flush();//刷新，清空缓存区
            void close();//关闭流，释放资源
常用子类：FileOutputStream
构造方法：
                 //通过构造方法没有传入append，则append默认是覆盖(默认为false)
                    public FileOutputStream(String pathname);
                    public FileOutputStream(File pathname);
                    //append如果为true，则表示追加。如果为false表示覆盖
                    public FileOutputStream(String pathname,boolean append);
                    public FileOutputStream(File pathname,boolean append);

字符输入流(Reader)：
常用方法：
                 int read();//读取一个字符的数据，如果没有数据则返回-1
                 int read(char[] ch);//读取数据存入char数组，返回读取的长度，如果没有数据则返回-1
                 void close();//关闭流，释放资源
  
常用子类：FileReader
构造方法：
                     //调用下列构造方法的时候，底层会创建一个长度是8192的byte数组
                   //第一次读取的时候会读取8192字节的数据存入byte数组(如果数据量少于8192则有                           多少读多少)
                    //把数组对应位置的元素转换成字符进行操作处理。
                    //后面每一次读取的时候(调用read方法)，只要byte数组中有数据就不用去磁盘中再                          读取数据
                   //直接操作内存中byte数组中的数据就可以了。
                   public FileReader(String pathname);    
                   public FileReader(File pathname); 

字符输出流(Writer)：
常用方法：
                 void write(int i);//写出一个字符的数据
                 void write(char[] ch);//写出char数组中的全部数据
                 void write(char[] ch,int offset,int len);//写出char数组中，从offset开始到len长的数据
                 void write(String str);
                 void write(String str,int offset,int len);
                 void flush();
                 void close();

常用子类：FileWriter
构造方法：
                      //调用下列构造方法的时候，底层会创建一个长度是8192的byte数组
                    //写出的字符转换成byte数据存入8192的byte数组中
                     //当该byte数组存不下数据的时候，或者 显示的调用flush方法时，
                    //会把该byte数组中的数据写出到目标位置
  

 2.缓冲流：字节缓冲输入流和字节缓冲输出流作用：较少IO次数，提高IO的效率。

字节输入流(InputStream):
        常用和转换流子类：               FileInputStream
       BufferedInputStream：
 构造方法：
                    //调用下面这个构造方法的时候，底层会创建一个长度是8129的byte数组
                   //当第一次读取的时候，会读取数据存入该byte数组中
                   //然后从该数组对应位置获取元素，进行操作
                      public BufferedInputStream(InputStream is);
                      //下面这个构造方法可以自己指定缓冲区大小
                    public BufferedInputStream(InputStream is,int size);

字节输出流(OutputStream):
常用子类：
            FileOutputStream
            BufferedOutputStream：
 构造方法：
                    //调用下面这个构造方法的时候，底层会创建一个长度是8192的byte数组
                    //当写出数据的时候，会被数据存储在这个8192的byte数组中
                     //当该数组存不下数据，或者显示的调用了flush(close)方法，会把缓冲区中的数据                             写出去
                     public BufferedOutputStream(OutputStream os);
                   //通过下面的构造方法，可以指定缓冲区的大小
                     public BufferedOutputStream(OutputStream os,int size);

字符输入流(Reader):
 常用子类：
            FileReader      
            BufferedReader：
构造方法：
                   //调用下面这个构造方法的时候，底层会创建一个长度是8192的char数组
                     //调用读取方法，把数据读取存入8192的byte数组
                   //把8192byte数组中的数据统一转换成字符存入8192的char数组中
                    //从char数组中的对应位置获取元素，进行操作
                    public BufferedReader(Reader r);
                    public BufferedReader(Reader r,int size);
 
                   //字符输入流和缓冲字符输入流读取数据，读取的次数是一样的
                  //高效体现在字节到字符的转换。

InputStreamReader（字符转换输入流）：
构造方法：
                      //读取数据使用的是默认的字符编码
                     public InputStreamReader(InputStream is);
                     /读取数据使用的是自己指定的编码
                     public InputStreamReader(InputStream is,String charsetName);

字符输出流(Writer):
常用子类：
 FileWriter
                调用FileWriter构造方法的时候，底层会创建一个长度是8192的byte数组
 
 BufferedWriter
 构造方法：
                     //调用下面这个构造方法的时候，底层会创建一个长度是8192的char数组
                     //调用写出方法的时候，会把数据写出到8192的char数组中
                    //当8192的char数组存不下数据的时候，会同一进行转换(成byte)，
                     //存储到8192的byte数组中，然后把8192byte数组中的数据写出去
                     public BufferedWriter(Writer w);          
    //调用下面这个构造方法可以自己指定缓冲区的大小
        public BufferedWriter(Writer w,int size);
    //字符缓冲输出流的高效体现在，字符到字节的转换上，写出次数这两种(FileWriter、                     BufferedWriter)是一样的

OutputStreamWriter（字符转换输出流）：
 构造方法：
                   //使用默认的字符编码写出数据
                   public OutputStreamWriter(OutputStream os);
                    //使用自己指定的字符编码写出数据
                    public OutputStreamWriter(OutputStream os,String charsetName);

3.对象流 

ObjectInputStream(对象输入流):
 注意事项：
              序列化后，类文件结构不能改变，如果改变了反序列化就会报错。
              如果不能保证不修改类文件结构，则可以在该类中添加一个成员变量(常量)：
                                                      serialVersionUID
              反序列化回来后，会重新构建一个对象
 成员方法：
            final Object readObject();//读取一个对象
 构造方法：
            public ObjectInputStream(InputStream is);
ObjectOutputStream（对象输出流）：
 注意事项：
                a.序列化的对象必须是Serializable类型
                b.成员变量的类型也必须是Serializable类型
                c.使用transient关键字修饰的成员变量不进行序列化
成员方法：
               void writeObject(Object obj);//将指定的对象写出。
构造方法：
                publicObjectOutputStream(OutputStream out);

PrintStream：打印流       
 成员方法：
             void println();
             void print(参数);
 构造方法：
          public PrintStream(String pathname);
         public PrintStream(File pathname);