Java - io框架[字节流]（一）

流的概念

内存与存储设备之间传输数据的通道

流的分类

• 按方向分类
  1. 输入流：将【存储设备】中的内容读到【内存】中
  2. 输出流：将【内存】中的内容写到【存储设备】中

• 按单位分类
  1. 字节流：以字节为单位，可以读写所有数据
  2. 字符流：以字符为单位，只能读写文本数据
• 按功能分类
  1. 节点流：具有实际传输数据的读写功能
  2. 过滤流：在节点流的基础之上增强功能

字节流(抽象父类)

InputStream

类型	方法名	作用
int	available()	返回从该输入流中可以读取（或跳过）的字节数的估计值，而不会被下一次调用此输入流的方法阻塞。
void	close()	关闭此输入流并释放与流相关联的任何系统资源。
void	mark(int readlimit)	标记此输入流中的当前位置。
boolean	markSupported()	测试这个输入流是否支持 mark和 reset方法。
abstract int	read()	从输入流读取数据的下一个字节。
int	read(byte[] b)	从输入流读取一些字节数，并将它们存储到缓冲区 b 。
int	read(byte[] b, int off, int len)	从输入流读取最多 len字节的数据到一个字节数组。
void	reset()	将此流重新定位到上次在此输入流上调用 mark方法时的位置。
long	skip(long n)	跳过并丢弃来自此输入流的 n字节数据。

OutputStream

类型	方法名	作用
void	close()	关闭此输出流并释放与此流相关联的任何系统资源。
void	flush()	刷新此输出流并强制任何缓冲的输出字节被写出。
void	write(byte[] b)	将 b.length字节从指定的字节数组写入此输出流。
void	write(byte[] b, int off, int len)	从指定的字节数组写入 len个字节，从偏移 off开始输出到此输出流。
abstract void	write(int b)	将指定的字节写入此输出流。

文件字节流

FileInputStream

案例（一次读取一个字节）

package zijieliu;

import java.io.FileInputStream;

/**
 * 文件字节输入流
 * FileInputStream
 */

public class input{
    public static void main(String[] args) throws Exception {
//        1. 创建FileInputStream，指定文件路径
        FileInputStream file = new FileInputStream("D:\\a.txt");
//        2. 读取文件
        int data = 0;
        while ((data=file.read()) !=-1){
            System.out.println((char)data);
        }
//       3. 关闭流
        file.close();
        System.out.println("读取完成");
    }
}

此处需要对data进行强制转换，否则输出的为Ascii编码
当读取完成后file.read()值为-1

一次读取多个字节

package zijieliu;
import java.io.FileInputStream;
/**
 * 文件字节输入流
 * FileInputStream
 */

public class input{
    public static void main(String[] args)throws Exception {
//        1. 创建FileInputStream，指定文件路径
        FileInputStream file = new FileInputStream("D:\\a.txt");
//        2. 读取文件
        byte[] bytes = new byte[50];
        int count = file.read(bytes);
        System.out.println(new String(bytes));
        System.out.println(count);
//       3. 关闭流
        file.close();
        System.out.println("读取完成");
    }
}

每次读取都是从缓冲区读取

FileOutputStream

package zijieliu;

import java.io.FileOutputStream;

public class output {
    public static void main(String[] args) throws Exception {
//        1. 创建字节输出流对像
        FileOutputStream outputStream = new FileOutputStream("d:\\bb..txt",true);
//        2. 写入文件
//        outputStream.write(97);
//        outputStream.write('b');
        String a = "hello word";
        outputStream.write(a.getBytes());
        outputStream.close();
        System.out.println("执行完毕");
    }
}

outputStream.write('b');只写取一个字符
outputStream.write(97);写入的是97对应的字符
FileOutputStream("d:\\bb..txt",true);ture是append对应的属性，意义是在文件后面追加，而不是覆盖。

案例（文件的复制）

package zijieliu;

import java.io.FileInputStream;
import java.io.FileOutputStream;

public class demo {
    public static void main(String[] args) throws Exception{
        FileInputStream fileInputStream = new FileInputStream("d:\\a.png");
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\b.png");
//        一边读一边写
        byte[] bytes = new byte[1024*3];
        int count = 0;
        while ((count = fileInputStream.read(bytes))!=-1){
            fileOutputStream.write(bytes,0,count);
        }
        fileInputStream.close();
        fileOutputStream.close();
        System.out.println("复制完成！");
    }
}

a.png 为D盘 已经有的文件，b.png是复制的文件
byte[] bytes = new byte[1024*3]一次读取3k

字节缓冲流

缓冲流：BufferedInputStream/ BufferedOutputStream

• 提高IO效率，减少访问磁盘次数
• 数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close

BufferedInputStream

BufferedInputStream为另一个输入流添加了功能，即缓冲输入和支持mark和reset方法的功能。 当创建BufferedInputStream时，将创建一个内部缓冲区数组。 当从流中读取或跳过字节时，内部缓冲区将根据需要从所包含的输入流中重新填充，一次有多个字节。 mark操作会记住输入流中的一点，并且reset操作会导致从最近的mark操作之后读取的所有字节在从包含的输入流中取出新的字节之前重新读取。

package zijieliu;
import java.io.BufferedInputStream;
import java.io.FileInputStream;
/**
 * BufferedInputStream
 * 字节缓冲流
 */
public class Buffer {
    public static void main(String[] args) throws Exception{
//        创建BufferedInputStream
        FileInputStream fileInputStream = new FileInputStream("d:\\a.txt");
        BufferedInputStream inputStream = new BufferedInputStream(fileInputStream);
//        读取文件
        byte[] bytes = new byte[1024*4];
        int data = 0;
        while ((data = inputStream.read(bytes))!=-1){
            System.out.println(new String(bytes,0,data));
        }
        System.out.println("读取完成!");
        inputStream.close();
        fileInputStream.close();
    }
}

BufferedOutputStream

该类实现缓冲输出流。 通过设置这样的输出流，应用程序可以向底层输出流写入字节，而不必为写入的每个字节导致底层系统的调用。

package zijieliu;
import java.io.BufferedOutputStream;
import java.io.FileOutputStream;
public class bufferout {
    public static void main(String[] args) throws Exception{
        FileOutputStream fileOutputStream = new FileOutputStream("d:\\buffer.txt");
        BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(fileOutputStream);
        for (int q = 0; q < 10;q++){
            bufferedOutputStream.write("hello word".getBytes());  //内容少于8k写入缓冲区
            bufferedOutputStream.flush();  //刷新到硬盘
        }
        System.out.println("写入完成!");
        bufferedOutputStream.close();
    }
}

bufferedOutputStream.write("hello word\r\n".getBytes());每写一次换行

---

下一节（序列化与反序列化）