IO流

IO简介

In/Out: 相对于程序而言的输入(读取)和输出(写出)的过程。

即: 通过java程序到磁盘读取数据的过程, 我们称为In的过程, 也就是读取(输入)

将java程序中的数据写入磁盘的过程, 我们称为Out的过程, 也就是写出(输出)

在Java中，根据处理的数据单位不同，分为字节流和字符流。

字节流: 一个字节(byte)一个字节的去读取, 或者写出

字符流: 一个字符一个字符的去读取, 或者写出

JDK核心类库中提供了IO流相关的类, 这些类都在<java.io>包下

流的概念

程序中数据的读取和写入, 可以想象成水流在管道中流动。

• 流只能单方向流动
• 输入流用来读取in
• 输出流用来写出Out
• 数据只能从头到尾顺序的读取一次或写出一次

节点流和处理流

按照流是否直接与特定的地方(如磁盘,内存,设备等)相连,分为节点流和处理流两类

节点流

可以从或向一个特定的地方(节点)读写数据

处理流

是对一个已存在的流的连接和封装,通过所封装的流的功能调用实现数据读写

处理流特点

处理流的构造方法总是要带一个其他的流对象做参数,一个流对象经过其他流的多次包装,成为流的链接.

通常节点流也被称之为低级流.处理流也被称之为高级流或者过滤流

不能独立存在, 必须要连接低级流

节点流

OutputStream抽象类

Output输出 Stream字节流

此抽象类是表示输出字节流的所有类的超类。输出流接受输出字节并将这些字节发送到某个接收器。

FileOutputStream文件输出流

直接插在文件上，直接写出文件数据

创建对象：

FileOutputStream(String name) 
•     创建一个向具有指定名称的文件中写入数据的输出文件流。
FileOutputStream(File file) 
•     创建一个向指定 File 对象表示的文件中写入数据的文件输出流。
FileOutputStream(File file, boolean append) –追加
•     创建一个向指定 File 对象表示的文件中写入数据的文件输出流。

注意: 以上构造方法中, 如果参数指向的文件以及父目录都不存在, 将会抛出FileNotFoundException异常!

如果参数指向的文件不存在, 但文件的所在目录存在, 将不会抛异常, 程序会自动创建该文件!

FileOutputStream代码案例

package io;
​
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
/**
 * FOS FileOutputStream 文件输出流
 * 对File文件进行写出Output,使用的方式是Stream字节流
 */
public class FOSDemo {
    public static void main(String[] args) throws IOException {
        //1.创建FileOutputStream输出流,将数据输出到./test.txt文件中
        //File file = new File("./test.txt");
        //FileOutputStream fos = new FileOutputStream(file);
        //可以直接将文件的相对路径当做参数传递给流的构造方法
        //true如果不写,则默认是覆盖模式,每次写入内容,都会覆盖原有内容
        //如果写true,就是追加模式,不会覆盖原有内容
        FileOutputStream fos = new FileOutputStream("./test.txt",true);
        //2.开始向test.txt
        //向文件写出一个字节 参数单位是int
        //一个整数4个字节 传的是给定的int值的最后一个字节
        //00000000 00000000 00000000 00000001
        fos.write(1);//00000001
        fos.write(97);
        fos.write(98);
        fos.write(99);
        fos.write(13);//回车
        fos.write(10);//换行
        //输出byte数组 \r\n 是回车换行
        fos.write("Hello EveryBody\r\n".getBytes());
        //输出byte数组的一部分,输出BCD,1表示ABCDE中的下标1处的元素(B),3表示输出后面的3个字节
        fos.write("ABCDE".getBytes(),1,3);
        System.out.println("输出完成");
        //3.关闭流(释放资源)
        fos.close();
    }
}

InputStream抽象类

此抽象类是表示字节输入流的所有类的超类/抽象类。

FileInputStream子类

直接插在文件上，直接读取文件数据。

创建对象

FileInputStream(File file)

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的 File 对象 file 指定。

FileInputStream(String pathname)

通过打开一个到实际文件的连接来创建一个 FileInputStream，该文件通过文件系统中的路径名 name 指定。

FileInputStream代码案例

package io;
​
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
​
/**
 * FIS FileInputStream 文件字节输入流
 */
public class FISDemo {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("./test.txt");
        //使用read方法每次读取文件中的一个字节
        //System.out.println((char)fis.read());
        //....
        //read方法读取不到内容时,会返回-1
        //System.out.println(fis.read());
        //System.out.println(fis.read());
        //while一般用于循环次数不确定  for一般用于利用循环次数
        int data;
        //循环条件是判断读取的字节是否是-1,并且把读取到的字节整数赋值给data,便于输出
        while ((data = fis.read())!=-1){//不等于-1说明能读到东西
            System.out.print((char)data);
        }
        //关闭流
        fis.close();
    }
}

