IO流回顾(一)

时间:2021-08-11作者:klpeng分类:Java技术浏览:132评论:0

IO流的概述和分类

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

字节流

字节输出流的基本使用

/*
    java.io.OutputStream:字节输出流
        此抽象类是表示输出字节流的所有类的超类。
        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(File file)
            FileOutputStream(String name)
            参数:输出的目的地
                File file:输出的目的地是一个文件
                String name:输出的目的地是一个文件的路径
            构造方法的作用:
                1.会创建FileOutputStream对象
                2.会根据构造方法中传递文件|文件的路径,创建一个空白的文件
                3.会把FileOutputStream对象指向创建好的文件
    使用字节输出流往文件中写数据的底层过程
        java程序==>JVM==>操作系统(OS)==>调用系统中写数据的方法==>把数据写到文件中
    字节输出流的使用步骤(重点)
        1.创建FileOutputStream对象,构造方法中绑定输出的目的地
        2.使用FileOutputStream对象中的方法write,把数据写入到文件中
        3.释放资源
 */
public class Demo01OutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建FileOutputStream对象,构造方法中绑定输出的目的地
        FileOutputStream fos = new FileOutputStream("day14\\a.txt");
        //2.使用FileOutputStream对象中的方法write,把数据写入到文件中
        //public abstract void write(int b) 一次写一个字节
        fos.write(97);
        //3.释放资源
        fos.close();
    }
}

IO流回顾(一)

字节输出流写多个字节的方法

/*
    字节输出流中写多个字节的方法
        public void write(byte[] b) 一次写字节数组中的多个字节到文件中
        public void write(byte[] b, int off, int len) 写字节数组的一部分到文件中
            off:数组的开始索引
            len:写的字节个数
 */
public class Demo02OutputStream {
    public static void main(String[] args) throws IOException {
        //1.创建字节输出流FileOutputStream对象,构造方法中绑定要写的目的地
        FileOutputStream fos = new FileOutputStream(new File("day14\\b.txt"));
        //2.使用FileOutputStream对象中的方法write,把数据写入到文件中
        /*
            public void write(byte[] b) 一次写字节数组中的多个字节到文件中
            一次写多个字节:了解
                第一个字节是负数,那么会和第二个字节组成一个中文
                第一个字节是正数,那么写出单个的字节
         */
        byte[] bytes = {65,66,67,68,69};//ABCDE
        //byte[] bytes = {-65,-66,-67,68,69};//烤紻E
        fos.write(bytes);

        /*
            思考
                在文件中显示100,怎么写?
         */
        byte[] bytes2 = {49,48,48};
        fos.write(bytes2);

        /*
            public void write(byte[] b, int off, int len) 写字节数组的一部分到文件中
            off:数组的开始索引
            len:写的字节个数
         */
        fos.write(bytes,1,3);//BCD]

        //把字符串转换为字节数组,写入到文件中
        byte[] bytes3 = "中国".getBytes();
        System.out.println(Arrays.toString(bytes3));//IDEA默认是UTF-8编码 [-28, -72, -83, -27, -101, -67]6个字节
        fos.write(bytes3);

        //3.释放资源
        fos.close();
    }
}

字节输出流的续写和换行

换行:使用换行符号
windows: \r\n
linux: /n
mac: /r 从Mac OS X版本开始与linux统一

/*
    字节输出流的续写和换行
    1.续写(追加写):使用两个参数的构造方法
        FileOutputStream(File file, boolean append)
        FileOutputStream(String name, boolean append)
        参数:
            File file,String name:写入数据的目的地
            boolean append:续写开关
                true:可以续写,使用构造方法创建对象,文件名相同,不会创建新的文件覆盖之前的文件,会继续往文件的末尾写数据
                false:不可以续写,使用构造方法创建对象,文件名相同,会创建一个新的空白文件覆盖之前的文件,在新的文件写数据
    2.换行:使用换行符号
        windows: \r\n
        linux: /n
        mac: /r  从Mac OS X版本开始与linux统一
 */
