zoukankan      html  css  js  c++  java
  • Java中的IO流操作

    IO流

    一、IO产生的原因

    1、在操作系统中,一切数据都是以文件的形式存储。

    2、需要将文件长久存储在外部设备。

    3、程序运行时,所有的数据都需要在内存中,而内存的大小有限,因此常常需要在内存和外设之间交换数据,即IO。

    4、在Java语言中,主要通过输入流和输出流完成I/O功能,实现和外设之间的数据交互。


    二、IO流

    1、IO流用来处理JVM和外部设备之间的数据传输,Java通过流(Stream)的方式,完成数据的传输过程。

    2、IO流的分类:

    (1)按数据流动的方向:

    a、输入流:对应数据的读入,将外设数据读入JVM内存

    b、输出流:对于数据的写出,将数据写入到外设

    (2)、按流中的内容():

    a、字节流:流中的数据都是以字节为单位的二进制数据。字节流可以操作一切类型的数据,只是有时操作字符数据不太方便,所有字符数据专门交给字符流。

    b、字符流:流中的数据都是以字符为单位的二进制数据。文本编辑器可以打开,并且人可以看懂的数据。

    3、IO流的基类:

    (1)、字节流:

    a、输入流:InputStream (抽象类)

    b、输出流:OutputStream (抽象类)

    (2)、字符流:

    a、输入流:Reader(抽象类)

    b、输出流:Writer(抽象类)

    (3)、由这四个类派生出来的子类名字都是以其父类名作为子类名的后缀。如:InputStream的子类FileInputStream;Reader的子类FileReader。

    4、字节流(重要):

    (1)输出流(OutputStream):

    a、实例化:OutputStream是抽象类,无法直接实例化,只能间接实例化,因为通常操作的都是文件数据,所以使用其操作文件的具体子类FileOutputStream实例化

    FileOutputStream的构造方法:

    (1)、FileOutputStream(File file)
    (2)、FileOutputStream(String name)
    

    b、使用,即向外设写入数据:

    // write()的三个重载方法
    public void write(int b)
    public void write(byte[] b)
    public void write(byte[] b, int off, int len)
    

    以下分别实现三个重载方法:

    // void write(int b) 
    // 将指定的字节写入此输出流。
    // write 的常规协定是:向输出流写入一个字节。要写入的字节是参数 b 的八个低位。b 的 24 个高位将被忽略。
    
    package com.io.review;
    
    import java.io.*;
    
    /**
     * @author: Lucas
     * @version: 1.0
     * @date: 2020/6/26 20:25
     *  void write(int b)方法
     */
    public class WriteDemo1 {
    
        public static void main(String[] args) throws IOException {
            // 创建File对象
            File file = new File("E:\TestDir\a.txt");
    
            // 1、利用OutputStream的子类FileOutputStream创建输出流对象
            OutputStream out = new FileOutputStream(file);
    
            // 2、向目标目录写入数据(写入字符串"Hello,World")
            byte[] bytes = "Hello,World".getBytes();
            for (int i = 0; i < bytes.length; i++) {
                // 逐个读入字符
                out.write(bytes[i]);
            }
            // 3、关闭输出流对象,并释放资源
            out.close();
    
        }
    }
    
    
    // void write(byte[] b)
    // 将 b.length 个字节从指定的 byte 数组写入此输出流。
    
    package com.io.review;
    
    import java.io.*;
    
    /**
     * @author: Lucas
     * @version: 1.0
     * @date: 2020/6/26 20:48
     *      实现 void write(byte[] b)
     */
    public class WriteDemo2 {
    
        public static void main(String[] args) throws IOException {
            // 创建File对象
            File file = new File("E:\TestDir\b.txt");
    
            // 1、创建输出流对象
            OutputStream out = new FileOutputStream(file);
    
            // 2、将数据写入目标目录(向b.txt中写入
            //"zhangsan
            // lisi
            // wangwu")
            byte[] bytes = "zhangsan
    lisi
    wangwu
    ".getBytes();
            out.write(bytes);
    
            // 关闭输出流对象,并释放资源
            out.close();
        }
    }
    
    // void write(byte[] b, int off, int len)
    // 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。
    // 参数:
    // b - 数据。
    // off - 数据中的初始偏移量。
    // len - 要写入的字节数。
    
    package com.io.review;
    
    import java.io.*;
    
    /**
     * @author: Lucas
     * @version: 1.0
     * @date: 2020/6/26 20:57
     *
     *  void write(byte[] b, int off, int len)
     */
    public class WriteDemo3 {
    
        public static void main(String[] args) throws IOException {
            // 创建File对象
            File file = new File("E:\TestDir\c.txt");
    
            // 1、创建输出流对象
            OutputStream out = new FileOutputStream(file);
    
            // 2、向目标目录写出数据(向b.txt写出“”)
            byte[] bytes = ("我是个俗气至顶的人,
    " +
                    "见山是山,
    " +
                    "见海是海,
    " +
                    "见花便是花。
    " +
                    "唯独见了你,
    " +
                    "云海开始翻涌,
    " +
                    "江潮开始...
    ").getBytes();
            out.write(bytes, 0, bytes.length);
    
            // 3、关闭输出流,并释放资源
            out.close();
        }
    }
    
    

    c、字节流写数据常见的问题:

    创建字节输出流到底做了哪些事情?

    1)、FileOutputStream会先在操作系统中找到目标文件:若目标文件不存在,FileOutputStream类会创建这个文件;若文件存在,则不再创建,清空文件内容,准备从文件最开始的地方写入

    2)、在内存中,创建FileOutputStream对象

    3)、在FileOutputStream和目录之间建立数据传送通道

    数据写成功后,为什么要close()?

    关闭次输出流并释放与此流有关的所有系统资源

    如何实现速记的换行?(利用换行符)

    windows:' ' 或 ’ ‘

    linux、mac OS:’ ‘

    如何实现数据的追加写入?

    1)FileOutputStream(File file, boolean append)

    2)创建一个指定File对象表示的文件中写入数据的文件输出流。如果第二个参数为true,则将字节写入文件末尾处(而不是写入文件开始处)

    // 实现数据的追加写入
    // FileOutputStream(File file, boolean append)
    // 创建一个向具有指定 File 的文件中写入数据的输出文件流。
    // 如果第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处
    
    package com.cskaoyan.review;
    
    import java.io.*;
    
    /**
     * @author: Lucas
     * @version: 1.0
     * @date: 2020/6/26 23:27
            实现数据的追加写入:
                FileOutputStream(String name, boolean append)
                创建一个向具有指定 name 的文件中写入数据的输出文件流。
                如果第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处
    
                FileOutputStream(File file, boolean append)
                创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
                如果第二个参数为 true,则将字节写入文件末尾处,而不是写入文件开始处
     */
    
    public class AppendDemo {
    
        public static void main(String[] args) throws IOException {
    
            // 创建File对象
            File file = new File("E:\TestDir\d.txt");
    
            // 1、创建输出流对象
            OutputStream out = new FileOutputStream(file, true);
    
            // 2、向目标目录文件追加写入数据
            byte[] bytes = ("我们聊天的时候,有的人说“再见”,
    " +
                    "后面是一个波浪号,是轻盈的,
    " +
                    "这种是就算不约定几月几号也...
    ").getBytes();
    
            out.write(bytes);
    
            // 追加写入
            byte[] bytes1 = ("我们年轻的时候,总是把创作的冲动误以为是创作的才华;
    " +
                    "总是把对孤独的恐惧误以为是对爱情的向往。").getBytes();
            out.write(bytes1);
    
            // 3、关闭输出流,并释放资源
            out.close();
        }
    }
    
    
    
    

    (2)、输出流(InputStream):

    a、InputStream是抽象类,无法直接实例化,只能间接实例化,因为通常操作的都是文件数据,所以使用其操作文件的具体子类FileInputStream实例化。

    b、FileInputStream的构造方法:

    (1)、FileInputStream(File file)
    (2)、FileInputStream(String name)
     FileInputStream的构造方法
       // 创建一个读取指定文件(目标文件)数据的,文件字节输入流对象(目标文件以File对象的形式表示)
          FileInputStream(File file)
       // 创建一个读取指定文件(目标文件)数据的,文件字节输入流对象(目标文件以File对象的形式表示)
           FileInputStream(String name)
          
    

    c、使用,即从外设读入数据:

    // read()的两个重载方法
    public int read() 
    public int read(byte[] b) 
    

    以下分别实现read()的两个重载方法:

    // int read()
    package com.cskaoyan.review;
    
    import java.io.*;
    
    /**
     * @author: Lucas
     * @version: 1.0
     * @date: 2020/6/26 23:53
     *  int read()
     *      从输入流中读取数据的下一个 字节。
     *      返回值:
     *            1.下一个数据字节;
     *            2.如果到达流的末尾(没有数据可读),则返回 -1。
     */
    public class ReadDemo1 {
    
        public static void main(String[] args) throws IOException {
            // 创建File对象
            File file = new File("E:\testDir\c.txt");
    
            // 1、创建输入流对象
            InputStream in = new FileInputStream(file);
    
            // 2、int read() 逐个字符读入
            int readByte;
            while ((readByte = in.read()) != -1) {
                char c = (char) readByte;
                System.out.print(c);
            }
    
            // 3、关闭输入流对象,并释放资源
            in.close();
        }
    }
    
    
    
    // int read(byte[] b) 
    package com.cskaoyan.review;
    
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.IOException;
    import java.io.InputStream;
    
    /**
     * @author: Lucas
     * @version: 1.0
     * @date: 2020/6/27 0:10
     * int read(byte[] b)
     *     从输入流中读取一定数量的字节,并将其存储在缓冲区数组 b 中。
     *     返回值:
     *          1. 读入缓冲区的总字节数;
     *          2. 如果因为已经到达流末尾而不再有数据可用,则返回 -1。
     */
    public class ReadDemo2 {
    
        public static void main(String[] args) throws IOException {
            // 1. 创建流对象
            InputStream input = new FileInputStream("E:\TestDir\a.txt");
    
            //2. 从目标文件读取数据
            // int read(byte[] b)
            // 实际开发中,通常给1024的整数倍 2^10
            byte[] buffer = new byte[1024];
            // len 就告诉我们实际向字节数组中填充了多少个字节数据(实际读取到的字节个数)
            int len = input.read(buffer);
    
            String s = new String(buffer,0, len);
            System.out.println(s);
    
            // 3. 关闭流并释放资源
            input.close();
        }
    }
    
    
    d、一次读入读入或写出一个字节效率高,还是一次读入或写出一个字节数组效率高
    一个字节数组效率高?
    

    ==》一个字节数组效率高,原因如下:

    每一次,读入或写出,即每次和外设的数据交互都需要依赖操作系统内核实现,这意味着每次读入或写出,都需要付出额外的通信代价。一次读入或写出一个字节数组的数据,平均到每个字节,付出的额外代价少很多

    练习:把d:a.txt内容复制到e:.txt中,把e:**.jpg内容复制到当前项目目录下的mn.jpg

    package com.cskaoyan.review;
    
    import java.io.*;
    
    /**
     * @author: Lucas
     * @version: 1.0
     * @date: 2020/6/27 0:19
            把d:\a.txt内容复制到e:\b.txt中
            把e:\**.jpg内容复制到当前项目目录下的mn.jpg
     */
    
    
    public class Exercise {
    
        public static void main(String[] args){
            // 复制文本文件
            //copyFile("e:\a.txt", "d:\b.txt");
    
            // 复制图片文件
            //copyFile("e:\copy\upload.jpg", "copy.jpg");
    
    
            // 演示一次复制一个字节数据
            String srcFilePath = "d:\a.txt";
            String destFilePath = "e:\b.txt";
            copyByByte(srcFilePath, destFilePath);
    
        }
    
        private static void copyByByte(String srcFilePath, String destFilePath) {
            InputStream input = null;
            OutputStream output = null;
            try {
                // 创建输入流对象,用来读取源文件内容
                input = new FileInputStream(srcFilePath);
                // 创建输出流对象, 用来向目标文件写入源文件内容
                output = new FileOutputStream(destFilePath);
    
                //读取源文件数据, 以单个字节为单位复制
                int readByte;
    
                while ((readByte = input.read()) != -1) {
                    // 向目标文件写一个字节
                    output.write(readByte);
                }
    
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭流并释放资源
                closeQuietly(input);
    
                //关闭输出流
                closeQuietly(output);
    
            }
        }
    
    
        private static void copyFile(String srcFilePath, String destFilePath) {
            InputStream input = null;
            OutputStream output = null;
            try {
                // 创建输入流对象,用来读取源文件内容
                input = new FileInputStream(srcFilePath);
                // 创建输出流对象, 用来向目标文件写入源文件内容
                output = new FileOutputStream(destFilePath);
    
                //读取源文件数据
                byte[] buffer = new byte[2048];
                int len;
                while ((len = input.read(buffer)) != -1) {
                    // 将读取到的源文件内容,写入到输出流中
                    output.write(buffer, 0, len);
                }
    
                //close
    
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                // 关闭流并释放资源
                closeQuietly(input);
    
                //关闭输出流
                closeQuietly(output);
    
            }
        }
    
    
        private static void closeQuietly(Closeable closeable) {
            try {
                if (closeable != null) {
                    // 多态
                    closeable.close();
                }
    
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    
    }
    
    
    
    

    (3)、缓冲流

    a、产生原因:

    1)、字节流一次读写一个数组的速度明显比读一个字节的速度快很多

    2)、这是加入了数组这样的缓冲区效果

    3)、Java本身在设计的时候,也考虑到了这样的情况,所以提供了字节缓冲区流

    b、字节缓冲输出流(BufferedOutputStream)

    ​ 字节缓冲输入流(BufferedInputStream)

  • 相关阅读:
    使用 Traefik 代理 UDP 服务
    KubeOperator界面,集群详情中的存储,存储提供商
    centos7使用yum方式安装node_exporter
    Traefik2.3.x 使用大全(更新版)
    jumpserver堡垒机版本升级,从2.14.2升级到2.16.3
    Traefik 2.0 实现灰度发布
    matplotlib 中文问题
    数据采集实战(五) 当当网童书排名
    雅可比行列式迭代及优化(golang版)
    mysql8.x docker 远程访问配置
  • 原文地址:https://www.cnblogs.com/lcpp/p/13196958.html
Copyright © 2011-2022 走看看