字节流

• IO: Input / Ouput 即输⼊输出

输出流：程序（内存）--->外界设备
输⼊流：外界设备--->程序（内存）

• 处理数据类型分类

字符流：处理字符相关，如处理⽂本数据（如txt⽂件), Reader/Writer
字节流: 处理字节相关，如声⾳或者图⽚等⼆进制，InputStream/OutputStream

• 两者区别

字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，⼀次可能读多个字节
字节流可以处理⼏乎所有⽂件，字符流只能处理字符类型的数据

• 抽象类

字符流 Reader/Writer
字节流 InputStream/OutputStream

• InputStream是输⼊字节流的⽗类，它是⼀个抽象类（⼀般⽤他的⼦类）

int read() 
    从输⼊流中读取单个字节,返回0到255范围内的int字节值,字节数据可直接转换为int类 型, 如果已经到达流末尾⽽没有可⽤的字节，则返回－1
int read(byte[] buf)
    从输⼊流中读取⼀定数量的字节，并将其存储在缓冲区数组buf中, 返回实际读取的字节数，如果已经到达流末尾⽽没有可⽤的字节，则返回－1
long skip(long n)
    从输⼊流中跳过并丢弃 n 个字节的数据。
int available()
    返回这个流中有多少个字节数，可以把buf数组⻓度定为这个
void close() throws IOException
    关闭输⼊流并释放与该流关联的系统资源

• 子类FileInputStream

抽象类InputStream⽤来具体实现类的创建对象, ⽂件字节输⼊流, 对⽂件数据以字节的形式进⾏读取操作
 
//传⼊⽂件所在地址
public FileInputStream(String name) throws FileNotFoundException
 
//传⼊⽂件对象
public FileInputStream(File file) throws FileNotFoundException

• 代码案例

public class Main {
 
    public static void main(String[] args)throws IOException {
        String dir = "C:\\work";
        String name = "test.txt";
        File file = new File(dir,name);
        InputStream inputStream = new FileInputStream(file);
        testRead(inputStream);
        testSkip(inputStream);
        testReadByteArr(inputStream);
    }
 
    /**
     * 读取所有字节
     * @param inputStream
     * @throws IOException
     */
    public static void testReadByteArr(InputStream inputStream)throws IOException{
        //如果buf的长度为0，则不读取任何字节并返回0；每次读取的字节数最多等于buf的长度
        // 写法1
        // byte[] buf = new byte[1024];
        // 写法2
        byte[] buf = new byte[inputStream.available()];
        int length;
        //循环读取文件内容，输入流中将最多的buf.length个字节数据读入一个buf数组中，返回类型是读取到的字节数
        //如果这个缓冲区没有满的话，则返回真实的字节数
        while ((length = inputStream.read(buf))!=-1){
            //System.out.print(new String(buf,0,length));    // 从buf数组中读取，从0开始读取，读取到length
            //中文乱码问题，换成GBK,或者UTF-8
            System.out.print(new String(buf,0,length,"UTF-8"));
        }
        // 关闭流
        inputStream.close();
    }
 
    /**
     * 读取1个字节
     * @param inputStream
     * @throws IOException
     */
    public static void testRead(InputStream inputStream)throws IOException{
        //对于汉字等 unicode中的字符不能正常读取，只能以乱码的形式显示
        int read = inputStream.read();
        System.out.println(read);
        System.out.println((char)read);
        // 关闭流
        inputStream.close();
    }
 
    /**
     *
     * @param inputStream
     * @throws IOException
     */
    public static void testSkip(InputStream inputStream)throws IOException{
        // 跳过2个字节，读取第3个字节
        long skipSize = inputStream.skip(2);
        System.out.println(skipSize);
        int read = inputStream.read();
        System.out.println(read);
        System.out.println((char)read);
        // 关闭流
        inputStream.close();
    }
 
}

• OutputStream是输出字节流的⽗类，它是⼀个抽象类

void write(int b)
    将指定的字节写⼊输出流
void write(byte[] b)throws IOException
    将b.length个字节的byte数组写⼊当前输出流
void flush() throws IOException
    write是写到缓冲区中，可以认为是内存中,当缓冲区满时系统会⾃动将缓冲区的内容写⼊⽂件，但是⼀般还有⼀部分有可能会留在内存这个缓冲区中, 所以需要调⽤flush空缓冲区数据。
void close() throws IOException
    关闭输⼊流并释放与该流关联的系统资源

• 抽象类OutputStream⽤来具体实现类的创建对象, ⽂件字节输出流, 对⽂件数据以字节的形式进⾏输出的操作

//传⼊输出的⽂件地址
public FileOutputStream(String name)
//传⼊⽬标输出的⽂件对象
public FileOutputStream(File file)
//传⼊⽬标输出的⽂件对象, 是否可以追加内容
public FileOutputStream(File file, boolean append)

• 代码案例

public class Main {
 
    public static void main(String[] args)throws IOException {
        String dir = "C:\\work";
        String name = "test.txt";
        String target = "b.txt";
        File file = new File(dir,name);     // 拼接文件的路径
        InputStream inputStream = new FileInputStream(file);    // 读取文件
 
        // 写法1，写入数据，会自动创建文件，但是不会创建多级目录下的文件
//        OutputStream outputStream = new FileOutputStream(dir+File.separator+target);
        // 写法2，写入数据，不覆盖文件，追加数据
        OutputStream outputStream = new FileOutputStream(dir+File.separator+target,true);
        // 测试
        testOut(inputStream,outputStream);
        testOutBuf(inputStream,outputStream);
    }
 
