JAVA 输入输出流 IO 总结

字节流

InputStream 类系

类	功能	构造函数参数	用法
ByteArrayInputStream	以缓冲区内存为 InputStream	要从中提取出byte的那个缓冲区	作为一种数据源,把它连接到 FilterInputStream,由后者提供接口
StringBufferInputStream	以String为InputStream	需要一个String对象,实际内部用的是StringBuffer	作为一种数据源
FilterInputStream	用来读文件	一个表示文件名的String或者File,FileDescriptor 对象	作为一种数据源
PipedInputStream	从 PipedOutputStream 提取数据,实现管道功能	PipedOutputStream	一种多线程环境下的数据源
SequenceInputStream	将两个或者多个 InputStream 合并成一个 InputStream	两个 InputStream 对象或一个 InputStream 对象容器的 Enumerator	作为一种数据源
FilterInputStream	一个给 decorator 提供接口作用的抽象类	后面详解	后面详解

OutputStream 类系

类	功能	构造函数参数	用法
ByteArrayOutputStream	在内存里创建一个缓冲区,数据流写入到此缓冲区	缓冲区初始大小,可选	可通过 FilterOutputStream 为数据指定目标
FileOutputStream	将数据写入文件	一个表示文件名的String或者File,FileDescriptor 对象,可选的是否在末尾添加的参数	可通过 FilterOutputStream 为数据指定目标
PipedOutputStream	写入这个流的数据都会成为与之关联的 PipedInputStream 的数据源	可通过 FilterOutputStream 为数据指定目标
FilterOutputStream	一个给 decorator 提供接口作用的抽象类	后面详解	后面详解

字符流

Reader 类系

类名	功能描述
Reader	读字符流的抽象类
BufferedReader	从字符流中读入文本,可在必要时缓冲字符
LineNumberReader	一个能记录行数的缓冲字符输入流
InputStreamReader	从字节流到字符流的桥梁,它能读字节并转换为字符
FileReader	能方便的读字符文件

Writer 类系

类名	功能描述
Writer	写字符流的抽象类
BufferedWriter	经过字符缓冲将文本写入到一个字符输出流
PrintWriter	打印格式化对象内容到文本输出流.此类方法不抛出IO异常,但是可用 checkError检查错误
OutputStreamWriter	从字节流到字符流的桥梁,它能读字符转换为字节,然后将字节写入流
FileWriter	能方便的写字符文件

输入流和输出流的过滤

FilterInputStream 相关

类	功能	构造函数参数	用法
DataInputStream	与 DataOutputStream 结合使用,这样能以一种 可携带的方式从流中读取 primitives数据(int,char,long 等)	InputStream	包含了一套从primitives读取数据的接口
BufferedInputStream	读取数据时进行缓冲	InputStream,以及可选的缓冲区容量	本身不提供接口,只是提供一个缓冲区
LineNumberInputStream	跟踪输入流的行号	InputStream	只是加一个行号
PushbackInputStream	有一个弹压单字节的缓冲区,能把最后读到的字节再压回去	InputStream	主要用于编译器的扫描程序

FilterOutputStream 相关

类	功能	构造函数参数	用法
DataOutputStream	与 DataInputStream 配合使用,可用一种可携带的方式往流里写入 primitives数据	OutputStream	包括写入 primitives数据的接口
PrintStream	负责带格式的输出, DataOutputStream 负责数据的存储,而 PrintStream 负责数据的显示	一个 OutputStream 和可选 boolean 值,表示要不要清空换行符后面的缓冲区	OutputStream 的最终包覆层
BufferedOutputStream	输出数据时进行缓冲	OutputStream,和一个可选的缓冲区大小	本身不提供接口,只是提供一个缓冲区

字节流和字符流

• 字节流以字节为基本单位处理数据的输入输出,一般都用于二进制数据的读写,如声音,图像等.
• 字符流以字符为基本单位处理数据的输入输出,一般都用于对文本类型数据的读写,如文本文件,网络中发送的文本信息.

