(57) 二进制文件和字节流 / 计算机程序的思维逻辑

查看历史文章,请点击上方链接关注公众号。

本节我们介绍在Java中如何以二进制字节的方式来处理文件,上节我们提到Java中有流的概念,以二进制方式读写的主要流有:

  • InputStream/OutputStream: 这是基类,它们是抽象类。
  • FileInputStream/FileOutputStream: 输入源和输出目标是文件的流。
  • ByteArrayInputStream/ByteArrayOutputStream: 输入源和输出目标是字节数组的流。
  • DataInputStream/DataOutputStream: 装饰类,按基本类型和字符串而非只是字节读写流。
  • BufferedInputStream/BufferedOutputStream: 装饰类,对输入输出流提供缓冲功能。

下面,我们就来介绍这些类的功能、用法、原理和使用场景,最后,我们总结一些简单的实用方法。

InputStream/OutputStream

InputStream的基本方法

InputStream是抽象类,主要方法是:

public abstract int read() throws IOException;

read从流中读取下一个字节,返回类型为int,但取值在0到255之间,当读到流结尾的时候,返回值为-1,如果流中没有数据,read方法会阻塞直到数据到来、流关闭、或异常出现,异常出现时,read方法抛出异常,类型为IOException,这是一个受检异常,调用者必须进行处理。read是一个抽象方法,具体子类必须实现,FileInputStream会调用本地方法,所谓本地方法,一般不是用Java写的,大多使用C语言实现,具体实现往往与虚拟机和操作系统有关。

InputStream还有如下方法,可以一次读取多个字节:

public int read(byte b[]) throws IOException

读入的字节放入参数数组b中,第一个字节存入b[0],第二个存入b[1],以此类推,一次最多读入的字节个数为数组b的长度,但实际读入的个数可能小于数组长度,返回值为实际读入的字节个数。如果刚开始读取时已到流结尾,则返回-1,否则,只要数组长度大于0,该方法都会尽力至少读取一个字节,如果流中一个字节都没有,它会阻塞,异常出现时也是抛出IOException。该方法不是抽象方法,InputStream有一个默认实现,主要就是循环调用读一个字节的read方法,但子类如FileInputStream往往会提供更为高效的实现。

批量读取还有一个更为通用的重载方法:

public int read(byte b[], int off, int len) throws IOException

读入的第一个字节放入b[off],最多读取len个字节,read(byte b[])就是调用了该方法:

public int read(byte b[]) throws IOException {
    return read(b, 0, b.length);
}

流读取结束后,应该关闭,以释放相关资源,关闭方法为:

public void close() throws IOException

不管read方法是否抛出了异常,都应该调用close方法,所以close通常应该放在finally语句内。close自己可能也会抛出IOException,但通常可以捕获并忽略。

InputStream的高级方法

InputStream还定义了如下方法:

public long skip(long n) throws IOException
public int available() throws IOException
public synchronized void mark(int readlimit)
public boolean markSupported()
public synchronized void reset() throws IOException

skip跳过输入流中n个字节,因为输入流中剩余的字节个数可能不到n,所以返回值为实际略过的字节个数。InputStream的默认实现就是尽力读取n个字节并扔掉,子类往往会提供更为高效的实现,FileInputStream会调用本地方法。在处理数据时,对于不感兴趣的部分,skip往往比读取然后扔掉的效率要高。

available返回下一次不需要阻塞就能读取到的大概字节个数。InputStream的默认实现是返回0,子类会根据具体情况返回适当的值,FileInputStream会调用本地方法。在文件读写中,这个方法一般没什么用,但在从网络读取数据时,可以根据该方法的返回值在网络有足够数据时才读,以避免阻塞。

一般的流读取都是一次性的,且只能往前读,不能往后读,但有时可能希望能够先看一下后面的内容,根据情况,再重新读取。比如,处理一个未知的二进制文件,我们不确定它的类型,但可能可以通过流的前几十个字节判断出来,判读出来后,再重置到流开头,交给相应类型的代码进行处理。

InputStream定义了三个方法,mark/reset/markSupported,用于支持从读过的流中重复读取。怎么重复读取呢?先使用mark方法将当前位置标记下来,在读取了一些字节,希望重新从标记位置读时,调用reset方法。

能够重复读取不代表能够回到任意的标记位置,mark方法有一个参数readLimit,表示在设置了标记后,能够继续往后读的最多字节数,如果超过了,标记会无效。为什么会这样呢?因为之所以能够重读,是因为流能够将从标记位置开始的字节保存起来,而保存消耗的内存不能无限大,流只保证不会小于readLimit。