    /**
     * 将inputStream中的数据写入outputStream
     * @param inputStream
     * @param outputStream
     * @throws IOException
     */
    public static void testOutBuf(InputStream inputStream,OutputStream outputStream)throws IOException {
        byte [] buf = new byte[1024];
        int length ;
        while (( length = inputStream.read(buf))!=-1){
            outputStream.write(buf,0,length);
        }
        //关闭流
        inputStream.close();
        outputStream.close();
    }
 
    // 写入文件测试1，单个字节读取，中文会有问题
    public static void testOut(InputStream inputStream,OutputStream outputStream)throws IOException{
        int value = 0;
        while (value!=-1){
          value =  inputStream.read();
          outputStream.write(value);
        }
        //最后记得关闭流
        inputStream.close();
        outputStream.close();
    }
 
}

• 缓冲 Buffer

它是内存空间的⼀部分，在内存空间中预留了⼀定的存储空间，这些存储空间⽤来缓冲输⼊或输出的数据，这部分空间就叫做缓冲区，缓冲区是具有⼀定⼤⼩的

• 缓冲的作用

# 缓冲，缓和冲击，例如操作磁盘⽐内存慢的很多，所以不⽤缓冲区效率很低
# 数据传输速度和数据处理的速度存在不平衡，⽐如你每秒要写100次硬盘，对系统冲击很⼤，浪费了⼤量时间在忙着处理开始写和结束写这两个事件，⽤buffer暂存起来，变成每10秒写⼀次硬盘，数据可以直接送往缓冲区，⾼速设备不⽤再等待低速设备，对系统的冲击就很⼩，写⼊效率⾼了

• 缓冲类

BufferInputStream
BufferOutputStream

• BufferInputStream 缓冲字节输⼊流

# BufferedInputStream 通过预先读⼊⼀整段原始输⼊流数据⾄缓冲区中，⽽外界对BufferedInputStream的读取操作实际上是在缓冲区上进⾏，如果读取的数据超过了缓冲区的范围，那么BufferedInputStream负责重新从原始输⼊流中载⼊下⼀截数据填充缓冲区，然后外界继续通过缓冲区进⾏数据读取
# 好处：避免了⼤量的磁盘IO，原始的InputStream类实现的read是即时读取的，每⼀次读取都会是⼀次磁盘IO操作（哪怕只读取了1个字节的数据），如果数据量巨⼤，这样的磁盘消耗⾮常可怕
# 缓冲区的实现: 读取可以读取缓冲区中的内容，当读取超过缓冲区的内容后再进⾏⼀次磁盘IO，载⼊⼀段数据填充缓冲，下⼀次读取⼀般情况就直接可以从缓冲区读取，减少了磁盘IO
# 默认缓冲区⼤⼩是8k, int DEFAULT_BUFFER_SIZE = 8192
 
//对输⼊流进⾏包装，⾥⾯默认的缓冲区是8k
public BufferedInputStream(InputStream in);
//对输⼊流进⾏包装,指定创建具有指定缓冲区⼤⼩的
public BufferedInputStream(InputStream in,int size);

• 常用方法

/从输⼊流中读取⼀个字节
public int read();
 
//从字节输⼊流中给定偏移量处开始将各字节读取到指定的 byte 数组中。
public int read(byte[] buf,int off,int len);
 
//关闭释放资源，关闭的时候这个流即可，InputStream会在⾥⾯被关闭
void close();

• BufferOutputStream 缓冲字节输出流

//对输出流进⾏包装,⾥⾯默认的缓冲区是8k
public BufferedOutputStream(OutputStream out);
//对输出流进⾏包装,指定创建具有指定缓冲区⼤⼩的
public BufferedOutputStream(OutputStream out,int size);
 
# 常⽤的三个⽅法
 //向输出流中输出⼀个字节
 public void write(int b);
 //将指定 byte 数组中从偏移量 off 开始的 len 个字节写⼊缓冲的输出流。
 public void write(byte[] buf,int off,int len);
 //刷新此缓冲的输出流，强制使所有缓冲的输出字节被写出到底层输出流中。
 public void flush();
 //关闭释放资源，关闭的时候这个流即可，OutputStream会在⾥⾯被关闭, JDK7新特性try(在这⾥声明的会⾃动关闭){}
 void close();

• 使用缓冲流实现文件拷贝案例

public class BufferMain {
    
    public static void main(String [] args){
        try{
            FileInputStream fis = new FileInputStream("C:\\Users\\79466\\Desktop\\test\\a.txt");
            BufferedInputStream bis = new BufferedInputStream(fis);
            FileOutputStream fos = new FileOutputStream("C:\\Users\\79466\\Desktop\\test\\copy.txt");
            BufferedOutputStream bos = new BufferedOutputStream(fos);
            int size;
            byte [] buf = new byte[1024];
            while ( (size =bis.read(buf))!=-1){
                bos.write(buf,0,size);
            }
            //刷新此缓冲区的输出流，才可以保证数据全部输出完成，
            //bos.flush();
            bis.close();
            bos.close();
        }catch (Exception e){
        }
    }
 
}