Java IO使用总结

最近在写Android网络操作的时候突然发现竟然不知道怎么写IO操作了。于是找了一下印象笔记，居然没有收藏过关于IO相关的笔记，那么索性就自己总结一下吧。

字节流

ByteArrayInputStream & ByteArrayOutputStream

ByteArrayInputStream ： 把字节数组转化为输入流，。

ByteArrayOutputStream：把内容写入到内部字节数组缓存中，其实就是包含了一个“byte buf[]”数组的OutputStream。当写操作完成之后，可以访问缓存数组的一个备份。

实例：

public static void testByteArrayStream() {
String sourceString = "This is a test about ByteArrayOutputStream " +
"and ByteArrayInputStream";

try {
ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
outputStream.write(sourceString.getBytes());

byte[] sourceBytes = outputStream.toByteArray();
ByteArrayInputStream inputStream = new ByteArrayInputStream(sourceBytes);

// 方法一：一次读取一个字节，只适合占用一个字节的字符串。
int ch = -1;
while ((ch = inputStream.read()) != -1) {
System.out.print((char) ch);
}
System.out.println("\n");

// 方法二：一次读取一个固定长度的数组。
/*byte[] buffer = new byte[10];
while (inputStream.read(buffer) != -1) {
System.out.println(new String(buffer));
}*/

inputStream.close();
outputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}

FileInputStream & FileOutputStream

BufferedInputStream & BufferedOutputStream

FileInputStream 和FileOutputStream是专门用来读写字节文件。由于没有缓存，最好使用BufferedInputStream 和BufferedOutputStream来封装使用它们。所以把他们放在了一起。

Buffered是对InputStream和OutputStream的一个封装，提供一个buffer来缓存input和output，BufferedInputStream 会自动读取固定长度的字符流到buffer中，每次read先从buffer中读取；BufferedOutputStream会把write的字节先放到buffer中，如果超过设置长度才会执行写操作。

这算是以空间来换取时间。

实例：

public static void testFileInputStream() {
File from = new File("a.gif");
File to = new File("b.gif");
if (from.exists()) {
FileInputStream fileInputStream = null;
BufferedInputStream bufferedInputStream = null;
FileOutputStream fileOutputStream = null;
BufferedOutputStream bufferedOutputStream = null;

try {
fileInputStream = new FileInputStream(from);
bufferedInputStream = new BufferedInputStream(fileInputStream);

fileOutputStream = new FileOutputStream(to);
bufferedOutputStream = new BufferedOutputStream(fileOutputStream);

byte[] buffer = new byte[1024];

while (bufferedInputStream.read(buffer) != -1) {
bufferedOutputStream.write(buffer);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bufferedInputStream != null) {
bufferedInputStream.close();
}
if (bufferedOutputStream != null) {
bufferedInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
} else {
System.err.println(from.getName() + " 文件不存在！");
}
}

DataInputStream & DataOutputStream

提供读写java的基本数据类型。如writeBoolean(),writeUTF()，writeChar，writeByte()，writeDouble()等和对应的read方法。

实例：

BufferedOutputStream bufferedOutputStream = null;
BufferedInputStream bufferedInputStream = null;
DataOutputStream dataOutputStream = null;
DataInputStream dataInputStream = null;

try {
bufferedOutputStream = new BufferedOutputStream(new FileOutputStream(new File("out.txt")));
dataOutputStream = new DataOutputStream(bufferedOutputStream);

dataOutputStream.writeShort(1);
dataOutputStream.writeChar(',');
dataOutputStream.writeInt(20);
dataOutputStream.writeBoolean(false);
dataOutputStream.writeChar(',');
dataOutputStream.writeUTF("Test哦！");

dataOutputStream.flush();

bufferedInputStream = new BufferedInputStream(new FileInputStream(new File("out.txt")));
dataInputStream = new DataInputStream(bufferedInputStream);
short out1 = dataInputStream.readShort();
char out2 = dataInputStream.readChar();
int out3 = dataInputStream.readInt();
boolean out4 = dataInputStream.readBoolean();
char out5 = dataInputStream.readChar();
String out6 = dataInputStream.readUTF();

System.out.println("Result" + out1 + out2 + out3 + out4 + out5 + out6);

} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (bufferedOutputStream != null) {
bufferedOutputStream.close();
}

if (bufferedInputStream != null) {
bufferedInputStream.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}

ObjectInputStream & ObjectOutputStream

读写实现了Serializable接口的对象的字节流。

实例：

ObjectInputStream objectInputStream = null;
ObjectOutputStream objectOutputStream = null;

try {
objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("out.txt")));
objectOutputStream.writeUTF("ObjectStream:");

Employee employee = new Employee();
employee.setName("TOM");
employee.setAge(22);
employee.setAddress("China");
employee.setPhoneNumber("987766666");
objectOutputStream.writeObject(employee);

objectInputStream = new ObjectInputStream(new FileInputStream(new File("out.txt")));
String out1 = objectInputStream.readUTF();
Object out2 = (Employee) objectInputStream.readObject();
System.out.println(out1 + out2);

} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
} finally {
try {
objectInputStream.close();
objectOutputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}

字符流

CharArrayReader & CharArrayWriter

CharArrayReader ：把字符数组作为一个输入流

CharArrayWriter： CharArrayWriter里面包含一个字符数组来当做缓存，写操作就是把内容写入到缓存中。当写操作完成之后，可以访问缓存数组的一个备份。

实例：

String sourceString = "This is a test about ByteArrayOutputStream and ByteArrayInputStream";

CharArrayReader charArrayReader = null;
CharArrayWriter charArrayWriter = null;

charArrayWriter = new CharArrayWriter();
try {
// 把sourceString写入到CharArrayWriter的缓存数组中
charArrayWriter.write(sourceString);
} catch (IOException e) {
e.printStackTrace();
}

String sourceWriter = charArrayWriter.toString();
// 把sourceWriter字符串转化为输入流
charArrayReader = new CharArrayReader(sourceWriter.toCharArray());

StringBuilder stringBuilder = new StringBuilder();

// 方法一：一次读取一个字符
/*    int ch = -1;
try {
while ((ch = charArrayReader.read()) != -1) {
stringBuilder.append((char) ch);
}
System.out.println("Read one Char: " + stringBuilder.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
charArrayReader.close();
}*/

// 方法二：一次读取一个字符数组
char[] chars = new char[10];
int count;
try {
while ((count = charArrayReader.read(chars)) != -1) {
stringBuilder.append(String.copyValueOf(chars, 0, count));
}
System.out.println("Read char array: " + stringBuilder.toString());
} catch (IOException e) {
e.printStackTrace();
} finally {
charArrayReader.close();
}

FileReader & FileWriter

已字符流的形式读写文件。

如果读写操作比较频繁，需要使用BufferedReader和 BufferedWriter来包装使用。

实例：

FileReader fileReader = null;
FileWriter fileWriter = null;

try {
fileReader = new FileReader(new File("out.txt"));
fileWriter = new FileWriter(new File("out2.txt"));

// 读写不频繁的时候，直接使用
char[] buffer = new char[1024];
while (fileReader.read(buffer) != -1) {
fileWriter.write(buffer);
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
if (fileReader != null) {
fileReader.close();
}

if (fileWriter != null) {
fileWriter.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}

BufferedReader & BufferedWriter

自带Buffer的Reader和Write。如果读写操作比较频繁的话，可以使用这两个类。

实例：

FileReader fileReader = null;
FileWriter fileWriter = null;

try {
fileReader = new FileReader(new File("out.txt"));
fileWriter = new FileWriter(new File("out2.txt"));

BufferedReader bufferedReader = new BufferedReader(fileReader);
BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

String buffer;
while ((buffer = bufferedReader.readLine()) != null) {
bufferedWriter.write(buffer);
bufferedWriter.write('\n');
}

bufferedWriter.close();
bufferedReader.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
try {

if (fileReader != null) {
fileReader.close();

}

if (fileWriter != null) {
fileWriter.close();
}

} catch (IOException e) {
e.printStackTrace();
}
}

StringReader & StringWriter

StringReader：把String转化为一个流。

StringWriter：带有StringBuffer的Write。

实例：

String sourceString = "This is a test about ByteArrayOutputStream and ByteArrayInputStream";

StringReader stringReader = null;
StringWriter stringWriter = null;

stringReader = new StringReader(sourceString);
stringWriter = new StringWriter();

char[] buffer = new char[1024];
try {
while (stringReader.read(buffer) != -1) {
stringWriter.write(buffer);
}
System.out.println(stringWriter.toString());
} catch (IOException e) {
e.printStackTrace();
}

stringReader.close();
try {
stringWriter.close();
} catch (IOException e) {
e.printStackTrace();
}