public class Demo03OutputStream {
    public static void main(String[] args) throws IOException {
        //创建FileOutputStream对象,构造方法中传递输出的目的地和续写开关
        FileOutputStream fos = new FileOutputStream("day14\\c.txt",true);
        //使用FileOutputStream对象中的方法write,把数据写入到文件中
        for (int i = 1; i <= 10; i++) {
            fos.write(("你好"+i+"\r\n").getBytes());
        }
        //释放资源
        fos.close();
    }
}

上边介绍了字节输出流,接下来介绍字节输入流

字节输入流的介绍

/*
    java.io.InputStream:字节输入流
        此抽象类是表示字节输入流的所有类的超类。
        InputStream里边定义了所有字节输入流中共性的成员方法,所有字节输入流都可以使用这些方法
    共性的成员方法:
        - public void close() :关闭此输入流并释放与此流相关联的任何系统资源。
        - public abstract int read(): 从输入流读取数据的下一个字节。
        - public int read(byte[] b): 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
    java.io.FileInputStream:文件字节输入流 extends InputStream
    作用:
        把文件中的数据,以字节的方式读取到内存中
    构造方法:
        FileInputStream(File file)
        FileInputStream(String name)
        参数:传递要读取的数据源
            File file:读取的数据源是一个文件
            String name:读取的数据源是一个文件的路径
        构造方法的作用:
            1.会创建FileInputStream对象
            2.会把创建好的FileInputStream对象指向要读取的文件中的第一个字节
    注意:
        要读取的文件不存在,那么会抛出文件找不到异常
    使用字节输入流读取文件到内存中的底层原理:
        java程序=>JVM==>操作系统==>调用系统中读取数据的方法==>读取文件
 */

字节输入流的基本使用:一次读取一个字节

/*
    java.io.InputStream:字节输入流
        此抽象类是表示字节输入流的所有类的超类。
        InputStream里边定义了所有字节输入流中共性的成员方法,所有字节输入流都可以使用这些方法
    共性的成员方法:
        - public void close() :关闭此输入流并释放与此流相关联的任何系统资源。
        - public abstract int read(): 从输入流读取数据的下一个字节。
        - public int read(byte[] b): 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
    java.io.FileInputStream:文件字节输入流 extends InputStream
    作用:
        把文件中的数据,以字节的方式读取到内存中
    构造方法:
        FileInputStream(File file)
        FileInputStream(String name)
        参数:传递要读取的数据源
            File file:读取的数据源是一个文件
            String name:读取的数据源是一个文件的路径
        构造方法的作用:
            1.会创建FileInputStream对象
            2.会把创建好的FileInputStream对象指向要读取的文件中的第一个字节
    注意:
        要读取的文件不存在,那么会抛出文件找不到异常
    使用字节输入流读取文件到内存中的底层原理:
        java程序=>JVM==>操作系统==>调用系统中读取数据的方法==>读取文件
 */
/*
    字节输入流的使用步骤(重点)
        1.创建FileInputStream对象,构造方法中绑定要读取的数据源
        2.FileInputStream对象中的方法read,以字节的方式读取文件
        3.释放资源
 */
public class Demo01InputStream {
    public static void main(String[] args) throws IOException {
        //1.创建FileInputStream对象,构造方法中绑定要读取的数据源
        //FileInputStream fis = new FileInputStream("D:\\Work_idea\\llz\\day15\\a.txt");
        FileInputStream fis = new FileInputStream("day15\\a.txt");
        //2.FileInputStream对象中的方法read,以字节的方式读取文件
        //- public abstract int read()一次读取一个字节并返回

        /*
            我们发现读取文件是一个重复的过程,所以可以使用循环优化
            不知道文件中有多少数据,使用while循环
            循环结束的条件,read方法读取到-1的时候结束

            布尔表达式:(len = fis.read())!=-1
                1.fis.read():读取一个字节
                2.len = fis.read():把读取到的字节赋值给len变量
                3.(len = fis.read())!=-1:判断变量len的值是否为-1
         */
        int len = 0;
        while ((len = fis.read())!=-1){
            System.out.print((char)len);
        }

        /*int len = fis.read();
        System.out.println(len);//97

        len = fis.read();
        System.out.println(len);//98

        len = fis.read();
        System.out.println(len);//99

        len = fis.read();
        System.out.println(len);//-1*/

        //3.释放资源
        fis.close();
    }
}