不是所有流都支持mark/reset的,是否支持可以通过markSupported的返回值进行判断。InpuStream的默认实现是不支持,FileInputStream也不直接支持,但BufferedInputStream和ByteArrayInputStream可以。

OutputStream

OutputStream的基本方法是:

public abstract void write(int b) throws IOException;

向流中写入一个字节,参数类型虽然是int,但其实只会用到最低的8位。这个方法是抽象方法,具体子类必须实现,FileInputStream会调用本地方法。

OutputStream还有两个批量写入的方法:

public void write(byte b[]) throws IOException

public void write(byte b[], int off, int len) throws IOException

在第二个方法中,第一个写入的字节是b[off],写入个数为len,最后一个是b[off+len-1],第一个方法等同于调用:write(b, 0, b.length);。OutputStream的默认实现是循环调用单字节的write方法,子类往往有更为高效的实现,FileOutpuStream会调用对应的批量写本地方法。

OutputStream还有两个方法:

public void flush() throws IOException
public void close() throws IOException

flush将缓冲而未实际写的数据进行实际写入,比如,在BufferedOutputStream中,调用flush会将其缓冲区的内容写到其装饰的流中,并调用该流的flush方法。基类OutputStream没有缓冲,flush代码为空。

需要说明的是文件输出流FileOutputStream,你可能会认为,调用flush会强制确保数据保存到硬盘上,但实际上不是这样,FileOutputStream没有缓冲,没有重写flush,调用flush没有任何效果,数据只是传递给了操作系统,但操作系统什么时候保存到硬盘上,这是不一定的。要确保数据保存到了硬盘上,可以调用FileOutputStream中的特有方法。

close一般会首先调用flush,然后再释放流占用的系统资源。同InputStream一样,close一般应该放在finally语句内。

FileInputStream/FileOutputStream

FileOutputStream

FileOutputStream的主要构造方法有:

public FileOutputStream(File file) throws FileNotFoundException

public FileOutputStream(File file, boolean append) throws FileNotFoundException
public FileOutputStream(String name) throws FileNotFoundException
public FileOutputStream(String name, boolean append) throws FileNotFoundException

有两类参数,一类是文件路径,可以是File对象file,也可以是文件路径name,路径可以是绝对路径,也可以是相对路径,如果文件已存在,append参数指定是追加还是覆盖,true表示追加,没传append参数表示覆盖。new一个FileOutputStream对象会实际打开文件,操作系统会分配相关资源。如果当前用户没有写权限,会抛出异常SecurityException,它是一种RuntimeException。如果指定的文件是一个已存在的目录,或者由于其他原因不能打开文件,会抛出异常FileNotFoundException,它是IOException的一个子类。

我们看一段简单的代码,将字符串"hello, 123, 老马"写到文件hello.txt中:

OutputStream output =  new FileOutputStream("hello.txt");
try{
    String data = "hello, 123, 老马";
    byte[] bytes = data.getBytes(Charset.forName("UTF-8"));
    output.write(bytes);
}finally{
    output.close();
}

OutputStream只能以byte或byte数组写文件,为了写字符串,我们调用String的getBytes方法得到它的UTF-8编码的字节数组,再调用write方法,写的过程放在try语句内,在finally语句中调用close方法。

FileOutputStream还有两个额外的方法:

public FileChannel getChannel()

public final FileDescriptor getFD()

FileChannel定义在java.nio中,表示文件通道概念,我们不会深入介绍通道,但内存映射文件方法定义在FileChannel中,我们会在后续章节介绍。FileDescriptor表示文件描述符,它与操作系统的一些文件内存结构相连,在大部分情况下,我们不会用到它,不过它有一个方法sync:

public native void sync() throws SyncFailedException;

这是一个本地方法,它会确保将操作系统缓冲的数据写到硬盘上。注意与OutputStream的flush方法相区别,flush只能将应用程序缓冲的数据写到操作系统,sync则确保数据写到硬盘,不过一般情况下,我们并不需要手工调用它,只要操作系统和硬件设备没问题,数据迟早会写入,但在一定特定情况下,一定需要确保数据写入硬盘,则可以调用该方法。

FileInputStream

FileInputStream的主要构造方法有:

public FileInputStream(String name) throws FileNotFoundException
public FileInputStream(File file) throws FileNotFoundException

