IO字节流学习总结

最新推荐文章于 2022-04-18 23:40:11 发布

crazy韩先森

最新推荐文章于 2022-04-18 23:40:11 发布

阅读量107

点赞数

文章标签： java

本文链接：https://blog.youkuaiyun.com/crazyhsl/article/details/111241587

版权

什么是IO？

Java中I/O的操作主要是靠java.io包下面的类和接口来实现的，进入输入、输出操作。输入也可以叫做读取数据，输出也可以叫做写入数据。

IO分类

根据数据的流向分为：输入流和输出流

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

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

字节流：以字节为单位，读写数据的流
字符流：以字符为单位，读写数据的流。

IO流的顶级父类

	输入流	输出流
字节流	字节输入流InputStream	字节输出流OutputStream
字符流	字符输入流Reader	字符输出流Writer

字节流

一切皆为字节

一切文件数据(文本文档，图片，视频等)在存储时，都是以二进制数字的形式保存的，都是一个一个的字节，那么数据在进行传输的时候也是如此。所以字节流可以传输任意文件的数据。在操作流的时候，我们要明确，无论使用了什么样的流对象，底层传输的始终为二进制数据。

字节输出流[OutputStream]

java.io.OutputStream此抽象类是表示输出字节流的所有类的超类，将指定的字节信息写入到目的地。它定义了字节输出流的基本共性的api方法：

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)：将指定的字节输出到此输出流中。

备注：close方法，当完成流的操作时，必须调用此方法，释放系统资源。

FileOutputStream类

java.io.FileOutputStream类是文件字节输出流，用于将数据写入到文件中。

构造方法

public FileOutputStream(File file)：创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
public FileOutputStream(String name)：创建文件输出流以指定的的文件名称写入文件中。

当你创建一个流对象时，必须先传递一个文件路径，该路径下，如果没有这个文件，会创建该文件，如果有这个文件，会清空这个文件当中的数据。

数据的追加续写

如何在保留目标文件中的数据，还能继续添加新的数据到目标文件中？

public FileOutputStream(File file,boolean append)：创建文件输出流以写入由指定的File对象表示的文件中。
public FileOutputStream(String name,boolean append)：创建文件输出流以指定的名称写入文件中。

这两个构造方法，参数中都需要传入一个boolean类型的值，true表示的追加数据，false表示的清空原有数据。在这样的情况下创建输出流对象，就可以指定是否需要在文件的末尾追加。

字节输出流代码演示：

/*
  java.io.FileOutputStream：文件输出流  extends OutputStream
  父类OutputStream常用的API方法如下：
     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):将指定的字节输出到此输出流中

  FileOutputStream
    作用：把内存当中的数据写入到硬盘文件中
  构造方法： 
    public FileOutputStream（File file）:创建一个向指定File对象表示的文件中写入数据的文件输出流。

    public FileOutputStream（String name）:创建文件输出流以指定的文件名称写入文件中。

    参数：File file:目的地是一个文件
         String name:目的地是一个文件的路径
  构造方法的作用：
    1.创建一个FileOutputStream类对象
    2.会根据构造方法中传递的文件/文件路径（路径上文件不存在），创建一个空的文件。
    3.会把FileOutputStream对象指向创建好的文件。
  字节输出流的使用步骤：
    1.创建一个FileOutputStream类对象，构造方法中传递的写入数据的目的地。
    2.调用FileOutputStream对象中的方法write,把数据写入到文件中。
    3.释放资源.
  写入数据的原理：
    java程序->JVM虚拟机->OS（操作系统）->OS调用操作系统中的写入数据的方法->把数据写入到文件中。
  写入一个字节：
    write(int b);
 */
public class DemoFileOutputStream {
    public static void main(String[] args) throws Exception {
        demo1();
        demo2();
        demo3();
    }