复制文件

复制文件代码案例

package io;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
​
/**
 * 实现文件复制
 */
public class CopyDemo {
    public static void main(String[] args) throws IOException {
        //创建一个输入流,读取原文件
        FileInputStream fis = new FileInputStream("./ATM.jpeg");
        //创建一个输出流,将读取的原文件内容写出到目标文件中
        FileOutputStream fos = new FileOutputStream("./ATMCopy.jpeg");
        int d;//记录每次读取到的字节
        long start = System.currentTimeMillis();
        while ((d = fis.read())!=-1){//每次循环读取一个字节
            //每次循环也将读取到的字节写入到复制文件中
            fos.write(d);
        }
        long end = System.currentTimeMillis();
        System.out.println("复制完毕!共耗时:"+(end-start)+"ms");
        //关闭流资源
        fis.close();
        fos.close();
    }
}

快读写优化代码案例

package io;
​
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
​
/**
 * 提高每次读取数据量减少实际读写的次数,可以提高效率
 * 一组字节一组字节的读写:块读写形式
 */
public class CopyDemo2 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("./aaa.jpg");
        FileOutputStream fos = new FileOutputStream("./ccc.jpg");
        /*
         * 1.简单介绍实现思路
         * int read(byte[] data) 一次性读取给定的字节数组data总长度的字节量,
         * 返回的是实际读取到的字节量.如果返回的是-1时,表示读取到了末尾
         * 2.假定该文件就只有7个字节,然后四个字节一读取
         * aaa.jpg文件数据:
         * 10101010 10001101 10101000 00010010 10010110 10010101 01010101
         * byte[] data = new byte[4];
         * int len;该变量返回读取的字节数
         * 3.第一次调用方法读取4个字节
         * int len = read(data);
         * aaa.jpg文件数据:
         * 10101010 10001101 10101000 00010010 10010110 10010101 01010101
         * ^^^^^^^^ ^^^^^^^^ ^^^^^^^^ ^^^^^^^^
         * data:[10101010,10001101,10101000,00010010]
         * len:4 表示实际读取到了4个字节
         * 4:第二次调用方法读取4个字节,只剩三个字节
         * int len = read(data);
         * aaa.jpg文件数据:
         * 10101010 10001101 10101000 00010010 10010110 10010101 01010101
         *                                     ^^^^^^^^ ^^^^^^^^ ^^^^^^^^
         * data:[10010110,10010101,01010101,00010010]
         *      |----本次读到的新数据--------||-旧数据--|
         * len:3 表示实际读取到了3个字节
         * 5:第三次调用方法读取4个字节,但是已经没有内容可以读取了
         * data:[10010110,10010101,01010101,00010010]
         * len:-1 表示文件末尾了
         */
        /* byte[] data = new byte[10];
         * 1KB=1024byte
         * 1MB=1024KB
         * 1GB=1024MB
         * int t = 864000000;
         * int t = 60*60*24*1000
         */
        byte[] data = new byte[1024*10];//10kb
        int len;//记录每次读取到的字节
        long start = System.currentTimeMillis();
        while ((len = fis.read(data))!=-1){//每次循环读取一个字节
            //从下标0处开始写入,写入后面len个的字节
            fos.write(data,0,len);
        }
        long end = System.currentTimeMillis();
        System.out.println("复制完毕!共耗时:"+(end-start)+"ms");
        fis.close();
        fos.close();
    }
}

写入字符串

package io;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
​
/**
 * @author 老安
 * @data 2022/6/14 19:44
 * 向文件中写出字符串
 */
public class WriteStringDemo {
    public static void main(String[] args) throws IOException {
        //向文件demo.txt写出文本数据
        FileOutputStream fos = new FileOutputStream("./demo.txt");
        String line = "smell smelly,taste tasty";//闻着臭吃着香
        //将字符串转换为字节数组,通常要指定转换的编码UTF-8
        //java.nio.charset.StandardCharsets;
        //StandardCharsets.UTF_8 表示UTF-8编码
        byte[] data = line.getBytes(StandardCharsets.UTF_8);
        fos.write(data);
        fos.write("闻着臭,吃着香".getBytes(StandardCharsets.UTF_8));
        fos.close();
    }
}

简易笔记本