• 虽然文本数据也可以看做二进制数据,但一般采用字符流处理文本数据比采用字符流效率更高,也更方便.

InputStream and OutputStream

abstract  class InputStream
{

	//从数据中读入一个字节,并返回该字节,碰到流尾部返回-1
 	abstract  int read();
 	//读入一个字节数组并返回读入的字节数,碰到流尾部返回-1,最多读入b.length个字节
 	int read(byte []b);
 	//读入一个字节数组并返回实际读入的字节数,,流尾部返回-1,off 为在b中偏移量,len为最大字节数
 	int read(byte []b,int off,int lne);
 	//跳过n个字节,返回实际跳过的字节数
 	long skip(long n);
 	//返回再不阻塞的情况下可以提取的字节数
 	int available();
 	//关闭这个输入流
 	void close();
 	//在输入流的当前位置标记(并非所有流支持这个特性),如果输入流已经读入的字节多余readlimit个,允许忽略这个标记
 	void mark();
 	//返回到最后一个标记,随后对read的调用将重新读入这些字节,没有任何标记则该流不被重置
 	void reset();
 	//返回该流是否支持标记
 	boolean markSupported();
}

abstract class OutputStream
{
	//写出一个字节的数据
	abstract void write();
	void write(byte []b);
	void write(byte []b,int off,int len);
	//冲刷并关闭输出流
	void close();
	//冲刷输出流,也就是将所有缓冲数据发送到目的地.
	void flush();
}

几个接口

interface Closeable
{	
	//关闭这个Closeable,可能会抛出 IOException
	void close();
}
interface Flushable
{	
	//冲刷这个 Flushable
	void flush();
}
interface Readable
{	
	//尝试这从cb读入其可持有的char值,返回读入的char值的数量,无法继续读入返回-1
	int read(CharBuffer cb);
}
interface Appendable
{	

	Appendable  append(char c);
	//向这个Appendable追加指定码元或指定序列所有码元,返回this
	Appendable append(CharSequence cs);
}
interface CharSequence
{	
	//返回指定索引处的码
	char charAt(int index);
	//返回这个序列中的码元的数量
	int length();
	//返回存储在 startIndex 和 endIndex-1之间的 所有码元构成的 CharSequence
	CharSequence subSequence(int startIndex,int endIndex);
	//返回这个序列中所有码元构成的字符串
	String toString();
}

读取字符

PrintWriter

class PrintWriter
{
	PrintWriter(Writer out);
	PrintWriter(Writer out ,boolean autoFlush);
	//构建一个新的PrintWriter,可选是否自动冲刷
	PrintWriter(OutputStream);
	PrintWriter(OutputStream,boolean autoFlush);
	//通过构造必要的中介 OutputStreamReader 从OutputStream 构造 PrintWriter
	PrintWriter(String fileName);
	PrintWriter(File file);
	//通过构造必要的中介 FIleWriter 从文件构造 PrintWriter
	void print(Object obj);
	void print(String s);
	void println(String s);
	void print(char []s);
	void print(int i);
	void print(long l);
	void print(float  f);
	void print(double d);
	void print(boolean b);
	//格式化输出
	void printf(String format,Object...args);
	//如果产生格式化输出错误返回true,一旦一个流遇到了错误,它将会收到污染,并对所有 checkError调用返回 true
	boolean checkError();
}

字符集相关

class CharSet
{	
	//获取这个虚拟机可以使用的所有字符集,返回一个映射表,键是字符集名字,值是字符集
	static SortedMap availableCharSet();
	//获取给定名字的字符集
	static CharSet forName(String name);
	//返回这个字符集的别名
	Set aliases();
	//给定字符串编码为字节序列
	ByteBuffer encode(String str);
	//解码给定字节序列,无法识别的输入将被转换成Unicode的替代字符 '\uFFFD'
	CharBuffer decode(ByteBuffer buffer);
}

class ByteBuffer
{	
	
