20、java的IO流

IO流：进行输入输出操作。

输入流：把数据从其他设备上读取到内存中的流

输出流：把数据从内存中写出到其他设备上的流

数据的类型分为：字节流和字符流

 

一切皆为字节：一切文件数据在存储时都是以二进制数字的形式保存，都是一个一个的字节，那么传输时一样如此。所以，字节流可以传输任意文件数据。在操作流的时候，我们要时刻明确，无论使用什么样的流对象，底层传输的始终为二进制数据

 

字节输出流：OutputStream

java.io.OutputStream:此抽象类是表示输出字节流的所有类的超类

定义了一些子类共性的成员方法：

public void close（）；关闭此输出流并释放与此流相关联的任何系统资源

public void flush（）；刷新此输出流并强制任何缓冲的输出字节被写出

public void write（byte[] b）;将b.length字节从指定的字节数组写入此输出流

public void write （byte[] b,int off,int len）;从指定的字符数组写入len字节，从偏移量off开始输出到此输出流

public abstract void write（int b）;将指定的字节输出流

 

java.io.FileOutputStream extends OutputStream :把内存中的数据写入到硬盘的文件中

构造方法：FileOutputStream(String name)创建一个向具有指定名称的文件中写入数据的输出文件流

               FileOutputStream(File file)创建一个向指定File对象表示的文件中写入数据的文件输出流

               FileOutputStream(String name ,boolean appent), 指定路径是否覆盖重写

                参数：String name：目的地是一个文件的路径

                         File file：目的地是一个文件

                构造方法的作用：1、创建一个FileOutputStream 对象

                                        2、会根据构造方法中传递的文件/文件路径，创建一个空的文件

                                        3、会把FileOutputStream对象指向创建好的文件

写入数据的原理：Java程序->JVM->OS->OS调用写数据的方法->把数据写入到文件中

字节输出流的使用步骤：1、创建一个FileOutputStream对象，构造方法中传递写入数据的目的地

                                 2、调用FileOutputStream对象中的方法write，把数据写入到文件中

                                 3、释放资源

public class Demo {

    public static void main(String[] args)throws Exception {
        File file = new File("c/a.txt");
        FileOutputStream os= new FileOutputStream(file,true);
        byte[] in = new byte[]{97,98,99,100};
        os.write(97);
        os.write(in,0,in.length);
        os.flush();
        os.close();

    }

字节输入流：InputStream

Java.io.InputStream:此抽象类是表示字节输入流的所有类的超类

定义了所有子类共性的方法：1、int read()从输入流中读取数据的下一个字节

                                       2、int read(byte[] b)从输入流中读取一定数量的字节，并将其存储到缓冲区数组b中

                                       3、void close（）关闭此输入流并释放与该流关联的所有系统资源

java.io.FileInputStream extends InputStream: 文件字节输入流

作用：把硬盘文件中的数据，读取到内存中使用

构造方法：FileInputStream（String name）

               FileInputStream（File file）

构造方法作用：1、会创建一个FileInputStream对象

                     2、会把FileInputStream对象指向构造方法要读取到文件

                     

读取数据的原理：Java程序->JVM->OS->OS读取数据的方法-> 读取文件

字节输入流的使用步骤：1、创建FileInputStream对象，构造方法中绑定要读取的数据源

                                 2、使用FileInputStream对象中的方法read，读取文件

                                 3、释放资源

public class Demo {

    public static void main(String[] args)throws Exception {
        File file = new File("c/a.txt");
        FileInputStream is = new FileInputStream(file);
        byte[] buffer=  new byte[1024];
        int len = is.read(buffer);
        System.out.println(len);
        System.out.println(Arrays.toString(Arrays.copyOf(buffer,len)));
        is.close();

    }


}

字符流：

java.io.Reader:字符输入流，是字符输入流的最顶端的父类

共性的成员方法：int read()读取单个字符并返回

                        int read(char [] cbuf)一次读取多个字符，将字符读入数组