package io;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
​
/**
 * @author 老安
 * @data 2022/6/14 20:26
 * 实现简易记事本工具
 * 程序启动后,要求将控制台输入的每一行字符串,写入到文件note.txt
 * 当在控制台输入exit时,程序退出
 */
public class TestNotes {
    public static void main(String[] args) throws IOException {
        System.out.println("请开始输入内容,单独输入exit退出记事本!");
        //接收控制台输入的内容的扫描器
        Scanner scanner = new Scanner(System.in);
        //使用文件输出流绑定note.txt文件
        FileOutputStream fos = new FileOutputStream("./note.txt");
        while (true){//因为不知道什么时候写完,所以定义一个死循环
            //接收在控制台输入的一行字符串
            String line = scanner.nextLine();
            //如果line是exit时,退出循环
            //由于line是用户输入的,现在不好控制,所以可能会输入一个空值,
            //空值调用方法,一定会发生空指针异常
            //equalsIgnoreCase String也提供了一个比较字符串向同时,忽略大小写差异
            if ("exit".equalsIgnoreCase(line)){
                break;//break跳出当前循环,直接执行循环之后的内容
            }
            fos.write(line.getBytes(StandardCharsets.UTF_8));
        }
        //执行完就关闭流
        fos.close();
    }
}

文件追加模式案例

package io;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
​
/**
 * @author 老安
 * @data 2022/6/14 20:26
 * 实现简易记事本工具
 * 程序启动后,要求将控制台输入的每一行字符串,写入到文件note.txt
 * 当在控制台输入exit时,程序退出
 */
public class TestNotes {
    public static void main(String[] args) throws IOException {
        System.out.println("请开始输入内容,单独输入exit退出记事本!");
        //接收控制台输入的内容的扫描器
        Scanner scanner = new Scanner(System.in);
        //使用文件输出流绑定note.txt文件
        FileOutputStream fos = new FileOutputStream("./note.txt",true);
        while (true){//因为不知道什么时候写完,所以定义一个死循环
            //接收在控制台输入的一行字符串
            String line = scanner.nextLine();
            //如果line是exit时,退出循环
            //由于line是用户输入的,现在不好控制,所以可能会输入一个空值,
            //空值调用方法,一定会发生空指针异常
            //equalsIgnoreCase String也提供了一个比较字符串向同时,忽略大小写差异
            if ("exit".equalsIgnoreCase(line)){
                break;//break跳出当前循环,直接执行循环之后的内容
            }
            fos.write(line.getBytes(StandardCharsets.UTF_8));
        }
        //执行完就关闭流
        fos.close();
    }
}

处理流

缓冲流

• BufferedOutputStream缓冲输出流
• BufferedInputStream 缓冲输入流

复制文件代码案例

package io;
​
import java.io.*;
​
/**
 * @author 老安
 * @data 2022/6/14 21:31
 * 使用缓冲流实现高效率文件复制
 */
public class CopyDemo3 {
    public static void main(String[] args) throws IOException {
        FileInputStream fis = new FileInputStream("./aaa.jpg");
        BufferedInputStream bis = new BufferedInputStream(fis);
        FileOutputStream fos = new FileOutputStream("./ddd.jpg");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        //此案例还是用单字节读取,之前读取很慢,现在用高级流测试
        int d;
        long start = System.currentTimeMillis();
        while ((d = bis.read())!=-1){//使用缓冲流读取字节
            bos.write(d);//使用缓冲流写入字节
        }
        long end = System.currentTimeMillis();
        System.out.println("耗时:"+(end-start)+"ms");
        //关闭流 如果使用了高级流,就只需要关闭高级流就可以了,会自动关闭所连接的低级流
        bis.close();
        bos.close();
    }
}

flush代码案例

package io;
​
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
​
/**
 * @author 老安
 * @data 2022/6/14 21:55
 * 缓冲流写出数据的缓冲区问题
 */
public class BOS_flushDemo {
    public static void main(String[] args) throws IOException {
        FileOutputStream fos = new FileOutputStream("./bos.txt");
        BufferedOutputStream bos = new BufferedOutputStream(fos);
        bos.write("你是我的眼~~~~~~".getBytes(StandardCharsets.UTF_8));
        //如果不调用close方法,执行完毕,bos.txt没有内容
        //bos.flush();
        bos.close();
    }
}

对象流

Person代码