参数与FileOutputStream类似,可以是文件路径或File对象,但必须是一个已存在的文件,不能是目录。new一个FileInputStream对象也会实际打开文件,操作系统会分配相关资源,如果文件不存在,会抛出异常FileNotFoundException,如果当前用户没有读的权限,会抛出异常SecurityException。

我们看一段简单的代码,将上面写入的文件"hello.txt"读到内存并输出:

InputStream input = new FileInputStream("hello.txt");
try{
    byte[] buf = new byte[1024];
    int bytesRead = input.read(buf);    
    String data = new String(buf, 0, bytesRead, "UTF-8");
    System.out.println(data);
}finally{
    input.close();
}

读入到的是byte数组,我们使用String的带编码参数的构造方法将其转换为了String。这段代码假定一次read调用就读到了所有内容,且假定字节长度不超过1024。为了确保读到所有内容,可以逐个字节读取直到文件结束:

int b = -1;
int bytesRead = 0;
while((b=input.read())!=-1){
    buf[bytesRead++] = (byte)b;
}

在没有缓冲的情况下逐个字节读取性能很低,可以使用批量读入且确保读到文件结尾,如下所示:

byte[] buf = new byte[1024];
int off = 0;
int bytesRead = 0;
while((bytesRead=input.read(buf, off, 1024-off ))!=-1){
    off += bytesRead;
}    
String data = new String(buf, 0, off, "UTF-8");

不过,这还是假定文件内容长度不超过一个固定的大小1024。如果不确定文件内容的长度,不希望一次性分配过大的byte数组,又希望将文件内容全部读入,怎么做呢?可以借助ByteArrayOutputStream。

ByteArrayInputStream/ByteArrayOutputStream

ByteArrayOutputStream

ByteArrayOutputStream的输出目标是一个byte数组,这个数组的长度是根据数据内容动态扩展的。它有两个构造方法:

public ByteArrayOutputStream()
public ByteArrayOutputStream(int size) 

第二个构造方法中的size指定的就是初始的数组大小,如果没有指定,长度为32。在调用write方法的过程中,如果数组大小不够,会进行扩展,扩展策略同样是指数扩展,每次至少增加一倍。

ByteArrayOutputStream有如下方法,可以方便的将数据转换为字节数组或字符串:

public synchronized byte[] toByteArray()
public synchronized String toString()
public synchronized String toString(String charsetName)

toString()方法使用系统默认编码。

ByteArrayOutputStream中的数据也可以方便的写到另一个OutputStream:

public synchronized void writeTo(OutputStream out) throws IOException

ByteArrayOutputStream还有如下额外方法:

public synchronized int size()
public synchronized void reset()

size返回当前写入的字节个数。reset重置字节个数为0,reset后,可以重用已分配的数组。

使用ByteArrayOutputStream,我们可以改进上面的读文件代码,确保将所有文件内容读入:

InputStream input = new FileInputStream("hello.txt");
try{
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    byte[] buf = new byte[1024];
    int bytesRead = 0;
    while((bytesRead=input.read(buf))!=-1){
        output.write(buf, 0, bytesRead);
    }    
    String data = output.toString("UTF-8");
    System.out.println(data);
}finally{
    input.close();
}

读入的数据先写入ByteArrayOutputStream中,读完后,再调用其toString方法获取完整数据。

ByteArrayInputStream

ByteArrayInputStream将byte数组包装为一个输入流,是一种适配器模式,它的构造方法有:

public ByteArrayInputStream(byte buf[])
public ByteArrayInputStream(byte buf[], int offset, int length)

第二个构造方法以buf中offset开始length个字节为背后的数据。ByteArrayInputStream的所有数据都在内存,支持mark/reset重复读取。

为什么要将byte数组转换为InputStream呢?这与容器类中要将数组、单个元素转换为容器接口的原因是类似的,有很多代码是以InputStream/OutputSteam为参数构建的,它们构成了一个协作体系,将byte数组转换为InputStream可以方便的参与这种体系,复用代码。

DataInputStream/DataOutputStream

上面介绍的类都只能以字节为单位读写,如何以其他类型读写呢?比如int, double。可以使用DataInputStream/DataOutputStream,它们都是装饰类。

DataOutputStream

DataOutputStream是装饰类基类FilterOutputStream的子类,FilterOutputStream是OutputStream的子类,它的构造方法是:

public FilterOutputStream(OutputStream out)

它接受一个已有的OutputStream,基本上将所有操作都代理给了它。

DataOutputStream实现了DataOutput接口,可以以各种基本类型和字符串写入数据,部分方法如下:

