22.文件读写：字节流

1.什么是字节流

字节流最大的特点是，每次调用read或write读入或写出的数据是以字节为单位的，而有的字符需要两个字节去存储，所以字节流读取数据会发生读到的数据不准确的情况。

1.1 字节数组流

输入输出流的源 和 目的地除了可以是“文件”（硬盘）外，还可以是计算机内存，我们也可以使用数组流来将数据输入输出到内存。

1.1.1 字节数组输入流

ByteArrayInputStream是输入流InuptStream的一种实现，它的源只能是字节数组byte[]，它支持mark。

1.1.1.1 构造方法

ByteArrayInputStream(byte[] buf);
此构造方法的字节数组流的源是参数buf指定的数组的全部字节单元。
ByteArrayInputStream(byte[] buf ,int offset,int length);
此方法构造的字节数组流的源是buf指定的数组从offset处按顺序取length个字节单元。

1.1.1.2 常用方法

public int read();
该方法可以顺序地从源中读取一个字节，返回读出的字节值。
public int read(byte[] b,int off,int len);
该方法可以顺序地从源中读出参数len指定的字节数，并将读出的字节存放在参数b指定的数组中，参数off指定数组b读出字节的起始位置，返回实际读出的字节个数，若未读出字节read方法返回-1.

示例：

public static void readStudy(){
    //定义字节数组输入流的源
    byte[] bytes = "我是四郎".getBytes(StandardCharsets.UTF_8);
    //根据源创建字节数组输入流
    ByteArrayInputStream inputStream = new ByteArrayInputStream(bytes);
    //读取源bytes中的数据
    int n;
    while ((n=inputStream.read())!=-1){
        System.out.print((char)n);
    }
}

1.1.2 字节数组输出流

ByteArrayOutputStream是输出流的一种实现，它的目的地只能是字节数组byte[]，它支持mark。

1.1.2.1 构造方法

ByteArrayOutputStream();
该方法构造的字节数组输出空间指向一个默认大小为32字节的缓冲区，若输出流向缓冲区写入的字节个数大于缓冲区时，缓冲区的容量会自动增加。
ByteArrayOutputStream(int size);
此方法构造的字节数组输出流指向的缓冲区的初始大小由参数size指定，若输出流向缓冲区写入的字节个数大于缓冲区时，缓冲区的容量会自动的增加。

1.1.2.2 常用方法

public void write(int b);
字节数组输出流可调用该方法顺序地向缓冲区写入一个字节。
public void write(byte[] b, int off, int len);
该方法可以将参数b中指定的len个字节顺序地写入缓冲区，参数off指定从b中写出的字节的起始位置。
public byte[] toByteArray();
该方法可以返回输出流写入到缓冲区的全部字节，通过它我们可以获取写出的数据。

示例：

public static void toByteArrayStudy() throws IOException {
    byte[] result;
    byte[] bytes = "我是四郎".getBytes(StandardCharsets.UTF_8);
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    outputStream.write(bytes);
    result = outputStream.toByteArray();
    for (byte a:bytes){
        System.out.print(a);
    }
    System.out.println();
    for (byte b:result){
        System.out.print(b);
    }
}

1.2 字节数据流

数据流能让我们读取或写出指定类型的数据，它是字节流的一种增强。

1.2.1数据输入流

由DataInputStream类创建的对象称为数据输入流。
它们允许程序按着机器无关的风格读取java原始数据，也就是说，当读取一个数值时，不必再关心这个数值应当是多少字节。它算是对其他字节输入流的一种增强，但是也有一定的局限，比如用它读取readChar只能读取编码为UTF-16的文件，读取其他文件将会乱码。

1.2.1.1 构造方法

DataInputStream(InputStream in);
此构造方法创建的数据输入流指向一个由参数in指定的底层输入流。

1.2.1.2 常用方法

close();关闭流。
readBoolean();读取一个布尔值。
readByte();读取一个字节。
readChar();读取一个字符。
readDouble();读取一个双精度浮点值。
readFloat();读取一个单精度浮点值。
readInt();读取一个整型值。
readLong();读取一个长整型值。
readShort();读取一个短整型值。
readUnsignedByte();读取一个无符号字节。
readUnsignedShort();读取一个无符号短整型值。
readUTF();读取一个UTF字符串。

实例

public static void main(String[] args) throws IOException {
    DataInputStream inputStream = new DataInputStream(
            new FileInputStream("麻子.txt"));
    StringBuilder builder = new StringBuilder();
    while(true){
        try{
           builder.append(new Character(inputStream.readChar()));
        }catch (Exception e){
            inputStream.close();
            break;
        }
    }
    System.out.println(builder.toString());
}

1.2.2 数据输出流