    //字节输出流的使用步骤（写入一个字节）：
    public static void demo1() throws IOException {
        //1.创建一个FileOutputStream类对象，构造方法中传递的写入数据的目的地。
        FileOutputStream fileOutputStream = new FileOutputStream("day28--IO\\a.txt");
        // 2.调用FileOutputStream对象中的方法write,把数据写入到文件中。
        fileOutputStream.write(97);//a
        //  3.释放资源.
        fileOutputStream.close();
    }
    //一次往文件中写入多个字节的方法
    public static void demo2() throws IOException {
        /*
         public void write（byte[] b）:将b.length字节从指定的字节数组写入到此输出流中。

         public void write(byte[] b,int off,int len):从指定的字节数组写入len个字节，从偏移量off开始输出到此输出流中
         */
        //1.创建一个FileOutputStream类对象，构造方法中传递的写入数据的目的地。
        FileOutputStream fileOutputStream = new FileOutputStream("day28--IO\\b.txt");
        // 2.调用FileOutputStream对象中的方法write,把数据写入到文件中。
        byte[] bytes = {97,98,99,100,101};
        //写的字节是正数0-127，那么现实的时候会查询ASCII表
        // 如果不是，查询的是系统默认码表
        //public void write（byte[] b）:将b.length字节从指定的字节数组写入到此输出流中。
        fileOutputStream.write(bytes);//abcde
        // public void write(byte[] b,int off,int len):从指定的字节数组写入len个字节，从偏移量off开始输出到此输出流中
        fileOutputStream.write(bytes, 0, 3);//abcde(+)abc
        //写入汉字
        byte[] bytes1="你好".getBytes();//一个汉字占三个字节（utf-8） GBK中一个汉字占二个字节.
        fileOutputStream.write(bytes1);

        //  3.释放资源.
        fileOutputStream.close();
    }
    /*
    追加/续写
      public FileOutputStream （File file ,boolean append）:创建文件输出流以写入由指定的File对象表示的文件中。

      pubic FileOutputStream（String name,boolean append）:创建文件输出流以指定的名称写入文件中。
    参数：
      String name ,File file :写入的数据的目的地
      boolean append:追加写入的开关
        true：创建对象不会覆盖原文件，继续在文件的末尾追加数据
        false:创建一个新文件，覆盖源文件。
     */
    public static void demo3() throws IOException {
        //1.创建一个FileOutputStream类对象，构造方法中传递的写入数据的目的地。
        FileOutputStream fileOutputStream = new FileOutputStream("day28--IO\\c.txt",false);//true：创建对象不会覆盖原文件，继续在文件的末尾追加数据
                                                                            // false:创建一个新文件，覆盖源文件。
        // 2.调用FileOutputStream对象中的方法write,把数据写入到文件中。
        fileOutputStream.write("helloWorld\r".getBytes());//helloWorld  换行\n和\r
        fileOutputStream.write("你好呀呀呀呀".getBytes());//helloWorld你好呀呀呀呀//追加数据
        //  3.关闭流对象
        fileOutputStream.close();
    }
    
}

写入换行

Windows系统里，换行符号是\r\n。把以指定是否需要追加续写换行。

Linux系统里，换行符号是 /n

mac系统里，换行符号是/r

Unix系统里，每行结尾只有换行，即/n

回车符\r和换行符\n

回车符：回到一行的开头
换行符：下一行(newLine)。

系统中的换行：

Windows系统中，每行结尾是回车+换行。即\r\n。
Unix系统中，每行的结尾只有换行，即/n
Mac系统中，每行的结尾是回车，即/r

public static void main(String[] args) throws IOException {
        //1.创建对象
        FileOutputStream fos = new FileOutputStream("day28_IO\\c.txt", true);
        // 实现数据换行
        fos.write("\r\n".getBytes());
        //2.调用write()
        fos.write("Java31".getBytes());
        //3.关闭流对象
        fos.close();
    }

字节输入流【InputStream】

java.io.InputStream此抽象类是表示字节输入流的所有类的超类。可以读取字节信息到内存中。他定义了字节输入流的基本共性的api方法：

public void close()：关闭此输入流并释放与此流相关的其他的任何系统资源。
public abstract int read()：从输入流中读取数据的下一个字节。
public int read(byte[] b)：从输入流中读取一些字节数，并将它们存储到字节数组b当中。

备注：close方法，当完成流的相关操作后，需要调用此方法关闭输入流，释放系统资源。

FileInputStream类

java.io.FileInputStream类是文件输入流，从文件中读取字节。

构造方法

FileInputStream(File file)：通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的File对象file命名。
FileInputStream(String name)：通过打开与实际文件的连接来创建一个FileInputStream,该文件由文件系统中的路径名name命名。

当你创建一个流对象时，必须传入一个文件路径。该路径下，如果没有该文件，会抛出FileNotFoundException。

可以使用字节数组来读取数据：read(byte[] b)：从输入流中读取多个字节，并且将其存储到缓冲区数组b当中。当读取到文件的末尾时，返回一个-1。

备注：使用数组读取，每次可以读取多个字节，减少了系统间的IO操作次数，从而提高了读取的效率，建议使用, 流的关闭顺序：先开后关，后开先关。。

字节输入流及子类代码演示：

import java.io.*;
/*
  InputStream 字节输入流，抽象类
            他是所有字节输入流的超类
  定义了所有子类共性的api方法。如下：
            public void close（）：关闭此输入流并释放与此流相关的其他的任何系统资源。

            public abstract int  read（）：从输入流中读取数据的下一个字节。

            public int  read（byte[] b）:从输入流中读取一些字节数，并将他们存储到字节数组b当中。

      FileInputStream  extends  InputStream
           作用：把硬盘文件中的数据，读取到内存中使用
      构造方法：
            FileInputStream（File file）：通过打开与实际文件的连接来创建一个FileInputStream，该文件有文件系统中的File对象file命名。

            FileInputStream（String name）:通过打开与实际文件的连接来创建一个FileInputStream，该文件由文件系统中的路径名name命名。
            参数：读取文件的数据源
                String name:文件的路径
                File  file :文件
            构造方法的作用有两个：
               1.会创建一个FileInputStream类对象
               2.会把FileInputStream类对象指定构造方法中要读取的文件
        字节输入流的使用步骤：
           1.创建一个FileInputStream类对象，构造方法中绑定要读取的文件
           2.使用FileInputStream类对象中的方法read（），读取文件中的数据
           3.释放资源，关闭流对象。
      读取数据的原理（硬盘->内存）
         java程序->JVM->OS->OS调用系统中读取数据的方法->读取文件的数据
 */
