Java IO_002.InputStream与OutputStream--字节流对数据的操作（读取与写入）

提示：扫一扫查出行
【扫一扫了解最新限行尾号】
复制提示

Java IO之FileInputStream与FileOutputStream对象常用操作

涉及到文件(非文件夹）内容的操作，除了要用到File(见之前文章），另外就必须用到输入流或输出流。

输入流：该流处理时，数据由外部流向程序（内存），一般指代“读取数据”，更清晰点地说：从外部读取数据到内存中。

输出流：该流处理时，数据由程序（内存）流向外部，一般指代“写入数据”，更清晰点地说：将数据从内存写入到外部。

如果要操作字节（比如Soket,字节数据、图片、视屏等非纯文本文件），则采用字节输入流与字节输出流。在Java中，可使用： InputStream 与 OutputStream 及其子类。

如果要操作字符（比如字符数据、纯文本文件），则采用字符输入流与字符输出流。在Java中，可使用：Reader 与 Writer 及其子类。

对字节的操作，采用 InputStream与OutputStream。它们的为声明分别为：

public abstract class InputStream implements Closeable

public abstract class OutputStream implements Closeable, Flushable

它们都是抽象类，需要由具体子类进行实例化。

InputStream主要子类有：

AudioInputStream：读取音像媒体的字节流。
ByteArrayInputStream：读取字节数组的字节流。
FileInputStream：读取文件的字节流。
FilterInputStream：过滤器输入流，用于装饰。其子类有：PushbackInputStream , BufferedInputStream
ObjectInputStream：读取序列化的对象的字节流。
PipedInputStream：读取管道的字节流。
SequenceInputStream：读取序列的字节流。
PushbackInputStream：读取可以推回的字节流。继承自：FilterInputStream
BufferedInputStream：读取有缓存效果的字节流。继承自：FilterInputStream
StringBufferInputStream：读取字符缓冲的字节流。已过时，不作介绍。

常用的有FileInputStream，我们将以它为例。

OutputStream主要子类有：

ByteArrayOutputStream：将字节写入到字节数组
FileOutputStream：将字节写入到文件
FilterOutputStream：过滤器输出流，用于装饰
ObjectOutputStream：将字节写入到序列化对象
PipedOutputStream：将字节写入管道

常用的有FileOutputStream，我们将以它为例。

InputStream与OutputStream的方法

InputStream字节输入流，其主要方法有：

int available()：获取可用的字节总长度。返回int类型，该方法只要用于获取可被后续线程使用的流的长度，并且随已读取字节的变化而变化（见下边例子），特别是用它来表示文件大小时并不可靠（因为特大文件的字节长度可能是long字节。对于文件字节数，可以使用file.length()来代替)。
void close()：释放流对象。用于关闭资源。close()后无法进行read及skip等操作。所以一般在流操作结束后进行close()调用。
void mark(int readlimit)：标记流的位置。系统不一定支持。不推荐使用。
booleanmarkSupported()：检测是否支持流位置标记。（mark方法与reset方法在其支持下才可用。一般能不用则不用此3个方法）
abstract int read()：从流中读取一个字节，如果没有数据，返回-1。
intread(byte[] b)：从流中读取字节，并将数据存入到指定的字节数组中，读取的字节数为指定数组的长度。如果没有数据，返回-1。
intread(byte[] b, int off, int len)：从流中读取字节，并将数据存入到指定的字节数组中，读取的字节数为len，存入时从数组off开始存。如果没有数据，返回-1。
void reset()：从新设置流的开始。系统不一定支持。不推荐使用。
long skip(long n)：跳过指定数目字节。可以是正数负数或0（对于文件流来说，该方法已被重载，可以用来解决系统不支持reset()问题。负数是往回转跳，0不进行转跳。）。

输入字节流InputStream用于“读取”，其中最常用的方法是：read(), read(byte[] b), read(byte[] b, int off, int len)

综合测试代码：

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream; public class File001 {
public static void main(String[] args) throws IOException {
File file = new File("g:/java2019/file.txt");//文件内容：abc //打开流
InputStream is = new FileInputStream(file);
long len = file.length();
System.out.println("available:"+is.available());
System.out.println(is.read());//读取第一个字节:a
System.out.println(is.read());//读取第一个字节:b
System.out.println(is.read());//读取第一个字节:c
System.out.println(is.read());//-1
System.out.println(is.read());//-1
System.out.println(is.read());//-1 System.out.println("available:"+is.available()); if(is.markSupported()){
System.out.println("IO支持标记，可以进行重定位到开头标记处。");
is.reset();
}else{
System.out.println("IO不支持标记，不可以进行重定位到开头标记处。使用回跳处理。");
is.skip(-len);
} for(int i=0;(i=is.read())!=-1;){
System.out.println(i);
} is.skip(-len); byte[] b3 = new byte[3];
int len2 = is.read(b3,0,1);//从流中读取1个字节，存在b3字节数组中，从b3的0位置开始存。
System.out.println("读取长度为：:"+len2);
System.out.println("first byte:"+b3[0]); is.skip(-1);
is.read(b3);//从流中读取b3字节数组对应大小的字节存入b3中。
for(byte b : b3){
System.out.println(b);
} //关闭流
is.close();
} }

