Java 二进制I/O流之字节流

引入：

    文件可以分为你两种类型进行存储，一是以文本的格式存储，其他的都是以二进制的方式进行存储的，比如：（100100001111）.
    在文本的读取中，我们有Scanner和PrintWriter方法中文本中读入和写出数据。

读取文本数据：
Scanner input= new Scanner(new File(“text.txt”));
System.out.println(input.nextLine());
写入文本数据：
PrintWriter output = new PrintWriter(“text.txt”);
output.print(“Java Test”);

二进制I/O：

1.简介

其实对于计算机来说，存储的只有二进制数，因为计算机只能识别 0 和 1 ，文本主要在于在二进制的基础上加上了编码和解码的过程。由于二进制不需要编码解码，所以比文本要高效。

2.二进制I/O类
主要分为输入类和输出类两部分：
其实输入和输出流都是很像的，而且方法的用法也差不多，下面我们用几个列子来详细介绍这些类的使用：

3.输入输出实现

简单的输入输出实现，这里先实例化一个输出流，向文件中写入了十个二进制的值，利用write()方法，当你查看文件时会发现是乱码。然后在实例化输入流，利用其read()方法，从文件中读取出二进制值。在处理完成时要记得关闭流。这里会有异常，我们直接在方法上抛出了。

public static void main(String[] args) throws IOException{
        //文件保存位置
        File file = new File("D://test.txt");

        //输出流，写入数据
        FileOutputStream outputStream = new FileOutputStream(file);
        for (int i = 0; i < 10; i++) {
            outputStream.write(i);
        }
        //输入类，读取数据
        FileInputStream input = new FileInputStream(file);
        int len;
        while((len = input.read()) != -1){
            System.out.println(len+"");
        }
        outputStream.close();
        input.close();

    }

文件复制功能
利用I/O流进行文件的复制

public static void main(String[] args) {
        try {
            FileInputStream fis = new FileInputStream(new File("D://music.mp3"));
            FileOutputStream fos = new FileOutputStream(new File("D://copy.mp3"));

//          //从输入流中读取一个字节，就放在输出流中输出，效率太慢
//          int len = 0;
//          while((len = fis.read()) != -1){
//              fos.write(len);
//          }


            int len = 0;
            byte[] buff = new byte[512];        //自定义缓冲区
            while((len = fis.read(buff)) != -1){
                fos.write(buff,0,len);          //将缓冲区写到文件，而不是一个字节一个字节的写入
            }
    //      fos.flush();    //清空 缓冲区，但不会关闭流
            fos.close();  //具有flush()和close两个功能
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

这里有两种方法，一种是直接进行读取和写入，一个字节一个字节的去执行，直到数据全部复制完成。另一种是我们自定义一个byte数组，来暂存一些从I/O流中读取的数据，然后再将数组中的全部数据以输出流写入到文件中，当我们执行的时候会发现这种效率是非常高的，这就用到了缓冲机制。我们自定义了一个缓冲区，及大小。

---

然而javaAPI中也给我们提供了自己的I/O缓冲方式。就是BufferedInputStream和BufferedOutputStream让我们去使用。

public static void main(String[] args) {
        //
        FileInputStream fis = null;
        FileOutputStream fos = null;
        BufferedInputStream buffInput = null;
        BufferedOutputStream buffOutput = null;
        try {
            fis = new FileInputStream(new File("D://music.mp3"));
            fos = new FileOutputStream(new File("D://copy.mp3"));

            //利用缓冲
            buffInput = new BufferedInputStream(fis);
            buffOutput = new BufferedOutputStream(fos);

            int numberCopy = 0;
            int len = 0;
            while((len = buffInput.read()) != -1){
                buffOutput.write(len);
                numberCopy++;
            }

            //关闭流
            buffOutput.close();
            buffInput.close();

            System.out.println(numberCopy+"bytes");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

我们一般都可以使用自定义一个数组，用于缓冲区，进行缓冲机制的实现，因为使用系统自带的需要另外常见两个buffer缓冲区。可能会带来内存上的过多占用。

总结：

1. I/O流的处理上一定要记得捕获异常，并对其处理。
2. 使用完流后一定要记得关闭流通道。
3. 在大文件的处理上要加入缓冲机制。