Java I/O--字节流
流是一组有顺序的，有起点和终点的字节集合，是对数据传输的总称或抽象。向内存写入的是输入流，从内存读出的是输出流。java
- InputStream
在 InputStream 类中，方法 read() 提供了三种从流中读数据的方法：数组
int read()：从输入流中读一个字节，造成一个0~255之间的整数返回（是一个抽象方法）app
int read(byte b[])：从输入流中读取必定数量的字节，并将其存储在缓冲区数组 b 中。dom
int read(byte b[],int off,int len)：从输入流中读取长度为 len 的数据，写入数组 b 中从索引 off 开始的位置，并返回读取得字节数。设计
对于这三个方法，若返回-1，代表流结束，不然，返回实际读取的字符数。code
- OutputStream
代码示例：orm
package ioTest;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
public class Test {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
Test t = new Test();
System.out.println("请输入字符：");
t.copy(System.in,System.out);
}
private void copy(InputStream in, OutputStream out) throws IOException {
byte[] buf = new byte[3];
//从InputStream读取两个字节，存储到缓冲区数组buf里
int len = in.read(buf);
System.out.println("=="+len);
//字节流的结尾标志是-1
while(len != -1){
//将缓冲区数组buf中偏移量从0开始的len个字节写入输出流
out.write(buf, 0, len);
len = in.read(buf);
System.out.println("--"+len);
}
}
}
- 文件流
java.io 包中所提供的文件操做类包括：对象
一、用于读写本地文件系统中的文件：FileInputStream 和 FileOutputStream继承
二、描述本地文件系统中的文件或目录：File、FileDescriptor 和 FilenameFilter索引
三、提供对本地文件系统中文件的随机访问支持：RandomAccessFile
FileInputStream 类用于打开一个输入文件，若要打开的文件不存在，则会产生异常 FileNotFoundException，这是一个非运行时异常，必须捕获或声明抛弃；
FileOutputStream 类用来打开一个输出文件，若要打开的文件不存在，则会建立一个新的文件，不然原文件的内容会被新写入的内容所覆盖；
在进行文件的读/写操做时，会产生非运行时异常 IOException，必须捕获或声明抛弃（其余的输入/输出流处理时也一样须要进行输入/输出异常处理）。
构造方法：
//打开一个以 f 描述的文件做为输入 FileInputStream(File f) //打开一个文件路径名为 name 的文件做为输入 FileInputStream(String name) //建立一个以 f 描述的文件做为输出 //若是文件存在，则其内容被清空 FileOutputStream(File f) //建立一个文件路径名为 name 的文件做为输出 //文件若是已经存在，则其内容被清空 FileOutputStream(String name) //建立一个文件路径名为 name 的文件做为输出 //文件若是已经存在，则在该输出上输出的内容被接到原有内容以后 FileOutputStream(String name, boolean append)
代码示例：
package ioTest;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileInputOutTest {
/**
* @param args
*/
public static void main(String[] args) {
try {
File inFile = new File("d:/494389/Desktop/2.txt");
File outFile = new File("3.txt");
FileInputStream fis = new FileInputStream(inFile);
FileOutputStream fos = new FileOutputStream(outFile);
int b;
while((b = fis.read())!= -1){
fos.write(b);
}
fis.close();
fos.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
- 缓冲流
类BufferedInputStream和BufferedOutputStream实现了带缓冲的过滤流，提供缓冲机制，把任意IO流”捆绑“到缓冲流上，可提升IO流的读取效率。
BufferedInputStream 的数据成员Buf是一个位数组，默认2048字节。BufferedInputStream 会首先尽可能将 buf 填满。当使用 read ()方法时，先读取 buf 中的数据，当 buf 中的数据不满时，BufferedInputStream 才会再实现给定的 InputStream 对象的 read() 方法，从源中提取数据。
BufferedOutputStream 的数据成员 buf 是一个位数组，默认为512字节。当使用 write() 方法写出数据时，会先将数据写至到buf 中，当 buf 已满时才会实现给定的 OutputStream 对象的 write() 方法，将 buf 数据写至目的地。
构造方法：
//[ ]里的内容表明选填
BufferedInputStream(InputStream in [, int size])
BufferedOutputStream(OutputStream out [, int size])
BufferedInputStream 缓冲流和文件流相接，代码示例：
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];
//将缓冲流读取256个字节，若是长度不满256，则读取实际长度，而后存储到bArray这个字节数组
len = bin.read(bArray); //len 中获得的是实际读取的长度，bArray 中获得的是数据
对于 BufferedOutputStream，只有缓冲区满时，才会将数据真正送到输出流，但可使用 flush() 方法人为地将还没有填满的缓冲区中的数据写出。
看下面代码：
public void copy(InputStream in, OutputStream out) throw 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等基本数据类型。
数据流类 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();
}
}
}
- 标准流System.in
System.in做为字节输入流类InputStream的对象实现标准输入，经过read(）方法从键盘接受数据。
int read()
int read(byte b[])
int read(byte b[],int offset,int len)
import java.io.IOException;
public class StdInput{
public static void main(String[] args) throws IOException
{
System.out.println("input:");
byte b[]=new byte[512];
int count=System.in.read(b);
System.out.println("Output");
for(int i=0;i<count;i++)
{
System.out.print(b[i]+" ");
}
System.out.println();
for(int i=0;i<count;i++)
{
System.out.print((byte)b[i]+" ");
}
System.out.println("count="+count);
}
}
输出结果：
input: abcd Output 97 98 99 100 13 10 97 98 99 100 13 10 count=6
缘由分析：
一、从键盘输入4个字符abcd并按Enter键，保存在缓冲区b中的元素个数为6，Enter占用最后两个字节。
二、其read()方法是读取字节和字节数组，不能直接获得须要的数据（如整型，浮点型）。使用Scanner类对标准输入流System.in的数据进行解析，能够获得须要的数据。
- 标准流System.out
System.out做为打印流PrintStream的对象实现标准输出，其定义了print和println方法，支持将Java的任意基本类型做为参数。
public void print(int i); public void println(int i); //JDK5.0后的版本对PrintStream类进行了扩充，支持数据的格式化输出，增长了printf（）方法。 public PrintStream printf(String format,Object…args) public PrintStream printf(Locale 1,String format,Object…args)
- 标准流System.err
System.err也是从 PrintStream 中继承而来，把错误信息送到缺省的显示设备。
- 内存读写流
为了支持在内存上的 I/O，java.io 中提供了类：ByteArrayInputStream、ByteArrayOutputStream 和 StringBufferInputStream
一、ByteArrayInputStream 能够从指定的字节数组中读取数据。
二、ByteArrayOutputStream 中提供了缓冲区能够存放数据（缓冲区大小能够在构造方法中设定，缺省为 32），能够用 write() 方法向其中写入数据，而后用 toByteArray() 方法将缓冲区中的有效字节写到 字节数组中去。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);
}