Java IO 流总结

 

字符流： Reader, Writer
字节流： InputStream, OutputStream

字符流与字节流的转换：

         读入                      输入字节流转字符流                                              字符流转字节流输出                             写入
数据源----> InputStream ---------------------> Reader ----处理---- Writer-----------------------> OutputStream---->数据源
                           InputStreamReader(InputStream)                        OutputStreamWriter(Outputstream)

InputStreamReader(InputStream) ： 从InputStream读入，转为字符流
OutputStreamWriter(Outputstream)： 在Outputstream写入， 转为字节流

1. 字符流：
读取(Reader) ： read([char[] cbuf][,CharBuffer target])

 

CharArrayReader(char[] buf [,int offset, int length]): 从char数组读入数据创建流
StringReader(String s) ： 从字串读入
FileReader(File file | String fileName | FileDescriptor fd) ： 从文件读入， 继承自InputStreamReader, 说明是首先用InputStream读入文件， 再转成的Reader
PipedReader([PipedWriter src] [, int pipeSize]) : 从管道读入
BufferedReader(Reader in, int sz) : 从其他Reader读入， 提供缓存， 提高读取效率

 

写入(Writer) : append(char c | CharSequence csq) , write(char[] cbuf | int c | String str)

 

 

CharArrayWriter([int initialSize]) : 把数据写入内部的CharyArray中， 主要用作缓存, 可以通过initialSize规定缓存大小
StringWriter([int initialSize]): 把数据写入内部的String中， 可以初始化一个String， String(StringBuffer buffer)
FileWriter(File file | String fileName | FileDescriptor fd) ： 写入文件， 继承自OutputStreamWriter,
PipedWriter([PipedReader snk]): 写入管道
BufferedWriter(Writer out [, int sz]) : 写入其他流， 缓存功能， 防止每次写入都引发底层设备写操作。
PrintWriter(File file | OutputStream out | String fileName | Writer out) : 支持格式化输出，提供如format, print方法。 支持写入到文件（内部有缓存）、OutputStream, Writer

2. 字节流
读取 (InpurtStream)

 

ByteArrayInputStream(byte[] buf [, int offset, int length]): 从byte数组读入数据创建流
StringBufferInputStream(String s) ： 从字串读入， 已废弃
FileInputStream(File file | FileDescriptor fdObj | String name) : 从文件读入数据
PipedInputStream([PipedOutputStream src, int pipeSize]): 从管道读取数据
BufferedInputStream(InputStream in [, int size]): 从其他InputStream读入， 提供缓存功能

DataInputStream(InputStream in) : 从流读入数据， 可以以基本类型读入， 如readByte, readChar, readInt, readUTF...
SequenceInputStream(Enumeration<? extends InputStream> e | InputStream s1, InputStream s2) : 将多个或者两个流merge为一个
ObjectInputStream([InputStream in]) ： 从InputStream流，如FileInputStream中读取数据， 并且通过readInt(), readFloat(), readObject..等方法解析为各种类型和对象。

 

写入(OutputStream)

 

ByteArrayOutputStream([int size]): 把数据写入内部的一个ByteArray中， 可以通过toByteArray() and toString()获取
FileOutputStream(File file | FileDescriptor fdObj | String name) ： 写入文件
PipedOutputStream([PipedInputStream snk]) ： 写入管道
BufferedOutputStream(OutputStream out [, int size]): 写入其他流， 缓存功能， 防止每次写入都引发底层设备写操作。

如：
PrintStream ps1 = new PrintStream("test.out");
PrintStream ps2 = new PrintStream(new BufferedOutputStream(new FileOutputStream("test.out")));
ps1.println("Test the Print stream 2");
ps1.close();

ps1 可以直接写入文件， 但是每次调用println都会写一次文件
ps2 会先写入缓存， 当flush或者close时一起写入

DataOutputStream(OutputStream out) : 把基本类型写入流中， 如writeChar, writeByte, writeUTF, writeInt...

ObjectOutputStream([OutputStream out]): 把Object或其他类型，序列化为流
PrintStream(File file | OutputStream out | String fileName) : 格式化输出到文件或流

 

注意：

1） 使用File开头的字符/字节流， 一般要用Buffered流进行缓冲， 提高IO效率 

 

3. System.in & System.out

System.in 标准输入流 属于InputStream
System.out 标准输出流 属于PrintStream

4. nio
引入通道(Channel)和缓存(ByteBuffer)， 可以进行较为底层的读写操作，提高io效率
示例：
写：
FileChannel fc = new FileOutputStream("data.txt").getChannel();
fc.write(ByteBuffer.wrap("Some text").getBytes());
fc.close();
fc = new RandomAccessFile("data.tex", "rw").getChannel();
fc.posistion(fc.size()); //Move to file end
fc.write(ByteBuffer.wrap("Some text").getBytes());
fc.close();
读：
static final int BSIZE = 1024;
fc = new FileInputStream("data.txt").getChannel();
ByteBuffer buff = ByteBuffer.allocate(BSIZE);
fc.read(buff);
buff.flip();
while(buff.hasRemaining)
System.out.print((char).buff.get());

///out put
Some text Some text

Channel 内存映射文件

5. 压缩
产生校验和：
CheckedInputStream, CheckedOutputStream
压缩类
DeflaterOutputStream(基类)
ZipOutputStream(OutputStream in), GZIPOutputStream(OutputStream in)
解压缩类
InflaterInputStream(基类)
ZipInputStream(InputStream in), GZIPInputStream(InputStream in)

6. 序列化
实现Serializable 接口（不用实现任何方法）的类， 其对象可以被自动序列化。
参见ObjectInputStream, ObjectOutputStream.
注意
1) 对象中引用的其他对象， 也会被序列化， 形成“对象网”
2) 还原过程中不会调用构造器， 对象直接从数据恢复
3）如果序列化两个对象， 这两个对象同时持有另一个对象的引用， 那么会共享这个对象
4）类中static成员不会被序列化， 需要手动处理
5）对于不想序列化的成员变量， 用关键字transient声明

手动控制序列化， 实现Externalizable
需要重写writeExtenal(ObjectOutput out), readExternal(ObjectInput in) 在里面读写数据
在序列化，反序列化时这两个函数会分别被自动调用。 在反序列化时， 重建对象会先动用它的默认构造函数， 这点与Serializable不同
Serializable可以可以实现手动控制成员的序列化， 需要添加两个函数：
在序列化时，会调用他们，而不会调用默认的序列化机制。
private void writeObject(ObjectOutputStream stream) throws IOException;
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException;

转载于:https://www.cnblogs.com/hushpa/p/6113490.html