20、java的IO流

时间  2019-11-22
标签 java 栏目 Java 繁體版
原文   原文链接

IO流：进行输入输出操做。java

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

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

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

 

一切皆为字节：一切文件数据在存储时都是以二进制数字的形式保存，都是一个一个的字节，那么传输时同样如此。因此，字节流能够传输任意文件数据。在操做流的时候，咱们要时刻明确，不管使用什么样的流对象，底层传输的始终为二进制数据对象

 

字节输出流：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：目的地是一个文件

                构造方法的做用：一、建立一个FileOutputStream 对象

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

                                        三、会把FileOutputStream对象指向建立好的文件

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

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

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

                                 三、释放资源

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:此抽象类是表示字节输入流的全部类的超类

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

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

                                       三、void close（）关闭此输入流并释放与该流关联的全部系统资源

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

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

构造方法：FileInputStream（String name）

               FileInputStream（File file）

构造方法做用：一、会建立一个FileInputStream对象

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

                     

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

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

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

                                 三、释放资源

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构造方法的做用：一、建立一个FileReader对象

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

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

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

                                 三、释放资源

示例代码

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 对象

               参数：写入数据的目的地

                构造方法做用：一、会建立一个FileWriter对象

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

                                     三、会把FileWriter对象指向建立好的文件

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

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

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

                                 四、释放资源

示例代码：

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));
        }


    }


}

 注意：一、字符流能够写中文，字节流不能，读也同样

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

          三、键值对存储在文件，能够用等号或空格链接

          四、文件中的内容能够用#注释，注释过的内容不会被读取

 

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

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

字节缓冲流：BufferedInputStream，BufferedOutputStream

字符缓冲流：BufferedReader，BufferedWriter

 

java.io.BufferedOutputStream extends OutputStream

构造方法：BufferedOutputStream(OutputStream out)

               BufferedOutPutStream(OutputStream out,int size)

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

                二、建立BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提升FileOutputStream效率

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

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

                五、释放资源

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）

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

               二、建立BufferedInputStream对象，构造方法中传递FileInputStream对象，提升FileInputStream读写的读取效率

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

               四、释放资源

复制文件示例代码：

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（）；

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

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

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

               四、释放资源

 

java.io.BufferedReader extends Reader

构造方法：BufferedReader(Reader in)

               BufferedReader(Reader in ,int size)

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

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

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

               三、释放资源

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)建立指定字符集的

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

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

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

               四、释放资源

 

java.io.InputStreamReader extends Reader

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

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

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

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

               三、释放资源

示例代码：

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）

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

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

               三、释放资源

 

java.io.ObjectInputStream extends InputStream

构造方法：ObjectInputStream(InputStream in)

特有成员方法：Object readObject()

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

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

               三、释放资源

 

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

 

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

         二、能够经过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

特色：一、只负责数据的输出，不负责数据的读取

         二、与其余的输出流不一样，PrintStream永远不会抛出IOException

         三、特有方法：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("原样打印");
    }

}
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程