                        void close()关闭该流并释放与之关联的所有资源

 

java.io.FileReader extends InputStreamReader extends Reader

FileReader:文件字符输入流

作用：把硬盘文件中的数据以字符的方法读取到内存中

构造方法：FileReader（String fileName）

               FileReader（File file）

参数：String fileName：文件路径

         File file ：一个文件

FileReader构造方法的作用：1、创建一个FileReader对象

                                       2、会把FileReader对象指向要读取的文件

字符输入流的使用步骤：1、创建FileReader对象，构造方法中绑定要读取的数据源

                                 2、使用FileReader对象中的方法read读取文件

                                 3、释放资源

示例代码

public class Demo {

    public static void main(String[] args)throws Exception {
        FileReader reader = new FileReader(new File("c/a.txt"));
        int len = 0;
        char [] chars =new char[1024];
        System.out.println(reader.read());
        System.out.println(reader.read(chars));
        System.out.println(Arrays.toString(Arrays.copyOf(chars,9)));
        reader.close();

    }

java.io.write:字符输出流，是所有字符输出流的最顶层的父类，是一个抽象类

共性成员方法：void wirte(int c)写入单个字符

                     void write（char[] cbuf）写入字符数组

                    abstract void write (char [] cbuf,int off,int len) 写入字符数组的某一部分，off数组的开始索引，len写的字符个数

                    void write(String str)写入字符串

                    void write(String str,int off,int len)写入字符串的某一部分，off字符串的开始索引，len写的字符个数

                    void flush（）刷新该流的缓冲

                    void close（）关闭此流，但是要先刷新它

 

java.io.FileWriter extends OutputStream extends Writer

Filewriter:文件字符输出流

作用：把内存中字符数据写入到文件中

构造方法：FileWriter（File file）根据给定的File对象构造一个FileWriter对象

               FileWriter(String fileName)根据给定的文件名构造一个FileWriter 对象

               参数：写入数据的目的地

                构造方法作用：1、会创建一个FileWriter对象

                                     2、会根据构造方法中传递的文件/文件路径，创建文件

                                     3、会把FileWriter对象指向创建好的文件

字符输出流的使用步骤：1、创建FileWriter对象，构造方法中绑定要写入数据的目的地

                                 2、使用FileWriter中的方法write，把数据写入到内存缓冲区（字符转换成字节的过程）

                                 3、使用FileWriter中的方法flush，把内存缓冲区中的数据，刷新到文件中

                                 4、释放资源

示例代码：

public class Demo {

    public static void main(String[] args)throws Exception {
        FileWriter fw = new FileWriter(new File("c/a.txt"),true);
        fw.write("你好");
        fw.flush();
        fw.close();
    }


}

properties:表示一个持久的属性集，properties可保存在流中或从流中加载。属性列表中每个键及其对应指都是一个字符串，唯一和IO流相结合的集合

示例代码：

public class Demo {

    public static void main(String[] args)throws Exception {
        FileWriter fw = new FileWriter(new File("c/a.txt"),false);
        Properties pp =new Properties();
        pp.setProperty("读者A","作品A");
        pp.setProperty("读者B","作品B");
        Set<Object> set = pp.keySet();
        for (Object obj:set) {
            System.out.println(pp.getProperty((String)obj));
        }

        pp.store(fw,"save");
        fw.close();
        Properties pp2 = new Properties();
        pp2.load(new FileReader(new File("c/a.txt")));
        Set<Object> set2 = pp2.keySet();
        for (Object obj:set2) {
            System.out.println(pp2.getProperty((String)obj));
        }


    }


}

 注意：1、字符流可以写中文，字节流不能，读也一样

          2、后面位注释，大多用“”

          3、键值对存储在文件，可以用等号或空格连接

