Java io学习总结

Java io学习总结
一． InputStream继承关系图

InputStream和OutputStream：
两者都为抽象类，在没有处理流的情况下，每次只能从数据源读取一个字节和向数据源写出一个字节。

Reader和Writer:
两者同样为抽象类，在没有处理流的情况下，每次只能从数据源读取一个字符（2个字节）和向数据源写出一个字符。

 

注意：

 

1. 流对象实例后，必须得关闭
2. 关于流的类，除了打印流，很多方法都抛出来异常，需认真对待

 

3. Sysem.in和System.out分别为InputStream和OutputStream的实例化对象
它们由InputStream和OutputStream的之类创建。
4.有关阻塞式对象还需进一步研究。
5.处理数据用数据流
6.有意识的去运用缓冲流
二． 节点流

 

 

节点流连接的是数据源（文件/内存/管道），他们可以直接通过无参构造函数实例化，而不需要像处理流那样需要传入一个节点流参数才可以。

FileInputStream和FileOutputStream :

分别从文件中读取字节和向文件中写字节，跟byte和byte数组关系密切

FileInputStream 的主要方法：
int read() throws IOException ; //返回读取的一个字节，最后返回-1

int read(byte[] b) throws IOException;
// b - 存储读取数据的缓冲区。
//返回读入缓冲区的总数，读取的内容保存在byte数组中。
int read(byte[] b, int off, int len ) throws IOException；

Reader和Writer:
分别从文件中读取字字符和向文件中写字符，跟char和byte数组（String）关系密切
1.Reader的主要方法：
int read() throws IOException ; //返回读取的一个字符，最后返回-1

int read(char[] cbuf) throws IOException;

// cbuf - 存储读取数据的缓冲区。

//返回读入缓冲区的总数，读取的内容保存在char数组中。

int read(char[] cbuf, int off, int len ) throws IOException；

2.Writer的主要方法：
Void write (int c) throws IOException ; //写入单个字符
Void write(char[] cbuf) throws IOException; //写入字符数组

void read(char[] cbuf, int off, int len ) throws IOException；

Void write(String str) throws IOException; //写入字符串

Void write(String str,int off,int length) throws IOException ;
ByteArrayInputStream和ByteArrayOutpustStream:

ByteArrayOutputStream类是在创建它的实例时，程序内部创建一个byte型别数组的缓冲区(内存中)，然后利用ByteArrayOutputStream和ByteArrayInputStream的实例向数组中写入或读出byte型数据。在网络传输中我们往往要传输很多变量，我们可以利用ByteArrayOutputStream把所有的变量收集到一起，然后一次性把数据发送出去。

 

通常和过滤流DataInputStream和DataOutputStream混合使用
CharArrayReader和CharArrayWriter：
用法跟ByteArrayInputStrea和ByteArrayOutputStream用法一样。
三． 处理流

 
(一). 缓冲流
有BufferedInputStream和BufferedOutputStream ，相应的有BufferedReader和BufferedWriter类提供缓冲流。
使用缓冲流动好处：
1. 能够提搞读写速度，在一次访问硬盘的时候可以读取多条数据
2. 拥有节点流说没有的readLine（），即读取一行的方法
（二）. 数据流
DataInputStream和DataOutputStream:
用于输入输出Java基本数据类型，通常跟ByteArrayInputstream和ByteArrayOutputStream一起联合使用，注意没有DataReader和DataWriter类存在。
使用例子：
package com.ljp.io;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;

public class DataIOTest {

/**DataInputStream和DataOutputStream,ByteArrayInputStream和ByteArrayOutputStream的使用
* @param args
*/
public static void main(String[] args) {
//在内存中开辟一个字节数组，并且往里面写数据
ByteArrayOutputStream byOut=new ByteArrayOutputStream();
DataOutputStream dataOut=new DataOutputStream(byOut);
try {
dataOut.writeBoolean(true);
dataOut.writeDouble(5.654612121);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

//从开辟的内存字节数组中读出内容
ByteArrayInputStream byIn=new ByteArrayInputStream(byOut.toByteArray()); //注意参数
DataInputStream dataIn=new DataInputStream(byIn);
try {
System.out.println(dataIn.available());
System.out.println(dataIn.readBoolean());
System.out.println(dataIn.readDouble());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
byOut.close();
dataOut.close();
byIn.close();
dataIn.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}

(三).打印流
1.打印流只用输出流，没有输入流，属于处理流，构造方法需要传入节点流对象。

2.提供了重载的print和pintln方法

3.PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取
错误信息。
4.PrintWriter和PrintStream有自动档flush功能。

例子：

package com.ljp.io;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintStream;

public class PrintStreamTest {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
FileOutputStream fo=null;
try {
fo = new FileOutputStream("H:/io.txt");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
PrintStream ps=new PrintStream(fo);
if(ps!=null){
System.setOut(ps);
}

for(int i=0;i<10;i++){
System.out.println(Math.random());
}
try {
fo.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

}

（四）.对象流(object流)
ObjectInputStream和ObjectOutputStream：

1.直接将Object写入或写出
2.translent关键字
3.serializable接口（标记性接口，无方法）：把对象转换成字节流，将其序列化

例子：
package com.ljp.io;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class ObjectIOTest {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
T t=new T();
FileOutputStream fos=null;
ObjectOutputStream oos=null;
try {
fos=new FileOutputStream("D:/io.txt");
oos=new ObjectOutputStream(fos);
oos.writeObject(t);
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

FileInputStream fis=null;
ObjectInputStream ois=null;
try {
fis = new FileInputStream("D:/io.txt");
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
try {
ois=new ObjectInputStream(fis);
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
T tt=null;
try {
tt=(T)ois.readObject();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.print(tt.i+","+tt.d+","+tt.s);
}

}

class T implements Serializable{
int i=9;
double d=2.98;
String s="hello world";
transient int k=29; //transient关键字使变量不能序列化
}