public class DemoFileInputStream {
    public static void main(String[] args) throws Exception {
       demo();
       demo1();
       demo2();
       demo3();
        demo4();


    }

    //报错情况
    public static void demo() throws IOException {
        //找不到相应文件，报错java.io.FileNotFoundException: day28--IO\d.txt (系统找不到指定的文件。)
//        FileInputStream fileInputStream;
//        fileInputStream = new FileInputStream("day28--IO\\d.txt");
    }

    public static void demo1() throws IOException {
        //1.创建一个FileInputStream类对象，构造方法中绑定要读取的文件
        FileInputStream fileInputStream = new FileInputStream("day28--IO\\c.txt");
        // 2.使用FileInputStream类对象中的方法read（），读取文件中的数据
        //读取文件中的一个字节并且返回
        //虽然读取了一个字节，但是会自动被提升位int类型。
        int read = fileInputStream.read();//读取单个字符
        System.out.println(read);//不是h而是104  可以强转(char)read
        int fi = 0;//循环遍历文件内容
        while ((fi = fileInputStream.read()) != -1) {
            System.out.println((char) fi);
        }


    }

    public static void demo2() throws IOException {
        //1.创建一个FileInputStream类对象，构造方法中绑定要读取的文件
        FileInputStream fileInputStream = new FileInputStream("day28--IO\\c.txt");
        // 2.使用FileInputStream类对象中的方法read（），读取文件中的数据\
        byte[] bytes = new byte[4];
        /*
        使用while循环
        while循环结束的条件是   有效的字节个数为-1
         */
        int len1 = 0;
        while ((len1 = fileInputStream.read(bytes)) != -1) {
            //byte[]  转换成String//输出字符而不是ASCII字符集对应的数字
            //1.String(byte[] bytes,int off,int length)
            //2.String(byte[] byte);
            //System.out.println(Arrays.toString(bytes));
            System.out.println(new String(bytes, 0, len1));
        }
        // 3.释放资源，关闭流对象。
        fileInputStream.close();
    }

    //图片复制   单字节读取
    public static void demo3() throws IOException {
  /*
    文件复制练习：图片复制
    明确：数据源;C:\Users\1024\Desktop\G1.jpeg
         数据的目的地：D:\precode\day28--IO\G1.jpeg
    步骤：创建一个字节输入流，构造方法中绑定需要读取的图片路径
         创建一个字节输出流，构造方法中绑定需要写入的文件
         使用字节输入流对象中的read方法读取文件
         使用字节输出流对象的write方法，把读取到的字节写入到指定的文件夹中。
  */
        //1.创建一个字节输入流，构造方法中绑定需要读取的图片路径
        FileInputStream file = new FileInputStream("C:\\Users\\1024\\Desktop\\G1.jpeg");
        //2.创建一个字节输出流，构造方法中绑定需要写入的文件
        FileOutputStream fileO = new FileOutputStream("D:\\precode\\day28--IO\\G1.jpeg");
        //byte[] a = new byte[1000];
        int l = 0;//一个一个字节读取的
        //3.使用字节输入流对象中的read方法读取文件
        while ((l = file.read()) != -1) {
            //4. 使用字节输出流对象的write方法，把读取到的字节写入到指定的文件夹中。
            fileO.write(l);
        }
        fileO.close();
        file.close();
    }
    //图片复制2  多字节读取
    public static void demo4() throws IOException {

         long t1=System.currentTimeMillis();
        //1.创建一个字节输入流，构造方法中绑定需要读取的图片路径
        FileInputStream file = new FileInputStream("C:\\Users\\1024\\Desktop\\G1.jpeg");
        //2.创建一个字节输出流，构造方法中绑定需要写入的文件
        FileOutputStream fileO = new FileOutputStream("D:\\precode\\day28--IO\\G1.jpeg");
        byte[] a = new byte[1024];
        int l = 0;
        //3.使用字节输入流对象中的read方法读取文件
        while ((l = file.read(a)) != -1) {
            //4. 使用字节输出流对象的write方法，把读取到的字节写入到指定的文件夹中。
            fileO.write(a, 0, l);
        }
        fileO.close();
        file.close();
        //计算复制时间
        long t2=System.currentTimeMillis();
        long t3=t2-t1;
        System.out.println(t3);

    }

}