JavaSE进阶26 - IO流概述、字节流、字符流、转换流、缓冲流

IO概述

• 什么是IO？
  • 通过IO可以完成对硬盘文件的读和写。
  • I : Input
  • O : Output
    
• IO流的分类？
  • 有多种分类方式：
    • 一种方式是按照流的方向进行分类：
      • 以内存作为参照物，
        • 往内存中去，叫做输入(input)。或者叫做读(Read)。
        • 从内存中出来，叫做输出(Output)。或者叫做写(Write)。
    • 另一种方式是按照数据方式不同进行分类：
      • 有的流是按照字节的方式读取数据，一次读取1个字节byte，等同于一次读取8个二进制位。这种流是万能的，什么类型的文件都可以读取。包括：文本文件，图片，声音文件，视频等。
        • 假设文件file1.txt，采用字节流的话是这样读的：
          • a中国bc张三fe
          • 第一次读：一个字节，正好读到’a’（注意：'a’在java中是2个字节，但在windows操作系统中是1个字节）
          • 第二次读：一个字节，正好读到’中’字符的一半（注意：‘中’在java中是2个字节，在windows操作系统中也是2个字节）
          • 第三次读：一个字节，正好读到’中’字符的另外一半。
      • 有的流是按照字符的方式读取数据的，一次读取一个字符，这种流是为了方便读取普通文本文件而存在的，这种流不能读取：图片、声音、视频等文件。只能读取纯文本文件，连word文件都无法读取。
        • 文件file1.txt，采用字符流的话是这样读的：
          • a中国bc张三fe
          • 第一次读：‘a’字符（‘a’字符在windows系统中占用1个字节。）
          • 第二次读：‘中’字符（‘中’字符在windows系统中占用2个字节。）
    • 综述所述，流的分类：
      • 输入流、输出流
      • 字节流、字符流
• Java中的IO流都已经写好了，我们程序员不需要关心，我们最主要该是掌握在java中已经提供了哪些流，每个流的特点是什么，每个流对象上的常用方法有哪些？？
  • java中所有的流都是在：java.io.*下
  • java中主要还是研究：
    • 怎么new流对象？
    • 调用流对象的哪个方法是读，哪个方法是写。
• Java IO流这块有四大家族：
  • java.io.InputStream 字节输入流
  • java.io.OutputStream 字节输出流
  • java.io.Reader 字符输入流
  • java.io.Writer 字符输出流
  • 四大家族的首领都是抽象类。(abstract class)
  • 所有的流都实现了：
    • java.io.Closeable接口，都是可关闭的，都有close()方法。
    • 流毕竟是一个管道，这个是内存和硬盘之间的通道，用完之后一定要关闭，不然会耗费（占用）很多资源。养成好习惯，用完流一定要关闭。
  • 所有的输出流都实现了：
    • java.io.Flushable接口，都是可刷新的，都有flush()方法。养成一个好习惯，输出流在最终输出之后，一定要记得flush()刷新一下。这个刷新表示将通道/管道当中剩余未输出的数据强行输出完（清空管道！）刷新的作用就是清空管道。
    • 注意：如果没有flush()可能会导致丢失数据。
  • 注意：在java中只要“类名”以Stream结尾的都是字节流。以“Reader/Writer”结尾的都是字符流。
• java.io包下需要掌握的流有16个：
  • 文件专属：
    • java.io.FileInputStream（掌握）
    • java.io.FileOutputStream（掌握）
    • java.io.FileReader
    • java.io.FileWriter
  • 转换流：（将字节流转换成字符流）
    • java.io.InputStreamReader
    • java.io.OutputStreamWriter
  • 缓冲流专属：
    • java.io.BufferedReader
    • java.io.BufferedWriter
    • java.io.BufferedInputStream
    • java.io.BufferedOutputStream
  • 数据流专属：
    • java.io.DataInputStream
    • java.io.DataOutputStream
  • 标准输出流：
    • java.io.PrintWriter
    • java.io.PrintStream（掌握）
  • 对象专属流：
    • java.io.ObjectInputStream（掌握）
    • java.io.ObjectOutputStream（掌握）

