JavaSE笔记15.4-IO流-字节流

一. OutputStream

OutputStream类是所有字节输出流的父类，是一个抽象类，不能直接通过new进行实例化，可通过实例化子类创建对象。

1. OutputStream的常见子类

• ByteArrayOutputStream：字节数组输出流，用于向内存缓冲区的字节数组中写数据，缓冲区会随着数据的不断写入而自动增长
• FileOutputStream：文件字节输出流，用于将字节写入到指定的打开的文件中
• ObjectOutputStream ：对象输出流，它和ObjectInputStream一起对基本数据或者对象做持久存储
• PipedOutputStream：管道字节输出流，和PipedInputStream一起使用，能实现多线程间的管道通信
• BufferedOutputStream：缓冲字节输出流，为其他字节输出流提供写缓冲区
• DataOutputStream：数据输出流，用来装饰其他的输出流，用于操作基本数据类型
• PrintStream：字节打印流，用来装饰其他输出流，为其他输出流添加功能，方便的打印各种数据值

2. OutputStream的常用方法

//写入一个字符
//要写入的字节包含在给定整数值的8个低位中，24个高位被忽略
abstract void write(int b)throws IOException
//写入一个字节数组
void write(byte[] b)throws IOException
//写入一个字节数组的若干字节，off 指定字节数组中的起始下标，len 表示元素个数
void write(byte[] b,int off,int len)throws IOException

//为了提高效率，在写数据时，数据一般会先保存到内存缓冲区中，只有当缓冲区中的数据达到一定程度时，缓冲区中的数据才会被写入预期目的地
//使用 flush() 方法则可以强制将缓冲区中的数据写入预期目的地
void flush()throws IOException
//关闭输出流，并且在关闭之前会先将缓冲区中的数据刷新到预期目的地
void close()throws IOException

3. FileOutputStream

（1）概述

• FileOutputStream是文件字节输出流，用于将字节写入到指定的打开的文件中，FileOutputStream的创建不依赖于文件存在与否
• 文件字节输出流内部无缓冲区，不需要刷新动作

（2）构造方法

//在指定 File 对象的情况下构造一个 FileOutputStream 对象，file 表示要写入数据的 File 对象
FileOutputStream(File file)throws IOException
//在指定 File 对象的情况下构造一个 FileOutputStream 对象，如果 append 的值为 true，则将字节写入文件末尾，而不是写入文件开始处
FileOutputStream(File file,boolean append)throws IOException
//在指定文件名的情况下构造一个 FileOutputStream 对象，name 表示要写入字节的文件名，表示的是完整路径
FileOutputStream(String name)throws IOException
//在指定文件名的情况下构造一个 FileOutputStream 对象，如果 append 的值为 true，则将字节写入文件末尾，而不是写入文件开始处
FileOutputStream(String name,boolean append)throws IOException

FileOutputStream的创建不依赖于文件存在与否：

• 如果目标文件不存在，则会自动创建目标文件
• 如果目标文件已存在，默认情况会先清空文件中的数据，然后再写入数据；如果需要在原来的基础上追加数据，需要使用构造方法FileOutputStream(File,boolean)并将第2个参数设为true

（3）使用FileOutputStream的步骤

创建输出流对象–进行写操作–关闭输出流通道

（4）使用FileOutputStream的例子