package io;
​
import java.io.Serializable;
import java.util.Arrays;
​
/**
 * @author 老安
 * @data 2022/6/16 19:50
 * 使用当前类测试对象流的序列化和反序列化操作
 * 对象序列化:将一个java对象按照其结构转换为一组字节的过程
 * 序列化一个对象时,底层会为当前的Person生成一个版本号serialVersionUID
 * 在读取对象,会先比对被序列化对象的版本号,和还原的对象类型的版本是否一致,
 * 不一致,会抛出异常
 * 如何解决?
 * 开启兼容模式:自己指定一个版本号
 *  static final long serialVersionUID = 1L;
 */
public class Person implements Serializable {
    //控制死当前类的版本号是1,将来如何改当前类的内容,版本号都不会发生改变
    static final long serialVersionUID = 1L;
    private String name;//姓名
    //transient 当一个属性被transient修饰时,序列化时,就会忽略这个属性的值
    //transient 转瞬即逝的,短暂的
    private transient int age;//年龄
    private String gender;//性别
    private transient String[] otherInfo;//其他信息
    //private int salary;//薪资
    //全参构造
    //alt+insert/右键 Generate-->Constructor crtl+A全选属性
    public Person(String name, int age, String gender, String[] otherInfo) {
        this.name = name;
        this.age = age;
        this.gender = gender;
        this.otherInfo = otherInfo;
    }
    //get和set方法
    //alt+insert/右键 Generate-->getter and setter crtl+A全选属性
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String[] getOtherInfo() {
        return otherInfo;
    }
    public void setOtherInfo(String[] otherInfo) {
        this.otherInfo = otherInfo;
    }
    //toString
    //alt+insert/右键 Generate-->toString()
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", otherInfo=" + Arrays.toString(otherInfo) +
                '}';
    }
}

OOSDemo案例

package io;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
​
/**
 * @author 老安
 * @data 2022/6/16 20:05
 * 对象流
 * java.io.ObjectOutputStream 对象输出流 序列化流
 * java.io.ObjectInputStream 对象输入流 反序列化流
 * 对象流是一对高级流,在流链接中完成对象与字节的转换,
 * 学会了使用这组流,就可以轻松读取任何的java对象
 */
public class OOSDemo {
    public static void main(String[] args) throws IOException {
        String name = "康荐文";
        int age = 18;
        String gender = "男";
        String[] otherInfo = {"单身的","帅气的","网络鉴黄师","多金"};
        Person p = new Person(name, age, gender, otherInfo);
        System.out.println(p);
        //将p对象序列化到person.obj文件中
        //创建一个文件输出流,绑定文件
        FileOutputStream fos = new FileOutputStream("./person.obj");
        //创建一个对象输出流,连接fos低级流
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        /*
        * writeObject(Object obj)
        * 对象输出流独有的方法:该方法会将对象转换为字节,并将字节通过
        * 所连接的流写出
        * */
        oos.writeObject(p);
        System.out.println("写出完毕!");
        //关闭流资源
        oos.close();
        /*
        * java.io.NotSerializableException 执行这个程序时,出现此异常,
        * 一定要检查序列化的类,是否实现了一个Serializable接口
        * */
    }
}

OISDemo案例

package io;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
​
/**
 * @author 老安
 * @data 2022/6/16 20:27
 * 使用对象输入流进行对象的反序列化
 */
public class OISDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        FileInputStream fis = new FileInputStream("./person.obj");
        //创建一个对象输入流,连接fis低级流
        ObjectInputStream ois = new ObjectInputStream(fis);
        /*
        * Object readObject() 可以将文件中的字节读取出来,并且转换为java对象
        * 这个方法的返回值是Object,一般都需要强转为实际类型
        * */
        Person p = (Person) ois.readObject();
        System.out.println(p);
        ois.close();
    }
}

字节流和字符流

在Java中，根据处理的数据单位不同，分为字节流和字符流。

字节流: 一个字节(byte)一个字节的去读取, 或者写出

字符流: 一个字符一个字符的去读取, 或者写出

字节流

字节流(stream)：针对二进制文件(文本,图片,音频,视频…等)

InputStream(包含input都是输入流)

• FileInputStream
• BufferedInputStream
• ObjectInputStream

OutputStream(包含output都是输出流)

• FileOutputStream
• BufferedOutputStream
• ObjectOutputStream

字符流

字符流(Reader,Writer)：针对文本文件，读写容易发生乱码现象，在读写时最好指定编码集为utf-8

Reader(Reader结尾的都是字符输入流)

• FileReader
• BufferedReader
• InputStreamReader

Writer(Writer结尾的都是字符输出流)

• FileWriter
• BufferedWriter
• OutputStreamWriter
• PrintWriter/PrintStream

转换字符流

OutputStreamWriter

代码案例