FileInputStream的使用

package com.bjpowernode.javase.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
java.io.FileInputStream:
    1、文件字节输入流，万能的，任何类型的文件都可以采用这个流来读。
    2、字节的方式，完成输入的操作，完成读的操作（硬盘-->内存)
    3、
 */
public class FileInputStreamTest01 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream fis = null;
        // 创建文件字节流输入对象
        try {
    
    
            //FileInputStream fis = new FileInputStream("D:\\Java\\Pros\\IdeaPros\\advanced_21\\test.txt");
            // 写成"/"这样也是可以的
           fis = new FileInputStream("D:/Java/Pros/IdeaPros/advanced_21/test.txt");

           // 开始读取
            int readData = fis.read(); // 这个方法返回的是“字节”本身
            System.out.println(readData); // 97 <-- a

            readData = fis.read();
            System.out.println(readData); // 98 <-- b

            readData = fis.read();
            System.out.println(readData); // 99 <-- c

            readData = fis.read();
            System.out.println(readData); // 100 <-- d

            readData = fis.read();
            System.out.println(readData); // 101 <-- e

            readData = fis.read();
            System.out.println(readData); // 102 <-- f

            readData = fis.read();
            System.out.println(readData); // -1 // 读取不到任何数据

        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            // 在finally语句块中确保流一定关闭。
            if(fis != null){
    
     // 避免空指针异常
                // 关闭流的前提是：流不是空。流是null的时候没必要关闭。
                try {
    
    
                    fis.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.bjpowernode.javase.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
对第一个程序进行改进。循环方式。

分析这个程序的缺点：
    一次读取一个字节byte，这样内存和硬盘交互太频繁，基本上时间/资源都耗费
    在交互上面了。能不能一次读取多个字节呢？可以。
 */
public class FileInputStreamTest02 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream fis = null;

        try {
    
    
            fis = new FileInputStream("D:/Java/Pros/IdeaPros/advanced_21/test.txt");
            /*while(true){
                int readData = fis.read();
                if(readData == -1){
                    break;
                }
                System.out.println(readData);
            }*/

            // 改造while循环
            int readData = 0;
            while((readData = fis.read()) != -1){
    
    
                System.out.println(readData);
            }

        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            if(fis != null){
    
    
                try {
    
    
                    fis.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.bjpowernode.javase.io;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
int read(byte[] b)
    一次最多读取 b.length 个字节
    减少硬盘和内存的交互，提高程序的执行效率。
    往byte[]数组当中读。
 */
public class FileInputStreamTest03 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream fis = null;
        try {
    
    
            // 相对路径
            // IDEA默认当前路径：工程Project（区分模块io）的根就是IDEA的默认当前路径
            //fis = new FileInputStream("test.txt");
            //fis = new FileInputStream("io/test2.txt");
            //fis = new FileInputStream("io/src/test3.txt");
            fis = new FileInputStream("io/src/com/bjpowernode/javase/io/test4.txt");

            // 开始读，采用byte数组，一次读取多个字节。最多读取“数组.length”个字节。
            byte[] bytes = new byte[4]; // 准备一个4个长度的数组，一次最多读取4个字节。
            // 这个方法的返回值是：读取的数量，不是字节本身。
            int readCount = fis.read(bytes); // 第一次读到了4个字节
            System.out.println(readCount); // 4
            // 将字节数组全部转换成字符串
            // System.out.println(new String(bytes)); // abcd
            // 不应该全部都转换，应该是读取了多少个字节，转换多少个。
            System.out.println(new String(bytes, 0, readCount)); // abcd

            readCount = fis.read(bytes); // 第二次只能读取到2个字节
            System.out.println(readCount); // 2
            //System.out.println(new String(bytes)); // efcd
            System.out.println(new String(bytes, 0, readCount)); // ef

            readCount = fis.read(bytes); // 1个字节都没有读取到，返回-1
            System.out.println(readCount); // -1
            //System.out.println(new String(bytes)); // efcd
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            if(fis != null){
    
    
                try {
    
    
                    fis.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.bjpowernode.javase.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

// 最终版，需要掌握
public class FileInputStreamTest04 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream fis = null;

        try {
    
    
            fis = new FileInputStream("io/src/com/bjpowernode/javase/io/temp.txt");
            // 准备一个byte数组
            byte[] bytes = new byte[4];
            /*while(true){
                int readCount = fis.read(bytes);
                if(readCount == -1) break;
                // 把byte数组转换成字符串，读取多少转换多少个
                System.out.print(new String(bytes, 0, readCount));
            }*/
            int readCount = 0;
            while((readCount = fis.read(bytes)) != -1){
    
    
                System.out.print(new String(bytes, 0, readCount));
            }
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally{
    
    
            if(fis != null){
    
    
                try {
    
    
                    fis.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

package com.bjpowernode.javase.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

/*
FileInputStream类的其他常用方法：
    int available(): 返回流当中剩余的没有读到的字节数量。
    long skip(long n): 跳过几个字节不读。
 */
public class FileInputStreamTest05 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream fis = null;
        try {
    
    
            fis = new FileInputStream("io/src/com/bjpowernode/javase/io/test4.txt"); // 5

            System.out.println("总字节数量：" + fis.available()); // 6
            /*// 读1个字节
            int readByte = fis.read();
            // 还剩下多少可以读的字节数量：5
            System.out.println("剩下多少个字节没有读：" + fis.available());*/

            /*// 这个方法有什么用？
            byte[] bytes = new byte[fis.available()]; // 这种方式不太适合太大的文件，因为byte[]数组不能太大。
            // 不需要循环了。
            // 直接读一次就行了。
            int readCount = fis.read(bytes);
            System.out.println(new String(bytes));// abcdef*/


            // skip,跳过几个字节不读取，这个方法也可能以后会用!
            fis.skip(3);
            System.out.println(fis.read()); // 100 <-- e
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally{
    
    
            if(fis != null){
    
    
                try {
    
    
                    fis.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

FileOutputStream使用

package com.bjpowernode.javase.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
    文件字节输出流，负责写。
    从内存到硬盘。
 */
public class FileOutputStreamTest01 {
    
    
        public static void main(String[] args) {
    
    
            FileOutputStream fos = null;
            try {
    
    
                // writeTest.txt文件不存在的时候会自动新建
                // 这种方式谨慎使用，这种方式会先将原先文件清空，然后重新写入。
                // fos = new FileOutputStream("writeTest.txt");


                // 以追加的方式在文件末尾写入。不会清空原文件内容。
                fos = new FileOutputStream("io/src/com/bjpowernode/javase/io/temp.txt", true);
                // 开始写
                byte[] bytes = {
    
    97, 98, 99, 100};
                // 将byte数组全部写出！
                fos.write(bytes);
                // 将byte数组的一部分写出!
                fos.write(bytes, 0, 2);

                String s = "我是一个中国人， 我骄傲！！！！！！";
                // 将字符串转换成byte数组
                byte[] bs = s.getBytes();
                fos.write(bs);

                // 写完之后，一定记得要刷新!!!!!!!!!!!!!!!!!!!
                fos.flush();
            } catch (FileNotFoundException e) {
    
    
                e.printStackTrace();
            } catch (IOException e) {
    
    
                e.printStackTrace();
            } finally {
    
    
                if(fos != null){
    
    
                    try {
    
    
                        fos.close();
                    } catch (IOException e) {
    
    
                        e.printStackTrace();
                    }
                }
            }
        }
}

文件复制

文件的复制原理

代码

package com.bjpowernode.javase.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

/*
注意目前是拷贝文件，不是拷贝文件夹
使用FileInputStream + FileOutputStream完成文件的拷贝
拷贝的过程应该是一边读，一边写。
使用以上的字节流拷贝文件的时候，文件类型随意，万能的。什么样的文件都能拷贝。
 */
public class CopyTest01 {
    
    
    public static void main(String[] args) {
    
    
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
    
    
            // 创建一个输入流对象
            fis = new FileInputStream("D:\\Java\\Pros\\IdeaPros\\advanced_21\\videoRead\\秒剪辑.mp4");
            // 创建一个输出流对象
            // 这里不加上文件名Copy秒剪辑.mp4，会报错，“拒绝访问”，因为FileOutputStream流访问的是文件，不是文件夹。
            fos = new FileOutputStream("D:\\Java\\Pros\\IdeaPros\\advanced_21\\videoWrite\\Copy秒剪辑.mp4");

            // 最核心的：一边读，一边写
            // 8bit(位) = 1Byte(字节)
            // 1024Byte(字节) = 1KB
            // 1024KB = 1MB
            byte[] bytes = new byte[1024 * 1024]; // 1MB（一次最多拷贝1MB）
            int readCount = 0;
            while((readCount = fis.read(bytes)) != -1){
    
    
                fos.write(bytes, 0, readCount);
            }

            // 刷新，输出流最后要刷新
            fos.flush();
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally{
    
    
            // 分开try，不要一起try
            // 一起try，其中一个出现异常，可能会影响另一个流的关闭。
            if(fos != null){
    
    
                try {
    
    
                    fos.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
            if(fis != null){
    
    
                try {
    
    
                    fis.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

FileReader

package com.bjpowernode.javase.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

/*
FileReader:
    文件字符输入流，只能读取普通文本。
    读取文本内容时，比较方便，快捷。
 */
public class FileReaderTest {
    
    
    public static void main(String[] args) {
    
    
        FileReader reader = null;

        try {
    
    
            // 创建文件字符输入流
            reader = new FileReader("test.txt");

            // 准备一个char数组
            char[] chars = new char[4];
            // 往char数组中读
            reader.read(chars); // 按照字符的方式读取：第一次e，第二次f，第三次中，第四次国
            for(char c : chars){
    
    
                System.out.println(c);
            }

            /*// 开始读
            char[] chars = new char[4]; // 一次读取4个字符
            int readCount = 0;
            while((readCount = reader.read(chars)) != -1){
                System.out.print(new String(chars, 0, readCount));
            }*/
        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            if(reader != null){
    
    
                try {
    
    
                    reader.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

FileWriter

package com.bjpowernode.javase.io;

import java.io.FileWriter;
import java.io.IOException;

/*
FileWriter:
     文件字符输出流。写。
     只能输出普通文本
 */
public class FileWriterTest {
    
    
    public static void main(String[] args) {
    
    
        FileWriter fw = null;

        try {
    
    
            // 创建文件字符输出流对象
            // fw = new FileWriter("file");
            fw = new FileWriter("file", true);

            // 开始写。
            char[] chars = {
    
    '我', '是', '中', '国', '人'};
            fw.write(chars);
            fw.write(chars, 2, 3);
            fw.write("我是一名java软件工程师");
            fw.write("\n");
            fw.write("helloworld!");

            // 刷新
            fw.flush();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally{
    
    
            if (fw != null){
    
    
                try {
    
    
                    fw.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }

    }
}

复制普通文本文件

package com.bjpowernode.javase.io;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

/*
使用FileReader FileWriter进行拷贝的话，只能拷贝“普通文本”文件。
注意：java文件也是普通文本文件，能用记事本编辑的都是普通文本文件，不一定是txt。
 */
public class CopyTest02 {
    
    
    public static void main(String[] args) {
    
    
        FileReader in = null;
        FileWriter out = null;

        try {
    
    
            // 读取
            in = new FileReader("io/src/com/bjpowernode/javase/io/CopyTest02.java");
            // 写入
            out = new FileWriter("CopyTest2.java");

            // 一边读一边写
            // 1char = 2Byte
            // 512char = 1024Byte = 1KB
            // 1024KB = 1MB
            char[] chars = new char[1024 * 512]; // 1MB
            int readCount = 0;
            while((readCount = in.read(chars)) != -1){
    
    
                // 读多少，写多少
                out.write(chars, 0, readCount);
            }

            // 刷新
            out.flush();

        } catch (FileNotFoundException e) {
    
    
            e.printStackTrace();
        } catch (IOException e) {
    
    
            e.printStackTrace();
        } finally {
    
    
            if(in != null){
    
    
                try {
    
    
                    in.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
            if(out != null){
    
    
                try {
    
    
                    out.close();
                } catch (IOException e) {
    
    
                    e.printStackTrace();
                }
            }
        }
    }
}

BufferedReader

package com.bjpowernode.javase.io;

import java.io.BufferedReader;
import java.io.FileReader;

/**
 * BufferedReader:
 *      带有缓冲区的字符输入流
 *      使用这个流的时候不需要自定义char数组，或者说不需要自定义byte数组。自带缓冲。
 */
public class BufferedReaderTest01 {
    
    
    public static void main(String[] args) throws Exception{
    
    
        // BufferedReader构造方法的输入参数需要Reader类型的数据
        // 但Reader为抽象类，无法实例化，考虑子类
        // FileReader继承InputStreamReader，并继承于Reader，因此选择传入FileReader的实例
        FileReader reader = new FileReader("CopyTest2.java");
        // 当一个流的构造方法中需要一个流的时候，这个被传进来的流叫做：节点流。
        // 外部负责包装的这个流，叫做：包装流，还有一个名字叫做：处理流。
        // 像当前这个程序来说：FileReader就是一个节点流。BufferedReader就是包装流/处理流。
        BufferedReader br = new BufferedReader(reader);

        // 读一行
        /*String firstLine = br.readLine();
        System.out.println(firstLine);

        String secondLine = br.readLine();
        System.out.println(secondLine);

        String thirdLine = br.readLine();
        System.out.println(thirdLine);*/

        // br.readLine()读取一个文本行，但不带换行符。
        String s = null;
        while((s = br.readLine()) != null){
    
    
            System.out.println(s);
        }


        // 关闭流
        // 对于包装流来说，只需要关闭最外层流就行，里面的节点流会自动关闭。（可以看源代码）
        br.close();
    }
}

节点流和包装流

package com.bjpowernode.javase.io;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;

/**
 * InputStreamReader
 * 转换流
 */
public class BufferedReaderTest02 {
    
    
    public static void main(String[] args) throws Exception {
    
    
        /*
        // 字节流
        FileInputStream in = new FileInputStream("CopyTest2.java");

        // 通过转换流转换（InputStreamReader将字节流转换成字符流）
        // in是节点流，reader是包装流
        InputStreamReader reader = new InputStreamReader(in);

        // 这个构造方法只能传一个字符流。不能传字节流。
        // reader是节点流，br是包装流
        BufferedReader br = new BufferedReader(reader);
        */

        // 合并
        BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("CopyTest2.java")));

        String line = null;
        while((line = br.readLine()) != null){
    
    
            System.out.println(line);
        }

        // 关闭最外层流。
        br.close();
    }
}

BufferedWriter

package com.bjpowernode.javase.io;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

/*
BufferedWriter:
    带有缓冲的字符输出流
 */
public class BufferedWriterTest {
    
    
    public static void main(String[] args) throws Exception {
    
    

        // BufferedWriter out = new BufferedWriter(new FileWriter("copy");
        BufferedWriter out = new BufferedWriter(new FileWriter("copy", true));

        out.write("hello world!");
        out.write("\n");
        out.write("hello kitty!");

        // 刷新
        out.flush();
        // 关闭最外层流
        out.close();
    }
}