用法和输入流大同小异，它是字节输出流的一种增强。

1.2.2.1 关键方法

writeDouble(double v)
writeInt(int v)
writeUTF(String v)等。

实例：

public static void main(String[] args) throws IOException {
    DataOutputStream outputStream = new DataOutputStream
            (new FileOutputStream("四郎.txt"));
    String str = "我是四郎，我爱死麻子了！！";
    outputStream.writeUTF(str);
}

1.3 字节对象流

用ObjectInputStream和ObjectOutputStream类创建的对象称为对象输入（出）流。
对象输入（出）流可以将一个对象写入到一个文件中（或从文件读取一个对象到内存中）。
这个对象IO流比较常用，它可以将对象状态保存到磁盘中或通过网络发送出去，接收方只需要用相同的机制在需要的时候重新加载，相当于深拷贝了。

1.3.1 对象输入流

ObjectInputStream(InputStream in);
此方法是对象输入流的构造方法。
readObject();
此方法读取一个对象到程序中。

1.3.2 对象输出流

ObjectOutputStream(OutputStream out);
此方法是对象输出流的构造方法。
writeObject(object obj);
此方法可以将obj写入一个文件中。

实例：
首先使用对象输出流将对象写入磁盘中：

public static void main(String[] args) throws IOException {
    ObjectOutputStream outputStream = new ObjectOutputStream
    (new FileOutputStream("四郎"));
    List<String> a = new ArrayList<>();
    a.add("我是四郎，我爱死麻子了");
    outputStream.writeObject(a);
}

然后使用对象输入流重新加载：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    ObjectInputStream inputStream = new ObjectInputStream
    (new FileInputStream("四郎"));
    List<String> a  = (List<String>) inputStream.readObject();
    System.out.println(a);
}

1.3 随机IO流

在java中，我们也可以建立一个流，通过该流既能读文件，也能写文件。
那就是RandomAccessFile类创建的随机流。
RandomAccessFile类创建的流的指向既可以作为流的源，也可以作为流的目的地。
随机IO流读取字符是以字节为单位的。

1.3.1 使用方法

1.3.1.1 构造方法

RandomAccessFile(String name,String mode);
RandomAccessFile(File file ,String mode);
参数name用来确定一个文件名，给出创建的流的源（也是目的地）。参数mode取r（只读）或rw（可读写），决定创建流对文件的访问权利。

注意：随机流指向文件，不刷新文件。

1.3.1.2 常用方法

close();关闭文件。
getFilePointer();获取当前读写的位置。
length();获取文件的长度。
read();从文件中读取一个字节的数据。
readBoolean();从文件中读取一个布尔值，0代表false，其他代表true。
readByte();从文件中读取一个字节。
readChar();从文件中读取一个字符。（两个字节）
readDouble(); 从文件读取一个双精度浮点值（8个字节）
readFloat(); 从文件读取一个单精度浮点值（4个字节）
readFully(byte b[]); 读b.length字节放入数组b，完全填满该数组
readInt();从文件中读取一个int值（4个字节）
readLine();从文件中读取一个文本行
readLong();从文件中读取一个长整型值（8个字节）
readShort();从文件中读取一个短型值（2个字节）
readUnsignedByte();从文件读取一个无符号字节（1个字节）
readUnsignedShort();从文件读取一个无符号短型值（2个字节）
readUTF();从文件中读取一个UTF字符串
seek(long position);定位读写位置
setLength(long newlength);设置文件的长度。
skipBytes(int n);在文件中跳过给定数量的字节。
write(byte b[]);写b.length个字节到文件
writeBoolean(boolean v);把一个布尔值作为单字节值写入文件
writeByte(int v);向文件写入一个字节
writeByte(String s);向文件写入一个字符串
writeChar(char c);向文件写入一个字符
writeChars(String s);向文件写入一个作为字符数据的字符串
writeDouble(double v);向文件写入一个双精度浮点值
writeFloat(float v);向文件写入一个单精度浮点值
writeInt(int v);向文件写入一个int值
writeLong(long v);向文件写入一个长整型值
writeShort(int v);向文件写入一个短整型值
writeUTF(String s);向文件写入一个UTF字符串

1.3.1.3 使用实例

public class RandomAccessFileStudy {

    public static void main(String[] args) throws IOException {
        RandomAccessFile randomAccessFile = new RandomAccessFile("麻子.txt","rw");
        while (true){
               String s = randomAccessFile.readLine();
               if(s==null) break;
               System.out.println(s);
        }
        randomAccessFile.write("\n你好，我是四郎".getBytes(StandardCharsets.UTF_8));
    }
}

代码地址：
Java基础学习/src/main/java/Progress/exa22 · 严家豆/Study - 码云 - 开源中国 (gitee.com)