Java IO流

最新推荐文章于 2023-03-17 13:07:10 发布

园丁2k

最新推荐文章于 2023-03-17 13:07:10 发布

阅读量210

点赞数

文章标签： java

本文链接：https://blog.csdn.net/weixin_40429706/article/details/110194696

版权

Java IO原理

输入input：读取外部数据（磁盘、光盘等存储设备的数据）到程序（内存）中。
输出output：将程序（内存）数据输出到磁盘、光盘等存储设备中。

流的分类

按操作数据单位不同分为：字节流（8bit = 1byte），字符流（16bit = ’1 char字符‘）

– 一般文本文件用字符流，图片、视频等用字节流
按数据流的流向不同分为：输入流，输出流
按流的角色的不同分为：节点流，处理流

（抽象基类）字节流字符流
输入流 InputStream Reader
输出流 OutputStream Writer
1. Java的IO流共涉及40多个类，实际上非常规则，都是从如下4个抽象基类派生的。
2. 由这四个类派生出来的子类名称都是以其父类作为子类名后缀。

（抽象基类）	字节流	字符流
输入流	InputStream	Reader
输出流	OutputStream	Writer

IO流体系

分类	字节输入流	字节输出流	字符输入流	字符输出流
抽象基类	InputStream	OutputStream	Reader	Writer
访问文件	FileInputStream	FileOutputStream	FileReader	FileWriter
访问数组	ByteArrayInputStream	ByteArrayOutputStream	CharArrayReader	CharArrayWriter
访问管道	PipedInputStream	PipedOutputStream	PipedReader	PipedWriter
访问字符串			StringReader	StringWriter
缓冲流	BufferedInputStream	BufferedOutputStream	BufferedReader	BufferedWriter
对象流	ObjectInputStream	ObjectOutputStream
	FilterInputStream	FilterOutputStream	FilterReader	FilterWriter
打印流		PrintStream		PrintWriter
推回输入流	PushbackInputStream		PushbackReader
特殊流	DataInputStream	DataOutputStream

基本字符流

package IO流;
import org.junit.Test;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/**
 * @author: 园丁
 * @date: 2020-11-25
 * @description: 测试FileReader和FileWriter的使用
 */
public class FileReaderWriterTest {

