IO流整理

概述：

IO指的是输入流（input）和输出流（Output），流是一种抽象概念，是对数据传输的总称。也就是说数据在设备间的传输称为流，流的本质是数据传输。IO流就是用来处理设备间数据传输问题的。常见的应用：文件复制；文件上传；文件下载。

输出流：OutputStream：

      构造方法：

        FileOutputStream(String name)；

//创建字节输出流对象
        //FileOutputStream(String name)：创建文件输出流以指定的名称写入文件
        FileOutputStream fos = new FileOutputStream("myByteStream\\fos.txt");

常用方法：

        void close();

        void flush();

        void write(int date); / / 写出一个数据

        void write(byte[] b) ; 

        void write(byte[] b,int offset,int len); 

  字节输出流写数据的步骤：

public class FileOutputStreamDemo02 {
    public static void main(String[] args) throws IOException {
        //创建文件输出流以写入由指定的 File对象表示的文件
        FileOutputStream fos = new FileOutputStream(new File("myByteStream\\fos.txt"));
        
        //void write(int b)：将指定的字节写入此文件输出流
        fos.write(97);
        
        //void write(byte[] b)：将 b.length字节从指定的字节数组写入此文件输出流
        byte[] bys = {97, 98, 99, 100, 101};
        //byte[] getBytes()：返回字符串对应的字节数组
        byte[] bys = "abcde".getBytes();
        fos.write(bys);
 
        //void write(byte[] b, int off, int len)：将 len字节从指定的字节数组开始，
        //                     从偏移量off开始写入此文件输出流
        //fos.write(bys,0,bys.length);
        fos.write(bys,1,3);
 
        //释放资源
        fos.close();
    }
}

字符流：

        构造方法：

                InputStreamReader(InputStream is);

                InputStreamReader(InputStream is,String c);

                OutputStreamWriter(Outputstream)；

                OutputStreamWriter(Outputstream,String c)；

//根据目的地创建字符输出流对象
        OutputStreamWriter osw = new OutputStreamWriter(new                     
        FileOutputStream("myCharStream\\Copy.java"));
//根据数据源创建字符输入流对象
        InputStreamReader isr = new InputStreamReader(new 
        FileInputStream("myCharStream\\ConversionStreamDemo.java"));

         常用方法       

                void write(int c);

                  void write(char[ ] ch);

                  void write(char[ ] ch,int offset,int len);

                  void flush();

                  void write(String s);

                  void write(String[ ] s,int offset,int len);

                   int read();

                   int read(char[ ] ch);

public class CopyJavaDemo02 {
    public static void main(String[] args) throws IOException {
        //根据数据源创建字符输入流对象
        FileReader fr = new FileReader("myCharStream\\ConversionStreamDemo.java");
        //根据目的地创建字符输出流对象
        FileWriter fw = new FileWriter("myCharStream\\Copy.java");
 
        //读写数据，复制文件（一次读写一个字符数据）
//        int ch;
//        while ((ch=fr.read())!=-1) {
//            fw.write(ch);
//        }
        //一次读写一个字符数组数据
        char[] chs = new char[1024];
        int len;
        while ((len=fr.read(chs))!=-1) {
            fw.write(chs,0,len);
        }
 
        //释放资源
        fw.close();
        fr.close();
    }
}

字节缓冲流 ：

     构造方法：

        BufferedOutputStream(OutputStream os);        

        

 //字节缓冲输出流：BufferedOutputStream(OutputStream out)
        BufferedOutputStream bos = new BufferedOutputStream(new 				                                       FileOutputStream("myByteStream\\bos.txt"));

        BufferedInputStream(InputStream os);

//字节缓冲输入流：BufferedInputStream(InputStream in)
        BufferedInputStream bis = new BufferedInputStream(new                                                          FileInputStream("myByteStream\\bos.txt"));

字节输入流  InputStream：

        构造方法：

                FileInputStream(String name)；

     

//创建字节输入流对象
        //FileInputStream(String name)
        FileInputStream fis = new FileInputStream("myByteStream\\fos.txt");

        常用方法：

                int read();/ / 读取一个字节的数据

                int read(byte[ ]b);/ / 读取数据到数组中，返回读取的长度没有则返回-1；

                void close();

                

对象序列化流：

     序列化：

        构造方法：

          ObjectOutputStream(OutputStream os);

         常用方法：

           void writeObject(Object obj);

           

对象类
public class Student implements Serializable {
 
}
测试类
public class ObjectOutputStreamDemo {
    public static void main(String[] args) throws IOException {
        //ObjectOutputStream(OutputStream out)：创建一个写入指定的OutputStream的ObjectOutputStream
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("myOtherStream\\oos.txt"));
 
        //创建对象
        Student s = new Student("林青霞",30);
 
        //void writeObject(Object obj)：将指定的对象写入ObjectOutputStream
        oos.writeObject(s);
 
        //释放资源
        oos.close();
    }
}

反序列化：

        构造方法：           

                ObjectInputStream(InputStream in)；

        常用方法：

                Object readObject()；

public class ObjectInputStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //ObjectInputStream(InputStream in)：创建从指定的InputStream读取的ObjectInputStream
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("myOtherStream\\oos.txt"));
 
        //Object readObject()：从ObjectInputStream读取一个对象
        Object obj = ois.readObject();
 
        Student s = (Student) obj;
        System.out.println(s.getName() + "," + s.getAge());
 
        ois.close();
    }
}