void writeBoolean(boolean v) throws IOException;
void writeInt(int v) throws IOException;
void writeDouble(double v) throws IOException;
void writeUTF(String s) throws IOException;

在写入时,DataOutputStream会将这些类型的数据转换为其对应的二进制字节,比如:

  • writeBoolean: 写入一个字节,如果值为true,则写入1,否则0
  • writeInt: 写入四个字节,最高位字节先写入,最低位最后写入
  • writeUTF: 将字符串的UTF-8编码字节写入,这个编码格式与标准的UTF-8编码略有不同,不过,我们不用关心这个细节。

与FilterOutputStream一样,DataOutputStream的构造方法也是接受一个已有的OutputStream:

public DataOutputStream(OutputStream out)

我们来看一个例子,保存一个学生列表到文件中,学生类的定义为:

class Student {
    String name;
    int age;
    double score;
 
    public Student(String name, int age, double score) {
         ...
    }
    ...
}    

我们省略了构造方法和getter/setter方法,学生列表内容为:

List<Student> students = Arrays.asList(new Student[]{
        new Student("张三", 18, 80.9d),
        new Student("李四", 17, 67.5d)
});

将该列表内容写到文件students.dat中的代码可以为:

public static void writeStudents(List<Student> students) throws IOException{
    DataOutputStream output = new DataOutputStream(
            new FileOutputStream("students.dat"));
    try{
        output.writeInt(students.size());
        for(Student s : students){
            output.writeUTF(s.getName());
            output.writeInt(s.getAge());
            output.writeDouble(s.getScore());
        }
    }finally{
        output.close();
    }
}

我们先写了列表的长度,然后针对每个学生、每个字段,根据其类型调用了相应的write方法。

DataInputStream

DataInputStream是装饰类基类FilterInputStream的子类,FilterInputStream是InputStream的子类。

DataInputStream实现了DataInput接口,可以以各种基本类型和字符串读取数据,部分方法如下:

boolean readBoolean() throws IOException;
int readInt() throws IOException;
double readDouble() throws IOException;
String readUTF() throws IOException;

在读取时,DataInputStream会先按字节读进来,然后转换为对应的类型。

DataInputStream的构造方法接受一个InputStream:

public DataInputStream(InputStream in)

还是以上面的学生列表为例,我们来看怎么从文件中读进来:

public static List<Student> readStudents() throws IOException{
    DataInputStream input = new DataInputStream(
            new FileInputStream("students.dat"));
    try{
        int size = input.readInt();
        List<Student> students = new ArrayList<Student>(size);
        for(int i=0; i<size; i++){
            Student s = new Student();
            s.setName(input.readUTF());
            s.setAge(input.readInt());
            s.setScore(input.readDouble());
            students.add(s);
        }
        return students;
    }finally{
        input.close();
    }
}

基本是写的逆过程,代码比较简单,就不赘述了。

使用DataInputStream/DataOutputStream读写对象,非常灵活,但比较麻烦,所以Java提供了序列化机制,我们在后续章节介绍。

BufferedInputStream/BufferedOutputStream

FileInputStream/FileOutputStream是没有缓冲的,按单个字节读写时性能比较低,虽然可以按字节数组读取以提高性能,但有时必须要按字节读写,比如上面的DataInputStream/DataOutputStream,它们包装了文件流,内部会调用文件流的单字节读写方法。怎么解决这个问题呢?方法是将文件流包装到缓冲流中。

BufferedInputStream内部有个字节数组作为缓冲区,读取时,先从这个缓冲区读,缓冲区读完了再调用包装的流读,它的构造方法有两个:

public BufferedInputStream(InputStream in)
public BufferedInputStream(InputStream in, int size)

size表示缓冲区大小,如果没有,默认值为8192。

除了提高性能,BufferedInputStream也支持mark/reset,可以重复读取。

与BufferedInputStream类似,BufferedOutputStream的构造方法也有两个,默认的缓冲区大小也是8192,它的flush方法会将缓冲区的内容写到包装的流中。

在使用FileInputStream/FileOutputStream时,应该几乎总是在它的外面包上对应的缓冲类,如下所示:

InputStream input = new BufferedInputStream(new FileInputStream("hello.txt"));
OutputStream output =  new BufferedOutputStream(new FileOutputStream("hello.txt"));

再比如:

DataOutputStream output = new DataOutputStream(
        new BufferedOutputStream(new FileOutputStream("students.dat")));
DataInputStream input = new DataInputStream(
        new BufferedInputStream(new FileInputStream("students.dat")));    