    /**
     * 将hello.txt文件内容读入程序中，并输出到控制台
     * 说明点：
     * 1. read()的理解：返回读入的一个字符。如果达到文件末尾，返回-1
     * 2. 异常的处理：为了保证流资源一定可以执行关闭操作。需要使用try-catch-finally处理
     * 3. 读入的文件一定要存在，否则就会报FileNotFoundException
     */
    @Test
    public void testFileReader(){
        // 1.实例化File类的对象，指明要操作的文件
        File file = new File("src\\IO流\\hello.txt");
//        System.out.println(file.getAbsoluteFile());
        // 2.提供具体的流
        FileReader fr = null;
        try {
            fr = new FileReader(file);
            // 3.数据的读入
            // read():返回读入的一个字符。如果达到文件末尾，返回-1
            // 方式一：
//        int data = fr.read();
//        while (data != -1) {
//            System.out.print((char) data);
//            data = fr.read();
//        }
            // 方式二：语法上针对方式一的修改
            int data;
            while ((data = fr.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4.流的关闭操作
//            try {
//                if (fr != null)
//                    fr.close();
//            } catch (IOException e) {
//                e.printStackTrace();
//            }或
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }

    /**
     * 对read()操作升级：使用read的重载方法
     */
    @Test
    public void testFileReader1() {
        // 1. File类的实例化
        File file = new File("src\\IO流\\hello.txt");
        // 2. FileReader流的实例化
        FileReader fr = null;
        try {
            fr = new FileReader(file);
            // 3. 读入的操作
            char[] cbuf = new char[5];
            int len = -1;
            // read(char[] cbuf):返回每次读入cbuf数组中的字符的个数。如果达到文件末尾，返回-1
            while ((len = fr.read(cbuf)) != -1) {
//                // 方法一：
//                for (int i = 0; i < len; i++) {
//                    System.out.print(cbuf[i]);
//                }
                // 方法二：
                String buf = new String(cbuf, 0, len);
                System.out.print(buf);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fr != null) {
                try {
                    // 4. 资源的关闭
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 从内存中写出数据到硬盘的文件里
     *
     * 说明：
     * 1. 输出操作，对应的File可以不存在的。并不会报异常
     * 2.   File对应的硬盘中的文件如果不存在，在输出的过程中，会自动创建此文件。
     *      File对应的硬盘中的文件如果存在：
     *          如果流使用的构造器是：FileWriter(file,false) / FileWriter(file):对原有的文件进行覆盖
     *          如果流使用的构造器是：FileWriter(file,true):不会对原有文件覆盖，而是在原有文件的数据的基础上进行追加
     */
    @Test
    public void testFileWriter() {
        // 1. 提供File类的对象，指明写出到的文件
        File file = new File("src\\IO流\\hello1.txt");

        // 2. 提供FileWriter的对象，用于数据的写出
        FileWriter fw = null;
        try {
            fw = new FileWriter(file, false);

            // 3. 写出的操作
            fw.write("I have a dream!\n");
            fw.write("you need to have a dream!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fw != null) {
                // 4. 流资源的关闭
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 不能使用字符流来处理图片等文件
     */
    @Test
    public void testFileReaderFileWriter() {
        // 1. 创建File类的对象，指明读入和写出的文件
        File srcFile = new File("src\\IO流\\hello.txt");
        File destFile = new File("src\\IO流\\hello2.txt");
        FileReader fr = null;
        FileWriter fw = null;
        try {
            // 2. 创建输入流和输出流的对象
            fr = new FileReader(srcFile);
            fw = new FileWriter(destFile);

            // 3. 数据的读入和写出操作
            char[] cbuf = new char[5];
            int len = -1; // 记录每次读入到cbuf数组的字符的个数
            while ((len = fr.read(cbuf)) != -1) {
                fw.write(cbuf, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 流的关闭
            if (fr != null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fw != null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

基础字节流

package IO流;

import org.junit.Test;

import java.io.*;

/**
 * @author: 园丁
 * @date: 2020-11-26
 * @description: 测试FileInputStream和FileOutputStream的使用
 *
 * 结论：
 * 1. 对于文本文件（.txt,.java,.c,.cpp)，使用字符流处理
 * 2. 对于非文本文件（.jpg,.mp2,.mp4,.avi,.doc,.ppt,...)使用字节流处理
 */
public class FileInputOutputStreamTest {

    /**
     * 使用字节流FileInputStream处理文本文件，可能出现乱码
     */
    @Test
    public void testFileInputStream() {
        FileInputStream fis = null;
        try {
            // 1. 造文件
            File file = new File("src\\IO流\\hello.txt");
            // 2. 造流
            fis = new FileInputStream(file);
            // 3. 读取内容
            byte[] bytes = new byte[5];
            int len = -1;
            while ((len = fis.read(bytes)) != -1) {
                String s = new String(bytes, 0, len);
                System.out.print(s);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 实现对图片的复制操作
     */
    @Test
    public void testFileInputOutputStream() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
            File srcFile = new File("src\\IO流\\timg.jpg");
            File destFile = new File("src\\IO流\\timg1.jpg");
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            byte[] bytes = new byte[5];
            int len = -1;
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 文件的复制操作
     */
    public boolean copyFile(String srcPath, String destPath) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        boolean ok = false;
        try {
            File srcFile = new File(srcPath);
            File destFile = new File(destPath);
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            // 这里是一个需要根据具体情况调优的值，一般测试用1024
            byte[] bytes = new byte[1024];
            int len = -1;
            while ((len = fis.read(bytes)) != -1) {
                fos.write(bytes, 0, len);
            }
            ok = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return ok;
        }
    }

    @Test
    public void testCopyFile() {
//        String srcPath = "src\\IO流\\timg.jpg";
//        String destPath = "src\\IO流\\timg2.jpg";
        String srcPath = "src\\IO流\\测试.mp4";
        String destPath = "src\\IO流\\测试1.mp4";
        long start = System.currentTimeMillis();
        if (copyFile(srcPath, destPath)) {
            System.out.println("复制成功！");
        } else {
            System.out.println("复制失败！");
        }
        long end = System.currentTimeMillis();
        System.out.println("复制操作花费的时间为：" + (end - start));
        // 667
    }
}

缓冲流

package IO流;

import org.junit.Test;

import java.io.*;

/**
 * @author: 园丁
 * @date: 2020-11-26
 * @description:
 * 处理流之一，缓冲流的使用
 * 1.缓冲流：
 * BufferedInputStream
 * BufferedOutputStream
 * BufferedReader
 * BufferedWriter
 * 2. 作用： 提升流的读取、写入的速度
 * 提高读写速度的原因： 内部提供了一个缓冲区
 * 3. 处理流，就是“套接”在已有的流的基础上。
 */
public class BufferedTest {

    /**
     * 实现非文本文件的复制
     */
    @Test
    public void bufferedStreamTest() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        try {
            // 1. 造文件
            File srcFile = new File(getPath("timg.jpg"));
            File destFile = new File(getPath("timg3.jpg"));
            // 2. 造流
            // 2.1 造节点流
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            // 2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            // 3. 复制的细节：读取、写入
            byte[] bytes = new byte[1024];
            int len = -1;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. 流的关闭，先关外面的包裹的流，再关里面初始的流
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    /**
     * 获取本地文件的相对路径
     * @param name 文件名
     * @return 本地文件的相对路径
     */
    public String getPath(String name) {
        return "src\\IO流\\" + name;
    }

    /**
     * 通过字节流复制
     * @param srcPath 复制的文件名字
     * @param destPath 复制存储的文件的名字
     * @return 返回是否复制成功
     */
    public boolean copyFile(String srcPath, String destPath) {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        boolean ok = false;
        try {
            // 1. 造文件
            File srcFile = new File(getPath(srcPath));
            File destFile = new File(getPath(destPath));
            // 2. 造流
            // 2.1 造节点流
            fis = new FileInputStream(srcFile);
            fos = new FileOutputStream(destFile);
            // 2.2 造缓冲流
            bis = new BufferedInputStream(fis);
            bos = new BufferedOutputStream(fos);
            // 3. 复制的细节：读取、写入
            byte[] bytes = new byte[1024];
            int len = -1;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes, 0, len);
//                // 刷新缓冲区 -- 一般不调用会自动调用
//                bos.flush();
            }
            ok = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. 流的关闭，先关外面的包裹的流，再关里面初始的流
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 缓冲流的关闭能够使文件流自动关闭
//            if (fis != null) {
//                try {
//                    fis.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//            if (fos != null) {
//                try {
//                    fos.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
        }
        return ok;
    }

    @Test
    public void testCopyFileByBuffer() {
        String srcPath = "测试.mp4";
        String destPath = "测试2.mp4";
        long start = System.currentTimeMillis();
        if (copyFile(srcPath, destPath)) {
            System.out.println("复制成功！");
        } else {
            System.out.println("复制失败！");
        }
        long end = System.currentTimeMillis();
        System.out.println("复制操作花费的时间为：" + (end - start));
        // 175
    }

    /**
     * 通过字符流复制
     * @param srcPath 复制的文件名字
     * @param destPath 复制存储的文件的名字
     * @return 返回是否复制成功
     */
    public boolean copyFile1(String srcPath, String destPath) {
        BufferedReader br = null;
        BufferedWriter bw = null;
        boolean ok = false;
        try {
            // 1. 造文件
            File srcFile = new File(getPath(srcPath));
            File destFile = new File(getPath(destPath));
            // 2. 造流
            br = new BufferedReader(new FileReader(srcFile));
            bw = new BufferedWriter(new FileWriter(destFile));
            // 3. 复制的细节：读取、写入
            // 方法一：
//            char[] bytes = new char[1024];
//            int len = -1;
//            while ((len = br.read(bytes)) != -1) {
//                bw.write(bytes, 0, len);
//            }
            // 方法二：
            String buffer = "";
            while ((buffer = br.readLine()) != null) {
                // data中不包含换行符
                bw.write(buffer);
                // 提供换行操作
                bw.newLine();
            }
            ok = true;
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 4. 流的关闭，先关外面的包裹的流，再关里面初始的流
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            // 缓冲流的关闭能够使文件流自动关闭
//            if (fis != null) {
//                try {
//                    fis.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
//            if (fos != null) {
//                try {
//                    fos.close();
//                } catch (IOException e) {
//                    e.printStackTrace();
//                }
//            }
        }
        return ok;
    }
}

转换流

package IO流;

import org.junit.Test;

import java.io.*;
import java.nio.charset.StandardCharsets;

/**
 * @author: 园丁
 * @date: 2020-11-26
 * @description:
 *      处理流之二：转换流的使用
 *          1. 转换流： 属于字符流
 *              InputStreamReader: 将一个字节的输入流转换为字符的输入流
 *              OutputStreamWriter: 将一个字符的输出流转换为字节的输出流
 *          2. 作用： 提供字节流与字符流之间的转换
 *          3. 解码： 字节、字节数组 ---> 字符数组、字符串
 *             编码： 字符数组、字符串 ---> 字节、字节数组
 *          4. 字符集
 */
public class InputStreamReaderTest {

    /**
        这里测试抛出异常，应该try-catch处理
     */
    @Test
    public void test1() throws IOException {
        FileInputStream fis = new FileInputStream(getPath("hello.txt"));
        // 参数2指明字符集，具体使用哪个字符集，取决于文件保存时使用的字符集，如果不指定默认使用系统默认的字符集
        InputStreamReader isr = new InputStreamReader(fis);
        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            String str = new String(cbuf, 0, len);
            System.out.print(str);
        }
        isr.close();
    }

    /**
        综合使用转换流
     */
    @Test
    public void test2() throws IOException {
        FileInputStream fis = new FileInputStream(getPath("hello.txt"));
        FileOutputStream fos = new FileOutputStream(getPath("hello4.txt"));
        // 参数2指明字符集，具体使用哪个字符集，取决于文件保存时使用的字符集，如果不指定默认使用系统默认的字符集
        InputStreamReader isr = new InputStreamReader(fis, StandardCharsets.UTF_8);
        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.ISO_8859_1);
        char[] cbuf = new char[20];
        int len;
        while ((len = isr.read(cbuf)) != -1) {
            osw.write(cbuf, 0, len);
        }
        isr.close();
        osw.close();
    }

    /**
     * 获取本地文件的相对路径
     * @param name 文件名
     * @return 本地文件的相对路径
     */
    public String getPath(String name) {
        return "src\\IO流\\" + name;
    }
}

其他流

package IO流;

import org.junit.Test;

import java.io.*;
import java.lang.annotation.Retention;
import java.net.Socket;

/**
 * @author: 园丁
 * @date: 2020-11-26
 * @description:
 *  其他流的使用
 *      1. 标准的输入、输出流
 *      2. 打印流
 *      3. 数据流
 */
public class OtherStreamTest {
    /**
        1. 标准的输入、输出流
            1.1
                System.in: 标准的输入流，默认从键盘输入
                System.out: 标准的输出流，默认从控制台输出
            1.2
                System类的setIn(InputStream is) / setOut(PrintStream ps)方式重新指定输入和输出
            1.3 练习
                从键盘输入字符串，要求将读取到的整行字符串转成大写输出。然后继续进行输入操作，
                直至当输入“e“或者”exit“时，退出程序。
                方法一： 使用Scanner实现，调用next()返回一个字符串
                方法二： 使用System.in实现。System.in ---> BufferedReader的readline()

       **** 由于idea不支持单元测试检查键盘输入，所以必须用main
     */
    @Test
    public void test1() {
        BufferedReader br = null;
        try {
            InputStreamReader isr = new InputStreamReader(System.in);
            br = new BufferedReader(isr);
            while (true) {
                System.out.println("请输入字符串：");
                String data = br.readLine();
                if ("e".equalsIgnoreCase(data) || "exit".equalsIgnoreCase(data)) {
                    System.out.println("程序结束");
                    break;
                }
                String upperCase = data.toUpperCase();
                System.out.println(upperCase);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) {
        OtherStreamTest o = new OtherStreamTest();
        o.test1();
    }

    /**
     *  2. 打印流: PrintStream 和 PrintWriter
     *      2.1 提供了一系列重载的print() 和 println()
     *      2.2 练习：
     */
    @Test
    public void test2() {
        PrintStream ps = null;
        try {
            FileOutputStream fos = new FileOutputStream(new File(getPath("hello5.txt")));
            // 创建打印输出流，设置为自动刷新模式（写入换行符或字节’\n‘时都会刷新输出缓冲区
            ps = new PrintStream(fos, true);
            if (ps != null) {
                // 把标准输出流（控制台输出）改成文件
                System.setOut(ps);
            }
            for (int i = 0; i <= 255; i++) {
                // 输出ASCII字符
                System.out.println((char) i);
                // 每50个数据一行
                if (i % 50 == 0) {
                    // 换行
                    System.out.println();
                }
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } finally {
            if (ps != null) {
                ps.close();
            }
        }
    }

    public String getPath(String name) {
        return "src\\IO流\\" + name;
    }

    /**
     * 3. 数据流
     *  3.1 DataInputStream 和 DataOutputStream
     *  3.2 作用：用于读取或写出基本数据类型的变量或字符串
     *
     * 练习： 将内存中的字符串、基本数据类型的变量写出
     * 注意： 处理异常应该仍然使用try-catch
     */
    @Test
    public void test3() throws IOException {
        DataOutputStream dos = new DataOutputStream(new FileOutputStream(getPath("hello6.txt")));
        dos.writeUTF("刘胡兰");
        // 刷新操作，将内存中的数据写入文件
        dos.flush();
        dos.writeInt(22);
        dos.flush();
        dos.writeBoolean(true);
        dos.flush();
        dos.close();
    }

    /**
     *  将文件中存储的基本类型变量和字符串读取到内存中，保存在变量中。
     *  注意点： 读取不同类型的数据的顺序要与当初写入文件时，保存的数据的顺序一致！
     */
    @Test
    public void test4() throws IOException {
        DataInputStream dis = new DataInputStream(new FileInputStream(getPath("hello6.txt")));
        String name = dis.readUTF();
        int age = dis.readInt();
        boolean isMale = dis.readBoolean();
        System.out.println(name + age + isMale);
    }
}