          4、文件中的内容可以用#注释，注释过的内容不会被读取

 

缓冲流：基本流的一种增强

缓冲流的基本原理：在创建对象时，会创建一个内置的默认大小的缓冲区数组，通过缓冲区读写，减少系统IO次数，从而提高读写的效率

字节缓冲流：BufferedInputStream，BufferedOutputStream

字符缓冲流：BufferedReader，BufferedWriter

 

java.io.BufferedOutputStream extends OutputStream

构造方法：BufferedOutputStream(OutputStream out)

               BufferedOutPutStream(OutputStream out,int size)

 使用步骤：1、创建FileOutputStream对象，构造方法中绑定要输出的目的地

                2、创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream效率

                3、使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中

                4、使用BufferedOutputStream对象中的方法flush，刷新到文件中

                5、释放资源

public class Demo {

    public static void main(String[] args)throws Exception {
        FileOutputStream fos= new FileOutputStream(new File("c/a.txt"));
        BufferedOutputStream bfos= new BufferedOutputStream(fos);
        bfos.write("你好吗".getBytes());
        bfos.close();
        fos.close();


    }


}

java.io.BufferedInputStream extends InputStream

构造方法：BufferedInputStream（InputStream in）

               BufferedInputStream（InputStream in，int size）

使用步骤：1、创建FileInputStream对象，构造方法中绑定要读取到数据源

               2、创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream读写的读取效率

               3、使用BufferedInputStream对象中的方法read，读取文件

               4、释放资源

复制文件示例代码：

public class Demo {

    public static void main(String[] args)throws Exception {
        FileOutputStream fos= new FileOutputStream(new File("c/a.txt"));
        BufferedOutputStream bfos= new BufferedOutputStream(fos);
        bfos.write("你不好".getBytes());
        bfos.close();
        fos.close();

        FileInputStream fis = new FileInputStream(new File("c/a.txt"));
        BufferedInputStream bfis = new BufferedInputStream(fis);
        FileOutputStream fos2 = new FileOutputStream(new File("c/b.txt"));
        BufferedOutputStream bfos2= new BufferedOutputStream(fos2);
        int len =0;
        byte [] buffer = new byte[1024];
        while ((len=bfis.read(buffer))!=-1){
            bfos2.write(buffer,0,len);
            System.out.println(len);
            System.out.println(Arrays.toString(Arrays.copyOf(buffer,len)));
        }
        bfos2.flush();
        bfos2.close();
        fos2.close();
        bfis.close();
        fis.close();


    }


}

java.io.BufferedWriter extends Writer

构造方法:BufferedWriter(Writer out)

             BufferedWriter(Writer out,int size)

特有的成员方法：void newLine（）；

使用步骤：1、创建字符缓冲输出流对象，构造方法中传递字符输出流

               2、调用字符缓冲输出流中的方法write，把数据写入到内存缓冲区中

               3、调用字符缓冲输出流中的方法flush，把内存缓冲区中的数据，刷新到文件中

               4、释放资源

 

java.io.BufferedReader extends Reader

构造方法：BufferedReader(Reader in)

               BufferedReader(Reader in ,int size)

特有方法：String readLine（）；读取一个文本行

使用步骤：1、创建一个字符缓冲输入流对象，构造方法中传递字符输入流

               2、使用字符缓冲输入流对象中的方法read/readLine读取文本

               3、释放资源

public class Demo {

    public static void main(String[] args)throws Exception {
        File file  = new File("c/a.txt");
        BufferedReader br = new BufferedReader(new FileReader(file));
        File file1 = new File("c/b.txt");
        BufferedWriter bw = new BufferedWriter(new FileWriter(file1));
        int len = 0;
        char[] buffer = new char[1024];
        while ((len = br.read(buffer))!=-1){
            bw.write(buffer,0,len);
        }
        bw.flush();
        bw.close();
        br.close();
    }


}

转换流：可以指定编码表

java.io.OutputStreamWriter extends Writer

构造方法：OutputStream(OutputStream)创建使用默认字符编码