import java.io.*;
public class FileOutputStreamDemo {
    public static void main(String[] args) {
        FileOutputStream fos=null;
        try{
            //1. 创建输出流对象，与目标文件相关联
            fos=new FileOutputStream("fos.txt",true);
            //2. 进行写操作，写入一个字节数组
            fos.write("abcde".getBytes());
            fos.write("ABCDE".getBytes());
            //文件字节输出流内部无缓冲区，不需要刷新动作
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            try {
                //3. 关闭资源
                if(fos!=null)
                    fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4. BufferedOutputStream

（1）概述

• BufferedOutputStream是缓冲字节输出流，它的作用是为其他字节输出流添加缓冲功能。可以先将一批数据写入缓冲区，当缓冲区满了以后，再将缓冲区的数据一次性写到字节输出流，可提高对数据的写效率
• BufferedOutputStream要结合流才可以使用

（2）构造方法

//创建一个BufferedOutputStream对象来修饰参数out指定的字节输出流
BufferedOutputStream(OutputStream out)throws IOException
//创建一个BufferedOutputStream对象来修饰参数out指定的字节输出流，参数sz用于指定缓冲区的大小
BufferedOutputStream(OutputStream out,int sz)throws IOException

（3）使用BufferedOutputStream的步骤

创建底层字节输出流对象–创建缓冲字节输出流对象–写数据到缓冲区中–关闭资源

二. InputStream

InputStream类是所有字节输入流的父类，是一个抽象类，不能直接通过new进行实例化，可通过实例化子类创建对象。

1. InputStream的常见子类

• ByteArrayInputStream：字节数组输入流，将内存缓冲区中的字节数组转换为字节输入流，从中读取字节
• FileInputStream 类：文件字节输入流，从文件中读取数据
• ObjectInputStream：对象输入流，它和ObjectOutputStream一起对基本数据或者对象做持久存储
• PipedInputStream：管道字节输入流，和PipedOutputStream一起使用，能实现多线程间的管道通信
• BufferedInputStream：缓冲字节输入流，为其他字节输入流提供读缓冲区
• DataInputStream：数据输入流，用于操作基本数据类型

2. InputStream的常用方法

//从输入流中读取一个 8 位的字节，并把它转换为 0~255 的整数，如果返回 -1，则表示已经到了输入流的末尾
abstract int read()throws IOException
//从输入流中读取若干字节，并把它们保存到参数 b 指定的字节数组中，并返回读取的字节数
//如果返回 -1，则表示已经到了输入流的末尾
int read(byte[] b)throws IOException
//从输入流中读取若干字节，并把它们保存到参数 b 指定的字节数组中，off 指定在字节数组中开始保存数据的起始下标，len 指定读取的字节数
//该方法返回实际读取的字节数
//如果返回 -1，则表示已经到了输入流的末尾
int read(byte[] b,int off,int len)throws IOException

//返回可以从输入流中读取的字节数
int available()throws IOException
//关闭该流并释放与之关联的所有资源
void close()throws IOException

3. FileInputStream

（1）概述

• FileInputStream以字节为单位读取文本文件
• FileInputStream对象关联的文件要保证存在，否则会发生FileNotFoundException异常

（2）构造方法

//在给定要读取数据的文件的情况下创建一个新的FileInputStream对象，file表示要从中读取数据的文件
FileInputStream(File file) throws FileNotFoundException
//在给定要读取数据的文件名的情况下创建一个新的FileReader对象，fileName表示要从中读取数据的文件的名称，表示的是一个文件的完整路径
FileInputStream(String fileName) throws FileNotFoundException

（3）使用FileInputStream的步骤

创建输入流对象–进行读操作–关闭输入流通道

（4）使用FileInputStream的例子

import java.io.*;
public class FileInputStreamDemo {
    public static void main(String[] args) {
        try{
            //一次读取一个字节
            fileRead_1();
            //一次读取一个字节数组
            fileRead_2();

        } catch (IOException e) {
            throw new RuntimeException("读取文件失败");
        }

    }
    //一次读取一个字节数组，数组大小由available()获取
    public static void fileRead_2() throws IOException {
        //1. 创建输入流对象，与目标文件相关联
        FileInputStream fis=new FileInputStream("fos.txt");
        //2. 进行读操作，一次读取一个字节数组，数组大小由available()获取
        byte[] buf=new byte[fis.available()];
        int len=0;
        while ((len=fis.read(buf))!=-1){
            System.out.println(new String(buf,0,len));
        }
        //3. 关闭资源
        fis.close();
    }

    //一次读取一个字节
    public static void fileRead_1() throws IOException {
        //1. 创建输入流对象，与目标文件相关联
        FileInputStream fis=new FileInputStream("fos.txt");
        //2. 进行读操作，一次读取一个字节
        int ch=0;
        while ((ch=fis.read())!=-1){
            System.out.println((char)ch);
        }
        //3. 关闭资源
        fis.close();
    }
}

4. BufferedInputStream

（1）概述

• BufferedInputStream是缓冲字节输入流，它的作用是为其他字节输入流添加缓冲功能。可以先将一批数据读到缓冲区，当缓冲区满了以后，再将缓冲区的数据一次性读到字节输入流，可提高对数据的读效率
• BufferedInputStream要结合流才可以使用

（2）构造方法

//创建一个BufferedInputStream对象来修饰参数in指定的字节输入流
BufferedInputStream(InputStream in)
//创建一个BufferedInputStream对象来修饰参数in指定的字节输入流，参数sz用于指定缓冲区的大小
BufferedInputStream(InputStream in,int sz)

（3）使用BufferedInputStream的步骤

创建底层字节输入流对象–创建缓冲字节输入流对象–读数据到缓冲区中–关闭资源

（4）使用BufferedInputStream的例子

演示MP4的复制，通过缓冲区

import java.io.*;
public class BufferedStreamDemo {
    public static void main(String[] args) {
        try{
            copy_1();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void copy_1() throws IOException {
        //创建缓冲字节输入流对象
        BufferedInputStream bis=new BufferedInputStream(new FileInputStream("1.mp4"));
        //创建缓冲字节输出流对象
        BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("2.mp4"));

        byte[] buf=new byte[1024];
        int len=0;
        //读取数据
        while ((len=bis.read(buf))!=-1){
            //写入数据
            bos.write(buf,0,len);
        }

        //关闭资源
        bis.close();
        bos.close();
    }
}