输出：

available:3
97
98
99
-1
-1
-1
available:0
IO不支持标记，不可以进行重定位到开头标记处。使用回跳处理。
97
98
99
读取长度为：:1
first byte:97
97
98
99

说明：

FileInputStream是文件字节输入流。其构造方法有：FileInputStream(File file) ，FileInputStream(String name)， FileInputStream(FileDescriptor fdObj)。其中FileInputStream(String name)最为常用，它其实调用的也是FileInputStream(File file)。如果没有什么获取文件指定大小（需要用到File对象的length()方法：其实也可以通过name再构造一个File对象），推荐使用FileInputStream(String name)，它最为简洁。
FileInputStream对象一旦进行实例化，就会立刻进行文件的打开，所以如果文件不存在，会抛出FileNotFoundException异常（属于IOException）。所以该流使用结束后必须调用close()方法来进行关闭，进行资源释放。
read()方法一次从文件输入流中读取一个字节，并返回int类型，并不返回byte类型，因为具体读取到的字节属于属于-128到127（占8位），直接返回的话，难以判定是读取到的字节数是-1，还是读取到结尾了，可能造成读取中断问题。所以返回int的话，会将8位的-1转化为32位int类型的255，避免冲突。read(byte[] b)以及read(byte[] b, int off, int len)方法一次读取数个字节，返回读取到的字节数，读取到结尾时返回-1。
read()方法是阻塞的。即线程运行到read()处，该线程必须等待read()完成才能进行该线程后续代码执行操作。在网络通信状态不稳定或者socket等待时，往往配合多线程进行处理。read(byte[] b)以及read(byte[] b, int off, int len)同理。
对于文件流的读取，推荐使用read(byte[] b, int off, int len)来处理，可以减少读取次数，取得高效。
for(int i=0;(i=is.read())!=-1;){} 块可用于循环读取输入流的字节，当读取到的结尾时返回-1。也可以用int i=0;while((i=is.read())!=-1){}块，效果同样（只是多了一行）。

OutputStream字节输入流，其主要方法有：

void close()：释放流对象。用于关闭资源。close()后无法进行write及flush等操作。所以一般在流操作结束后进行close()调用。
void flush()：刷新输出流，以便数据能够完全被写入。
void write(byte[] b)：一次写入所给的字节数组的所有数据。
void write(byte[] b, int off, int len)：一次写入所给的字节数组从off位置开始，长度为len的数据。
abstract void write(int b)：一次写入一个字节。

输出字节流InputStream用于“写入”，其中最常用的方法是：write(byte[] b) , write(byte[] b, int off, int len) , write(int b)

测试代码：

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream; public class File002 {
public static void main(String[] args) throws IOException {
String filepath = "G:/java2019/file123.txt";
//打开文件构造输出流，如果文件不存在则进行创建，如果文件上级路径不存在，则抛出FileNotFoundException
OutputStream os = new FileOutputStream(filepath); os.write(97);//写入a
os.write(98);//写入b
os.write('c');//写入c byte[] b = new byte[]{97,98,99}; os.write(b); os.write(b, 2, 1);
os.write(b, 1, 1);
os.write(b, 0, 1); //关闭输出流
os.close(); //再次打开，需要再次构造。在文件内容后边进行写入。
os = new FileOutputStream(filepath, true);
String LINE = System.getProperty("line.separator");
byte[] bLine = null;
if(LINE.equals("\r")){
bLine = new byte[]{10};
}else if(LINE.equals("\n")){
bLine = new byte[]{13};
}else{// LINE.equals("\r\n")
bLine = new byte[]{10,13};
} //输出换行
os.write(bLine); os.write(new byte[]{'A','B','C'}); //关闭输出流
os.close(); }
}