               OutputStream(OutputStream,string charsetName)创建指定字符集的

使用步骤：1、创建OutputStreamWriter对象，构造方法中传递字节输出流和指定的编码表名称

               2、使用OutputStreamWriter对象中的方法write，把字符转换文字节存储缓冲区中

               3、使用OutputStreamWriter对象中的方法flush，把内存缓冲区中的字节刷新到文件中

               4、释放资源

 

java.io.InputStreamReader extends Reader

构造方法：InputStreamReader(InputStream in )创建一个使用默认字符集的字节输入流

               InputStreamReader(InputStream in,String charsetName)创建使用指定字符集的字节输入流

使用步骤：1、创建InputStreamReader对象，构造方法中传递字节输入流和指定的编码表名称

               2、使用InputStreamReader对象中的方法read读取文件

               3、释放资源

示例代码：

public class Demo {

    public static void main(String[] args)throws Exception {
        File file  = new File("c/a.txt");
        InputStreamReader isr = new InputStreamReader(new FileInputStream(file),"UTF-8");
        File file1 = new File("c/b.txt");
        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream(file1),"UTF-8");
        int len = 0;
        char[] buffer = new char[1024];
        while ((len = isr.read(buffer))!=-1){
            osw.write(buffer,0,len);
        }
        osw.flush();
        osw.close();
        isr.close();
    }


}

序列化流：

序列化：把对象以流的方式，写入到文件中保存，叫做对象的序列化

反序列化：把文件中保存的对象，以流的方式读取出来，叫做对象的反序列化

 

java.io.ObjectOutputStream extends OutputStream

构造方法：ObjectOutputStream(OutputStream out)

特有的成员方法：void writerObject（Object obj）

使用步骤：1、创建ObjectOutputStream对象，构造方法中传递字节输出流

               2、使用ObjectOutputStream对象中的方法writeObject，把对象写入到文件中

               3、释放资源

 

java.io.ObjectInputStream extends InputStream

构造方法：ObjectInputStream(InputStream in)

特有成员方法：Object readObject()

使用步骤：1、创建ObjectInputStream对象，构造方法中传递字节输入流

               2、使用ObjectInputStream对象中的方法readObject读取保存对象的文件

               3、释放资源

 

注意：序列化和反序列的对象类必须实现Serializable接口，且存在

 

扩展：1、被static修饰成员变量不能被序列化，同理transient（瞬态关键字），被修饰的成员变量不能被序列化，但是有不具备静态成员变量的属性

         2、可以通过private static final long serialVersionUID = 1L; 的格式手动添加序列号

 

示例代码：

public class Demo {

    public static void main(String[] args)throws  Exception {
        ObjectOutputStream oos =new ObjectOutputStream(new FileOutputStream(new File("c/b.txt")));
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(new File("c/b.txt")));

        Person p1 = new Person("读者A",18);
        Person p2 =new Person("读者B",19);

        ArrayList<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);

        oos.writeObject(list);

        Object o = ois.readObject();
        ArrayList<Person> list1 =(ArrayList<Person>)o;

        for (Person p:list1) {
            System.out.println(p);
        }

    }


}

打印流：

java.io.PrintStream

特点：1、只负责数据的输出，不负责数据的读取

         2、与其他的输出流不同，PrintStream永远不会抛出IOException

         3、特有方法：void print（任意类型的值）

                             void print （任意类型的值并换行）

构造方法：PrintStream（File file）输出目的地是一个文件

               PrintStream（OutputStream out）输出目的地是一个字节输出流

               PrintStream（String fileName）输出目的地是一个文件路径

注意：如果使用继承自父类的write方法写数据，那么查看数据的时候会查询编码表 97->a

         如果使用自己特有的方法print方法写数据，学的数据原样输出

public class Demo {

    public static void main(String[] args)throws  Exception {
        PrintStream ps = new PrintStream(new File("c/a.txt"));
        ps.print("原样打印");
    }

}

转载于:https://my.oschina.net/u/4131739/blog/3065050