使用字节输入流一次读取多个字节

/*
    使用字节输入流一次读取多个字节
        - public int read(byte[] b): 从输入流中读取一些字节数,并将它们存储到字节数组 b中 。
    明确两个内容:
        1.read方法的参数byte[]字节数组的作用?
            起到缓冲作用,把读取到的字节依次存储到数组中
            把数组一次性的由操作系统返回给JVM,由JVM返回给java程序,效率高
            数组的长度一般都使用:1024或者1024的整数倍
        2.read方法的返回值int是什么?
            每次读取到的有效字节个数
    String类中的构造方法
        String(byte[] bytes) 把字节数组转换为字符串
        String(byte[] bytes, int offset, int length) 把字节数组的一部分转换为字符串
            int offset:数组的开始索引
            int length:转换的个数,读取到的有效字节个数
 */
public class Demo02InputStream {
    public static void main(String[] args) throws IOException {
        //1.创建字节输入流FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("day15\\b.txt");//ABCDE
        //2.使用FileInputStream对象中的方法read,以字节的方式读取文件
        //- public int read(byte[] b) 使用字节数组缓冲一次读取多个字节

        /*
            我们发现读取数据,是一个重复的过程,所以可以使用循环优化
            不知道文件中有多少数据,使用while循环
            循环结束的条件,read方法读取到-1结束
         */
        byte[] bytes = new byte[1024];
        int len = 0;
        while ((len = fis.read(bytes))!=-1){
            //把字节数组的一部分转换为字符串
            System.out.println(new String(bytes,0,len));
        }


        /*byte[] bytes = new byte[2];
        int len = fis.read(bytes);
        //System.out.println(Arrays.toString(bytes));//[65, 66]
        System.out.println(new String(bytes));//AB
        System.out.println(len);//2

        len = fis.read(bytes);
        System.out.println(new String(bytes));//CD
        System.out.println(len);//2

        len = fis.read(bytes);
        System.out.println(new String(bytes));//ED
        System.out.println(len);//1

        len = fis.read(bytes);
        System.out.println(new String(bytes));//ED
        System.out.println(len);//-1*/

        //3.释放资源
        fis.close();
    }
}

IO流回顾(一)

文件复制(重点)

IO流回顾(一)

/*
    文件复制:
    原理:一读一写
    数据源: c:\\1.jpg
    写的目的地: d:\\1.jpg
    实现步骤:
        1.创建FileInputStream对象,构造方法中绑定要读取的数据源
        2.创建FileOutputStream对象,构造方法中绑定要写的目的地
        3.使用FileInputStream对象中的方法read,以字节的方式读取文件
        4.使用FileOutputStream对象中的方法write,把读取到的字节写入到文件中
        5.释放资源
 */
public class Demo01CopyFile {
    public static void main(String[] args) throws IOException {
        long s = System.currentTimeMillis();
        //1.创建FileInputStream对象,构造方法中绑定要读取的数据源
        FileInputStream fis = new FileInputStream("c:\\1.exe");
        //2.创建FileOutputStream对象,构造方法中绑定要写的目的地
        FileOutputStream fos = new FileOutputStream("d:\\1.exe");
        //3.使用FileInputStream对象中的方法read,以字节的方式读取文件
        //一次读取一个字节,写一个字节的方式复制:效率低下
        /*int len = 0;
        while ((len = fis.read())!=-1){
            //4.使用FileOutputStream对象中的方法write,把读取到的字节写入到文件中
            fos.write(len);
        }*/

        //一次读取多个字节,写多个字节的方式复制:效率高
        byte[] bytes = new byte[1024*500];
        int len = 0;
        while ((len = fis.read(bytes))!=-1){
            fos.write(bytes,0,len);//写读取到的有效的字节个数(最后一次不一定读取1024个)
        }

        //5.释放资源
        fos.close();
        fis.close();
        long e = System.currentTimeMillis();
        System.out.println("复制文件共耗时:"+(e-s)+"毫秒!");
    }
}
打赏
文章版权声明:除非注明,否则均为彭超的博客原创文章,转载或复制请以超链接形式并注明出处。
相关推荐

发表评论:

◎欢迎参与讨论,请在这里发表您的看法、交流您的观点。

猜你喜欢