	byte []array();//返回这个缓冲区管理的字节数组
	static ByteBuffer wrap(byte []bytes);
	static ByteBuffer wrap(byte []bytes,int offset,int length);
	//返回管理给定字节数组的某个范围的字节缓冲区
}
class CharBuffer
{	 
	//返回这个缓冲区管理的码元数组
	char []array();
	//返回给定索引处的码元
	char charAt();
	//返回这个缓冲区管理的码元构成的字符串
	String toString();
}

	//more code ...
	Charset charset=Charset.forName("utf-8");
	String content="字符集";
	ByteBuffer byteBuffer=charset.encode(content);
	byte []bytes=byteBuffer.array();
		
	ByteBuffer bbuf=ByteBuffer.wrap(bytes);
	CharBuffer cbuf=charset.decode(bbuf);
	String string=cbuf.toString();
		
	System.out.println(string);
	//more code ...

读写二进制数据

DateInput and DataOutput

interface DataInput
{
	boolean readBoolean();
	byte readByte();
	char readChar();
	double readDouble();
	int readInt();
	long readLong();
	short readShort();
	//读入给定类型的数据
	void readFully(byte []b);
	//读入字节到数组b,其间阻塞直至所有字节都读入
	void readFully(byte []b,int off,int len);
	//读入字节到数组b,其键阻塞直至所有字节都读入, off数据起始位置偏移量,len读入数据最大数量
	String readUTF();
	//读入由修订过的 UTF-8 格式的字符构成的字符串
	int skipBytes(int n);
	//跳过n个字节,其间阻塞直至所有字节都被跳过
}

interface DataOutput
{
	void writeBoolean(boolean b);
	void writeByte(byte b);
	void writeChar(char c);
	void writeDouble(double d);
	void writeFloat(float f);
	void writeInt(int i);
	void writeLont(long l);
	void writeShort(short s);
	void writeChars(String s);
	void writeUTF(String s);
}

RandomAccessFile 

class RandomAccessFile
{
	RandomAccessFile(String file,String mode);
	RandomAccessFile(File file,String mode);
	// "r" 表示只读, "rw" 表示读写 ,"rws"表示每次更新时对数据和元数据的写磁盘操作进行同步的读写模式
	// "rwd" 表示每次更新时,只对数据的写磁盘操作进行同步的读写模式
	long getFilePointer();//返回文件指针的当前位置
	void seek(long pos);//将文件指针设置到距离开头的pos个字节处
	long length();//返回文件按照字节来衡量的长度
}

Zip

未完待续...

对象序列化

class People implements Serializable
{
	String name;
	int age;
	People(String name,int age){
		this.name=name;
		this.age=age;
	}
	public String toString() {
		return name+" "+age;
	}
}


public static void testSerializable(){
			
	People []peoples=new People[]{new People("Mike",15),new People("Jack", 16)};
			
	try(FileOutputStream fout=new FileOutputStream("/home/yzr/desktop/dat.txt"))
	{
		ObjectOutputStream oout=new ObjectOutputStream(fout);
		oout.writeObject(peoples);
	}catch (IOException e) {e.printStackTrace();}
			
	try(FileInputStream fin=new FileInputStream("/home/yzr/desktop/dat.txt");)
	{
		ObjectInputStream oin=new ObjectInputStream(fin);
		People [] cPeoples=(People[])oin.readObject();
		for(People people:cPeoples)
			System.out.println(people);
					
	}catch (IOException  e) {e.printStackTrace();} 
	catch (ClassNotFoundException ce) {ce.printStackTrace();}
}

利用对象序列化深拷贝

class SerialClonable implements Serializable ,Cloneable
{
	public Object clone(){
		
		try {
			ByteArrayOutputStream bout=new ByteArrayOutputStream();
			ObjectOutputStream oout=new ObjectOutputStream(bout);
			oout.writeObject(this);
			oout.close();
			
			ByteArrayInputStream bin=new ByteArrayInputStream(bout.toByteArray());
			ObjectInputStream oin=new ObjectInputStream(bin);
			Object ret=oin.readObject();
			oin.close();
			return ret;
			
		} catch (Exception e) {
			return null;
		}
	}
}