实用方法

可以看出,即使只是按二进制字节读写流,Java也包括了很多的类,虽然很灵活,但对于一些简单的需求,却需要写很多代码,实际开发中,经常需要将一些常用功能进行封装,提供更为简单的接口。下面我们提供一些实用方法,以供参考。

拷贝

拷贝输入流的内容到输出流,代码为:

public static void copy(InputStream input, 
        OutputStream output) throws IOException{
    byte[] buf = new byte[4096];
    int bytesRead = 0; 
    while((bytesRead = input.read(buf))!=-1){
        output.write(buf, 0, bytesRead);
    }
}    

将文件读入字节数组

代码为:

public static byte[] readFileToByteArray(String fileName) throws IOException{
    InputStream input = new FileInputStream(fileName);
    ByteArrayOutputStream output = new ByteArrayOutputStream();
    try{
        copy(input, output);
        return output.toByteArray();
    }finally{
        input.close();
    }
}

这个方法调用了上面的拷贝方法。

将字节数组写到文件

public static void writeByteArrayToFile(String fileName, 
        byte[] data) throws IOException{
    OutputStream output = new FileOutputStream(fileName);
    try{
        output.write(data);
    }finally{
        output.close();    
    }
}

Apache有一个类库Commons IO,里面提供了很多简单易用的方法,实际开发中,可以考虑使用。

小结

本节我们介绍了如何在Java中以二进制字节的方式读写文件,介绍了主要的流。

  • InputStream/OutputStream:是抽象基类,有很多面向流的代码,以它们为参数,比如本节介绍的copy方法。
  • FileInputStream/FileOutputStream:流的源和目的地是文件。
  • ByteArrayInputStream/ByteArrayOutputStream:源和目的地是字节数组,作为输入相当于是适配器,作为输出封装了动态数组,便于使用。
  • DataInputStream/DataOutputStream:装饰类,按基本类型和字符串读写流。
  • BufferedInputStream/BufferedOutputStream:装饰类,提供缓冲,FileInputStream/FileOutputStream一般总是应该用该类装饰。

最后,我们提供了一些实用方法,以方便常见的操作,在实际开发中,可以考虑使用专门的类库如Apache Commons IO。

本节介绍的流不适用于处理文本文件,比如,不能按行处理,没有编码的概念,下一节,就让我们来看文本文件和字符流。

原文发布于微信公众号 - 老马说编程(laoma_shuo)

原文发表时间:2016-12-01

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏菩提树下的杨过

java:利用xpath删除xml中的空节点

原始xml内容: 1 <data> 2 <a> </a> 3 <b>b1</b> 4 <awb> 5 <awbpre>123</a...

22880
来自专栏desperate633

LintCode x的n次幂题目分析代码

样例 Pow(2.1, 3) = 9.261 Pow(0, 1) = 0 Pow(1, 0) = 1

9120
来自专栏码云1024

不同方式复制文件效率的比较

34160
来自专栏noteless

[十六]JavaIO之InputStreamReader 与 OutputStreamWriter

所以可以看得出来InputStreamReader只是一个外包公司,他的活都是转包给StreamDecoder的

23310
来自专栏一个会写诗的程序员的博客

第9章 文件IO操作、正则表达式与多线程第9章 文件IO操作、正则表达式与多线程

我们在《第6章 扩展函数与属性》中已经介绍过Kotlin中的类扩展的特性。使用Kotlin的扩展函数功能,我们可以直接为 String 类实现一个 inc() ...

12630
来自专栏aCloudDeveloper

Java中Properties类的操作

    知识学而不用,就等于没用,到真正用到的时候还得重新再学。最近在看几款开源模拟器的源码,里面涉及到了很多关于Properties类的引用,由于Java已经...

242100
来自专栏闻道于事

Java I/O流输入输出,序列化,NIO,NIO.2

31430
来自专栏pangguoming

Java编程最差实践(常见编程错误典范)

转载自  http://macrochen.iteye.com/blog/1393502

9720
来自专栏用户3030674的专栏

java写文件读写操作(IO流,字节流)

/** * IO流的数据写入和读取 * 在本质上是用的FileReader("c:text.txt")或FileWriter("c:text2.txt")...

1.1K10
来自专栏Ryan Miao

Java XML解析工具 dom4j介绍及使用实例

Java XML解析工具 dom4j介绍及使用实例 dom4j介绍   dom4j的项目地址:http://sourceforge.net/projects/d...

42860

扫码关注云+社区

领取腾讯云代金券