java io byte_java.io 字节流
java.io 字节流
基类 InputStream 和 OutputStream
字节流主要操作 byte 类型数据，以 byte 数组为准，java 中每一种字节流的基本功能依赖于基本类 InputStream 和 Outputstream，他们是抽象类，不能直接使用。字节流能处理所有类型的数据(如图片、avi 等)。
InputStream
InputStream 是所有表示字节输入流的基类，继承它的子类要重新定义其中所有定义的抽象方法.InputStream是从装置来源地读取数据的抽象表示，例如System中的标准输入流in对象就是一个InputStream类型的实例。
我们先来看看InputStream类的方法：
方法
说明
read()throws IOException
从输入流中读取数据的下一个字节(抽象方法)
skip(long n) throws IOException
跳过和丢弃此输入流中数据的n个字节
available() throws IOException
返回流中可用字节数
mark(int readlimit) throws IOException
在此输入流中标记当前的位置
reset() throws IOException
将此流重新定位到最后一次对此输入流调用mark方法时的位置
markSupport() throws IOException
测试此输入流是否支持mark 和 reset 方法
close() throws IOException
关闭流
在InputStream类中，方法read()提供了三种从流中读数据的方法；
int read(): 从输入流中读一个字节，形成一个0~255之间的整数返回(是一个抽象方法)
int read(byte b[]): 从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
int read(byte b[], int off,int len): 从输入流中读取长度为len的数据，写入数组b中从索引off开始的位置，并返回读取的字节数。
对于这三个方法，若返回-1，表明流结束，否则，返回实际读取的字符数。
OutputStream
OutputStream 是所有表示字节输出流类的基类。子类要重新定义其中所定义的抽象方法，OutputStream 是用于将数据写入目的地的抽象表示。例如 System 中的标准输出流对象 out 其类型是 java.io.PrintStream，这个类是 OutputStream 的子类。
OutputStream 类方法：
方法
说明
write(int b)throws IOException
将指定的字节写入此输出流(抽象方法)
write(byte b[])throws IOException
将字节数组中的数据输出到流中
write(byte b[], int off, int len)throws IOException
将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流
flush()throws IOException
刷新此输出流并强制写出所有缓冲的输出字节
close()throws IOException
关闭流
看个例子
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class test {
/**
* 把输入流中的所有内容赋值到输出流中
* @param in
* @param out
* @throws IOException
*/
public void copy(InputStream in, OutputStream out) throws IOException {
byte[] buf = new byte[4096];
int len = in.read(buf);
//read 是一个字节一个字节地读，字节流的结尾标志是-1
while (len != -1){
out.write(buf, 0, len);
len = in.read(buf);
}
}
public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
test t = new test();
System.out.println("输入字符：");
t.copy(System.in, System.out);
}
}
文件流
在 I/O 处理中，最常见的就是对文件的操作。java.io 包中所提供的文件操作类包括
用于读写本地文件系统中的文件：FileInputStream 和 FileOutputStream
描述本地文件系统中的文件或目录： File、FileDescriptor 和 FilenameFilter
提供对本地文件系统中文件的随机访问支持：RandomAccessFile
今天我们来学习文件流的FileInputStream 和 FileOutputStream
FileInputStream 类用于打开一个输入文件，若要打开的文件不存在，则会创建一个新的文件，否则原文件的内容会被新写入的内容所覆盖；
在进行文件的读/写操作时，会产生非运行时异常IOException，必须捕获或声明抛弃(其他的输入/输出流处理时也同样需要进行输入/输出异常处理)
文件构造方法:
//打开一个以 f 描述的文件作为输入
FileInputStream(File f)
//打开一个文件路径名为 name 的文件作为输入
FileInputStream(String name)
//创建一个以 f 描述的文件作为输出
//如果文件存在，则其内容被清空
FileOutputStream(File f)
//创建一个文件路径名为 name 的文件作为输出
//文件如果已经存在，则其内容被清空
FileOutputStream(String name)
//创建一个文件路径名为 name 的文件作为输出
//文件如果已经存在，则在该输出上输出的内容被接到原有内容之后
FileOutputStream(String name, boolean append)
示例代码 ：
File f1 = new File("file1.txt");
File f2 = new File("file2.txt");
FileInputStream in = new FileInputStream(f1);
FileOutputStream out = new FileOutputStream(f2);
输入流的参数是用于指定输入的文件名,输出流的参数则是用于指定输出的文件名
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class test {
public static void main(String[] args) {
try {
//inFile 作为输入流的数据文件必须存在，否则抛出异常
File inFile = new File("/Users/mumutongxue/Documents/file1.txt");
//file2.txt 没有，系统可以创建，在 workspace 的 Test 项目下可以找到
File outFile = new File("file2.txt");
FileInputStream fis = new FileInputStream(inFile);
FileOutputStream fos = new FileOutputStream(outFile);
int c;
while((c = fis.read()) != -1){
fos.write(c);
}
//打开了文件一定要记着关，释放系统资源
fis.close();
fos.close();
}catch(FileNotFoundException e) {
System.out.println("FileStreamsTest:" + e);
}catch(IOException e){
System.err.println("FileStreamTest:" + e);
}
}
}
缓冲流
类BufferedInputStream 和 BufferedOutoutStream 实现了带缓冲的过滤流，它提供了缓冲机制，把任意的I/O流“捆绑”到缓冲流上，可以提高I/O流的读取效率
在初始化时，除了要指定所连接的I/O流之外，还可以指定缓冲区的大小，缺省时是用32字节大小的缓冲区；最优的缓冲区大小以来于主机操作系统、可使用的内存空间以及机器的配置等；一般缓冲区的大小为内存页或磁盘块等的整数倍
BufferedInputStream 的数据成员buf是一个位数组，默认为2048字节，当读取数据来源时例如文件，BufferedInputStream 会尽量将buf填满。当使用read() 方法时，实际上是先读取buf中的数据，而不是直接对数据来源作读取。当buf中的数据不足时，BufferedInputStream 才会再实现给定的InputStream对象的read() 方法，从指定的装置中提取数据。
BufferedInputStream 的数据成员 buf 是一位数组，默认为512字节。当使用write() 方法写入数据时，实际上会先将数据写至buf中，当buf已满时才会实现给定的OutputStream 对象的write() 方法，将buf数据写至目的地，而不是每次都对目的地作写入的动作。
构造方法：
//[ ] 里的内容代表选填
BufferedInputStream(InputStream in [, int size])
BufferedOutputStream(OutputStream out [, int size])
举个例子，将缓冲流与文件流相接
FileInputStream in = new FileInputStream("file.txt");
FileOutputStream out = new FileOutputStream("file2.txt");
//设置输入缓冲区大小为 256 字节
BufferedInputStream bin = new BufferedInputStream(in,256)
BufferedOutputStream bout = new BufferedOutputStream(out,256)
int len;
byte bArray[] = new byte[256];
len = bin.read(bArray); //len 中得到的是实际读取的长度，bArray 中得到的是数据
对于 BufferedOutputStream，只有缓冲区满时，才会将数据真正送到输出流，但可以使用 flush() 方法人为地将尚未填满的缓冲区中的数据送出。
例如方法copy();
public void copy(InputStream in, OutputStream out) throws IOException {
out = new BufferedOutputStream(out, 4096);
byte[] buf = new byte[4096];
int len = in.read(buf);
while (len != -1) {
out.write(buf, 0, len);
len = in.read(buf);
}
//最后一次读取得数据可能不到 4096 字节
out.flush();
}
数据流
接口 DataInput 和 DataOutput，设计了一种较为高级的数据输入输出方式：除了可处理字节和字节数组外，还可以处理 int、float、boolean 等基本数据类型，这些数据在文件中的表示方式和它们在内存中的一样，无须转换，如 read(), readInt(), readByte()...; write(), writeChar(), writeBoolean()... 此外，还可以用 readLine() 方法读取一行信息。
方法 ：
方法
返回值
说明
readBoolean()
boolean
readByte()
byte
readShort()
short
readChar()
char
readInt()
int
readLong()
long
readDouble()
double
readFloat()
float
readUnsignedByte()
int
readUnsignedShort()
int
readFunlly(byte[] b)
void
从输入流中读取一些字节，并将它们存储在缓冲区数组b中
reaFully(byte[] b, int off, int len)
void
从输入流中读取len个字节
skipBytes(int n)
int
与InputStream.skip 等价
readUTF()
String
按照UTF-8形式从输入中读取字符串
readLine()
String
按回车(\r)换行(\n)为分隔符读取一行字符串，不完全支持UNICODE
writeBoolean(boolean v)
void
writeByte(int v)
void
writeShort(int v)
void
writeChar(int v)
void
writeInt(int v)
void
writeLong(long v)
void
writeFloat(float v)
void
writeDouble(double v)
void
write(byte[] b)
void
与OutputStream.write 同义
write(byte[] b,int off,int len)
void
与OutputStream.write 同义
write(int b)
void
与OutputStream.write 同义
writeBytes(String s)
void
只输出每个字符的低 8 位；不完全支持 UNICODE
writeChars(String s)
void
每个字符在输出中都占两个字节
数据流类 DataInputStream 和 DataOutputStream 的处理对象除了是字节或字节数组外，还可以实现对文件的不同数据类型的读写；
分别实现了DataInput 和 DataOutput 接口
在提供字节流的读写手段同时，以统一的形式向输入流中写入boolean，int，long，double 等基本数据类型，并可以再次把基本数据类型的值取回来
提供了字符串读写的手段
数据流可以连接一个已经建立好的数据对象，例如网络连接、文件等。数据流可以通过如下方式建立；
FileInputStream fis = new FileInputStream("file1.txt");
FileOutputStream fos = new FileOutputStream("file2.txt");
DataInputStream dis = new DataInputStream(fis);
DataOutputStream dos = new DataOutputStream(fos);
接下来我们通过具体的代码，看一看它的用法吧；
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class DataStream {
public static void main(String[] args) throws IOException{
// TODO Auto-generated method stub
//向文件 a.txt 写入
FileOutputStream fos = new FileOutputStream("a.txt");
DataOutputStream dos = new DataOutputStream(fos);
try {
dos.writeBoolean(true);
dos.writeByte((byte)123);
dos.writeChar('J');
dos.writeDouble(3.1415926);
dos.writeFloat(2.122f);
dos.writeInt(123);
}
finally {
dos.close();
}
//从文件 a.txt 读出
FileInputStream fis = new FileInputStream("a.txt");
DataInputStream dis = new DataInputStream(fis);
try {
System.out.println("\t" + dis.readBoolean());
System.out.println("\t" + dis.readByte());
System.out.println("\t" + dis.readChar());
System.out.println("\t" + dis.readDouble());
System.out.println("\t" + dis.readFloat());
System.out.println("\t" + dis.readInt());
}
finally {
dis.close();
}
}
}
标准流、内存读写流、顺序输入流
标准流
语言包 java.lang 中的System类管理标准输入/输出流和错误流
System.in 从InputStream中继承而来，用于从标准输入设备中获取输入数据(通常是键盘)
System.out 从PrintStream 中继承而来，把输入送到缺省的显示设备(通常是显示器)
System.err 也是从PrintStream中继承而来，把错误信息送到缺省的显示设备(通常是显示器)
每当mian方法被执行时，就会自动生产上述三个对象。这里就不再写代码验证了。
内存读写流
为了支持在内存上的I/O，java.io 中提供了类；ByteArrayInputStream、ByteArrayOutputStream 和 StringBufferInputStream
ByteArrayInputStream 可以从指定的字节数组中读取数据
ByteArrayOutputStream 中提供了 缓冲区可以存放数据(缓冲区大小可以在构造方法中设定，缺省为32)，可以用write() 方法 向其中写入数据，然后用toByArray() 方法将缓冲区中的有效字节写到字节数组中去。size() 方法可以知道写入的字节数； reset() 可以丢弃所有内容
StringBufferInputStream 与 ByteArrayInputStream 相类似，不同点在于它是从字符缓冲区 StringBuffer 中读取 16位的 Unicode 数据，而不是 8 位的字节数据(已被StringReader取代)
这里只做简要的介绍，有兴趣的同学可以查看一下这些类里具体的方法。
顺序输入流
java.io 中提供了类SequenceInputStream, 使应用程序可以将几个输入流顺序连接起来。顺序输入流提供了将多个不同的输入流统一为一个输入流的功能，这使得程序可能变得更加简洁
例如：
FileInputStream f1,f2;
String s;
f1 = new FileInputStream("file1.txt");
f2 = new FileInputStream("file2.txt");
SequenceInputStream fs = new SequenceInputStream(f1,f2);
DataInputeStream ds = new DataInputStream(fs);
while((s = ds.readLine()) != null) {
System.out.println(s);
}
参考连接