文件内容：

abcabccba

(这时是空白行）
ABC

说明：

FileOutputStream是文件字节输出流。其构造方法有：FileOutputStream(File file) ，FileOutputStream(File file, boolean append) ，FileOutputStream(String name)，FileOutputStream(String name, boolean append)， FileOutputStream(FileDescriptor fdObj)。其中FileOutputStream(String name)及FileOutputStream(String name, boolean append)最为常用，它其实调用的也是FileOutputStream(File file)或FileOutputStream(File file, boolean append)。如果没有什么获取文件指定大小（需要用到File对象的length()方法：其实也可以通过name再构造一个File对象），推荐使用FileoutputStream(String name)及FileOutputStream(String name, boolean append)，它最为简洁。boolean类型的参数append指明对文件内容的写入是否要接在文件末尾，如果不想覆盖原来文件的内容，则需要使用FileOutputStream(name,true)，因为默认情况下是false(会覆盖)。
FileOutputStream对象一旦进行实例化，就会立刻进行文件的打开，所以如果文件不存在，会自动创建，如果文件所在路径（上级目录）不存在，会抛出FileNotFoundException异常（属于IOException）。所以该流使用结束后必须调用close()方法来进行关闭，进行资源释放。
write(int b)方法一次向文件输出流中写入一个字节，int类型会最终转化为byte类型。write(byte[] b)以及write(byte[] b, int off, int len)方法一次写入数个字节。
write()方法是不会阻塞的。wrie(byte[] b)以及write(byte[] b, int off, int len)同理。
对于文件流的写入，推荐使用write(byte[] b, int off, int len)来处理，可以减少写入次数，取得高效。
byte[] b=new byte[1024*8];int len=0;while((len=is.read(b))!=-1){os.write(b,0,len);}块可以配合读取、写入操作，进行高效的文件的复制。

高效的字节文件复制操作代码：

IO中，要处理具体的异常，可以这样：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; public class File004 {
public static void main(String[] args) {
String from = "G:/java2019/file.txt";
String to = "G:/java2019/file2.txt";
InputStream is = null;
OutputStream os = null;
try {
is = new FileInputStream(from);
os = new FileOutputStream(to); byte[] b = new byte[1024 * 8];
int len = 0;
while ((len = is.read(b)) != -1) {
os.write(b, 0, len);
} } catch (IOException e) {
e.printStackTrace();
} finally {
if (is != null) {
try {
is.close();
} catch (IOException e) {
e.printStackTrace();
}
} if (os != null) {
try {
os.close();
} catch (IOException e) {
e.printStackTrace();
}
}
} }
}

不过这样很烦索，如果在JDK1.7及以上版本，可以使用try-resource改进,代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; public class File005 {
public static void main(String[] args) {
String from = "G:/java2019/file.txt";
String to = "G:/java2019/file2.txt";
try (InputStream is = new FileInputStream(from);OutputStream os = new FileOutputStream(to);) {
byte[] b = new byte[1024 * 8];
int len = 0;
while ((len = is.read(b)) != -1) {
os.write(b, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} }
}

JAVA也提供了比较高效的内置缓存流：BufferedInputStream及BufferedOutputStream。其内置缓冲区大小默认为1024*8（如果需要改变，可以在构造的时候传入其它值）。它们直接由InputSteam及OutputStream构造，所有方法都与InputStream及OutputStream相同。不过不同的是对于OutputStream,其write()实际上是写入到缓冲区，然后判断缓冲区是否满了，如果满了则使用flush()刷新缓冲区，同时写入文件，如果最后一次的时候刚才未满，则不能保证是否写入，这样会造成断尾了。可以使用其flush()方法，或者当进行close()的时候，也会进行缓冲区的刷新及文件的写入（不过对于JDK1.7及以上版本使用try-resource处理异常的情况下，会自动进行close()，不太需要担心）

BufferedInputStream构造器：

public BufferedInputStream(InputStream in)：以字节输入流构造缓冲输入流，默认1024*8的缓冲区，常用。

public BufferedInputStream(InputStream in, int size) ：以字节输入流构造缓冲输入流，缓冲区大小由size指定。

BufferedOutputStream构造器：

public BufferedOutputStream(OutputStream out)：以字节输出流构造缓冲输出流，默认1024*8的缓冲区，常用。

public BufferedOutputStream(OutputStream out, int size)：以字节输出流构造缓冲输出流，缓冲区大小由size指定。

测试代码：

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException; public class File006 {
public static void main(String[] args) {
String from = "G:/java2019/file.txt";
String to = "G:/java2019/file2.txt";
try (BufferedInputStream is = new BufferedInputStream(new FileInputStream(from));
BufferedOutputStream os = new BufferedOutputStream(new FileOutputStream(to));) {
byte[] b = new byte[1024 * 8];
int len = 0;
while ((len = is.read(b)) != -1) {
os.write(b, 0, len);
}
} catch (IOException e) {
e.printStackTrace();
} }
}

说明：

可以知道，使用字节缓冲流处理输入输出的时候，跟之前的代码相比，只需要改变构造器就可以，其它代码可以一概不变，因为缓冲字节流使用的是字节流对象构造并且直接重写其所有方法。

要进行高效的字节流处理，一方面可以使用缓冲字节流，另一方面可以使用自己写的高效处理方法（同上边“字节文件的复制”）。推荐使用后者，更灵活，更高效。

除了InputStream与OutputStream的应用中，除了FileInputStream与FileOutputStream常用来处理文件，也可以处理字节数组，数据，序列对象，管道，字符缓冲等。

ByteArrayInputStream可以从字节数组中获取字节输入流数据，ByteArrayOutputStream可以将数据写入字节数组输出流。代码：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream; public class File007 {
public static void main(String[] args) {
byte[] b = new byte[] {97,98,99};
try(InputStream is = new ByteArrayInputStream(b); OutputStream os = new ByteArrayOutputStream()){
int i = 0;
while((i=is.read())!=-1){
os.write(i);
} System.out.println(os.toString());
} catch (IOException e) {
e.printStackTrace();
} }
}

DataInputStream可以从int,long,float,double,char,byte[],boolean等中获取字节输入流的数据，DataOutputStream可以将int,long,float,double,char,byte[],boolean等数据写入字节输出流。代码：

public class File007 {
public static void main(String[] args) {
byte[] b = new byte[] { 97, 98, 99, 100 };
try (DataInputStream is = new DataInputStream(new ByteArrayInputStream(b));
DataOutputStream os = new DataOutputStream(new FileOutputStream("g:/java2019/file.txt"))) {
char c = 0;
c = is.readChar();// 读取两个字节
os.writeChar(c);// 写入两个字节
System.out.println(c);
c = is.readChar();
os.writeChar(c);
System.out.println(c);
} catch (IOException e) {
e.printStackTrace();
} }
}

输出：

慢

捤

文件内容：abcd

ObjectInputStream可以从已经序列化的对象（对象相对应的某种格式化的文件）等中获取字节输入流的数据，DataOutputStream可以将序列化的对象（实现Serialiazable接口的对象）写入字节输出流（最终变成相应格式文件数据）。代码：

测试代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable; public class File008 {
public static void main(String[] args) {
try (ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("g:/java2019/file.txt"))) {
User user = new User();
user.setId(1);
user.setName("dreamyoung");
os.writeObject(user);
} catch (IOException e) {
e.printStackTrace();
} try(ObjectInputStream is = new ObjectInputStream(new FileInputStream("g:/java2019/file.txt"))){
try {
User user = (User)is.readObject();
System.out.println(user);
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
} catch (IOException e) {
e.printStackTrace();
} }
} class User implements Serializable{
private static final long serialVersionUID = 1L;
private int id;
private String name;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
} @Override
public String toString() {
return "User [id=" + id + ", name=" + name + "]";
}
}

输出：

User [id=1, name=dreamyoung]

文件内容：

 sr User I idL namet Ljava/lang/String;xp t

dreamyoung

说明：

对象序列化通常指的是将对象数据（不是类）保存到文件，其格式由JVM自动生成。而反序列化指的是从文件中读取数据生成对象。
要序列化的对象必须实现Serializable接口（通常还可以添加serialVersionUID），不然会出现 NotSerializableException 异常。

SequenceInputStream可以从已经一个或多个的输入流中顺序获取字节输入流的数据。需要注意的是，没有SequenceOutputStream。代码：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.SequenceInputStream; public class File009 {
public static void main(String[] args) {
//通过顺序流，将两个文件内容写入一个新文件
try (FileInputStream fis1 = new FileInputStream("g:/java2019/file1.txt");//文件内容：111
FileInputStream fis2 = new FileInputStream("g:/java2019/file2.txt");//文件内容：222
SequenceInputStream is = new SequenceInputStream(fis1, fis2);
FileOutputStream fos = new FileOutputStream("g:/java2019/file3.txt")) {
byte[] b = new byte[1024];
int len = 0;
while((len=is.read(b))!=-1){
fos.write(b,0,len);
}
} catch (IOException e) {
e.printStackTrace();
} }
}

文件file3.txt内容：111222

要进行文件分割，必须配套PushbackInputStream类来使用，它可以使用 unread(int b) 或 unread(byte[] b) 或 unread(byte[] b, int off, int len)将已经读取的内容返送回去，对于分割读取后超过的内容，则可以不读取。注意默认只能返回读一个字节，如果要推回的内容长度比较大，还是建议指定长度，否则会出现Push back buffer is full异常。分割文件的代码：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PushbackInputStream;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List; public class File011 {
public static void main(String[] args) {
// 没有SequenceOutputStream，要分割文件，可以采用如下手段：
File file1 = new File("g:/java2019/file1.txt");
File file2 = new File("g:/java2019/file2.txt");
File file3 = new File("g:/java2019/file3.txt"); try (FileOutputStream fos1 = new FileOutputStream(file1);
FileOutputStream fos2 = new FileOutputStream(file2);
FileOutputStream fos3 = new FileOutputStream(file3);
PushbackInputStream fis = new PushbackInputStream(new FileInputStream("g:/java2019/file.txt"), 1024)) {
// file.txt内容：111111222222333333
byte[] b = new byte[5];// 缓冲数组大小，不大于分割文件大小
int splitSize = 6;// 分割文件大小
int len = 0;
List<FileOutputStream> list = Arrays.asList(fos1, fos2, fos3);
Iterator<FileOutputStream> it = list.iterator();
while (it.hasNext()) {
FileOutputStream fos = (FileOutputStream) it.next();
while (fos.getChannel().size() < splitSize && (len = fis.read(b)) != -1) {
int left = (int) fos.getChannel().size() + len - splitSize; if (left > 0) {// 读取后会超出
for(int i=0;i<left;i++){
fis.unread(b[len-left+i]);
}
//fis.skip(-left);
fos.write(b, 0, len - left);
} else {
fos.write(b, 0, len);
} System.out.println(fos.toString() + ":" + fos.getChannel().size());
}
} } catch (IOException e) {
e.printStackTrace();
} }

输出：

java.io.FileOutputStream@15db9742:5

java.io.FileOutputStream@15db9742:6

java.io.FileOutputStream@6d06d69c:5

java.io.FileOutputStream@6d06d69c:6

java.io.FileOutputStream@7852e922:5

java.io.FileOutputStream@7852e922:6

分割后各文件内容为：

file1.txt: 111111

file2.txt: 222222

file3.txt: 333333

PipedInputStream可以从管道中获取字节输入流数据，PipedOutputStream可以将数据写入管道输出流。将在网络编程的时候进行说明，本篇暂不介绍。

总结：

FileInputStream与FileOutputStream可以以字节流形式处理文件，进行读取或写入操作。
要进行高效的字节流处理，可以使用内置的BufferedInputStream及BufferedOutputStream缓冲字节流，它可以处理各种InputStream及OutputStream(不仅仅是FileInputStream及FileOutputStream）
使用read(byte[] b, int off, int len)及write(byte[], int off, int len) 可以更高效的进行字节复制（可以替代缓冲字节流）

流