IO使用Buffer复制流媒体文件

之前的文章整理一下重新发布

java io流有如下内容：

      使用java-io流复制文件时，可以从以下步骤来进行判断使用何种流：

1.首先判断是源文件还是目的文件，若为源文件就使用inputstream和reader，否则就使用outputstream和writer；

2.如果是文本文件使用字节流，所以使用inputstream/outputstream体系，媒体文件就使用reader/writer体系；

3.接下来明确使用体系中的那个对象，reader中操作文件的对象是filereader，inputstream体系中操作文件的对象是fileinputstream；

4.是否提高效率：如需提高效率，使用缓存类buffered~，只要用到缓冲区，就要记得刷新，关闭缓冲区，就是在关闭缓冲区中的流对象。

     ① 完整的复制媒体文件的类如下：

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

public class CopyMdeia {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        try {
            InputStream is = new FileInputStream("e://txdx.mp3");
            BufferedInputStream bis = new BufferedInputStream(is);
            OutputStream os = new FileOutputStream("d://txdx.mp3");
            byte[] buffer = new byte[1024];
            int count = 0;
            try {
                while((count=bis.read(buffer))!=-1) {
                    os.write(buffer, 0, count);    
                }                
            }catch(IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            try {
                os.flush();
                os.close();
                bis.close();
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

     ② 接下来编写自己的缓存类：

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

public class MyIputStremBufferedFileMediaCopy {

    private FileInputStream fis = null;

    private byte[] by = new byte[1024];

    private int len = 0, p = 0;

    MyIputStremBufferedFileMediaCopy(FileInputStream fis) {
        this.fis = fis;
    }

    public int Read() throws IOException {

        if (len == 0) {
            len = fis.read(by);
            if (len < 0)
                return -1;
            p = 0;
            byte b = by[p];
            p++;
            len--;
            return b & 255;
        } else if (len > 0) {
            byte b = by[p];
            p++;
            len--;
            return b & 255;
        }
        return -1;
    }

    public void myClose() throws IOException {
        fis.close();
    }
}

       这里解释下为什么要&255：

* 因为read读取到的是二进制数据，二进制数据是由0和1组成的，有可能出现11111111
* 作为一个字节来讲11111111的十进制是-1，由于返回值是int类型，就会自动提升，int类型是32位，在前面补1，
* 就成了11111111-11111111-11111111-11111111，他的值还是-1，在写入的while循环哪里，判断到-1就会停止循环，
* 就导致了数据丢失，所以在这里&一个255，也就是二进制的00000000-00000000-00000000-11111111，
* 11111111-11111111-11111111-11111111
* 00000000-00000000-00000000-11111111
* ————————————————————————————————————& 值都为1结果才为1。
* 00000000-00000000-00000000-11111111
* 结果不变，
* 这样既保证了返回值不是-1，又没有改变二进制数据。

查看BufferedInputStream源码就可以看到：

public synchronized int read() throws IOException {
        if (pos >= count) {
            fill();
            if (pos >= count)
                return -1;
        }
        return getBufIfOpen()[pos++] & 0xff;
    }

这里也&255，具体的原因就是上面提到的问题。

参考文章：https://blog.csdn.net/qq_41890624/article/details/81625383