package io;
​
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
​
/**
 * @author 老安
 * @data 2022/6/16 21:22
 * java IO 将流按照读写的单位分为字节流和字符流
 * java.io.InputStream和OutputStream 是所有字节输入流和输出流的超类,
 * 读写的最小单位是字节
 * 而java.io.Reader和Writer 是所有字符输入流和输出流的超类,
 * 读写的最小单位是字符
 * 转换流:是一对常用字符流实现类:(写代码不常用,但是流链接很重要)
 * java.io.InputStreamReader
 * java.io.OutputStreamWriter
 * 作用:
 * 1:在流链接中衔接其他的高级字符流和下面的字节流(这也是转换流名字的由来)
 * 2:负责将字符与对应的字节按照指定的字符集自动转换方便读写操作
 */
public class OSWDemo {
    public static void main(String[] args) throws IOException {
        //向osw.txt写入文本数据
        //创建一个低级的字节流
        FileOutputStream fos = new FileOutputStream("./osw.txt");
        //String line = "super idol的笑容都没你的甜~~~";
        //fos.write(line.getBytes(StandardCharsets.UTF_8));
        //创建一个字符流(转换流),连接低级的字节流fos
        //通常都需要指定字符集编码
        OutputStreamWriter osw = new OutputStreamWriter(fos,StandardCharsets.UTF_8);
        osw.write("super idol的笑容都没你的甜~~~");
        osw.write("八月正午的阳光都没你耀眼");
        osw.write("天天向上");
        osw.close();
    }
}

InputStreamReader

代码案例

package io;
​
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStreamReader;
​
/**
 * @author 老安
 * @data 2022/6/16 21:43
 * 使用转换流测试读取文本数据
 */
public class ISRDemo {
    public static void main(String[] args) throws IOException {
        //将osw.txt中所有内容读取出来,并输出到控制台
        FileInputStream fis = new FileInputStream("./osw.txt");
        //创建一个字符转换流,连接fis低级输入流
        InputStreamReader isr = new InputStreamReader(fis);
        //读取一个字符,返回的int值内容本质上是一个char
        //但是如果返回的是-1,表示读取到了末尾
        //int d = isr.read();
        //System.out.println((char)d);
        int d;
        while ((d = isr.read())!=-1){
            System.out.print((char)d);
        }
        isr.close();
    }
}

缓冲字符流

PrintWriter

代码案例

package io;
​
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
​
/**
 * 缓冲字符流
 * java.io.BufferedWriter和BufferedReader
 * 缓冲字符流内部维护了一个数组,可以块读写文本数据进行读写性能的提升
 *
 * java.io.PrintWriter 具有自动行刷新功能的缓冲字符输出流,内部总是连接着BufferedWriter
 * 实际开发中,缓冲输出字符流我们就用这个PW
 * 特点:
 * 1:可以按行写字符串
 * 2:可以自动行刷新
 * 3:可以提高读写字符的效率
 */
public class PWDemo {
    public static void main(String[] args) throws FileNotFoundException, UnsupportedEncodingException {
        //向文件pw.txt中写入文本数据
        //此处可以指定编码,但是StandardCharset还没有发现,所以需要字符串指定编码
        PrintWriter pw = new PrintWriter("./pw.txt", "UTF-8");
        //print 不带换行 println 自带换行
        pw.println("该配合你演出的我视而不见");
        pw.println("阿巴阿巴阿巴阿巴阿巴阿巴");
        System.out.println("写出完毕");
        pw.close();
    }
}

代码案例2

package io;
​
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.Scanner;
​
public class PWDemo2 {
    public static void main(String[] args) throws FileNotFoundException {
        //文件字节输出流(是一个低级流),向文件中写出数据
        FileOutputStream fos = new FileOutputStream("pw2.txt",true);
        //转换输出流(是一个高级流),1:衔接字符与字节 2:将写出的字符转换字节
        OutputStreamWriter osw = new OutputStreamWriter(fos, StandardCharsets.UTF_8);
        //缓冲输出字符流(是一个高级流) 块写文本数据加速
        BufferedWriter bw = new BufferedWriter(osw);
        //具有自动行刷新功能的缓冲字符输出流
        //当值设置为true时,表示打开了自动行刷新,每次调用println方法时,会自动调用flush一次
        PrintWriter pw = new PrintWriter(bw,true);
        Scanner scanner = new Scanner(System.in);
        while (true){
            String line = scanner.nextLine();
            if ("exit".equalsIgnoreCase(line)){
                break;
            }
            pw.println(line);
        }
        pw.close();
    }
}