【转】输入/输出流 - 全面掌握IO

File类：

程序中操作文件和目录都可以使用File类来完成即不管是文件还是目录都是使用File类来操作的，File能新建,删除,重命名文件和目录，但File不能访问文件内容本身，如果需要访问文件本身，则需要使用输入/输出流，该类是位于java.io包下的

输入与输出IO:

输入流：只能从中读取数据，而不能向其中写入数据（由InputStream（字节流）和Reader（字符流）作为基类）

输出流：只能向其写入数据，而不能从中读取数据（由OutputStream（字节流）和Writer（字符流）作为基类）

java的io总共涉及40多个类，但都是从这四个抽象基类中派生出来的

InputStream最重要的三个read方法:



Reader中的read方法：



从这两个抽象类提供的方法就可以看出其实功能基本是一样的，只是操作的数据单元不一样而已

由于InputStream与Reader都是抽象类，是不能进行实例化的，我们只能用他们的子类来创建实例，它们分别提供了一个子类用于读取文件的输入流：FileInputStream和

FileReader，这两个子类都是节点流（与处理流相对）-----会直接与指定的文件关联而无包装。下面代码演示FileInputStream使用read(byte[] b):

package xidian.sl.io;

import java.io.FileInputStream;
import java.io.FileReader;

public class InputStreamTest {
/**
* 使用FileInputStream读取该类本身
* */
public static void FileInputStreamTest() throws Exception{
FileInputStream fis = null;
try{
//创建字节输入流
fis = new FileInputStream("src/xidian/sl/io/InputStreamTest.java");
//创建一个长度为1024的字节数组来存取
byte[] bbuf = new byte[1024];
//用于保存实际读取的字节数
int hasRead = 0;
//使用循环来进行重复读取
while((hasRead = fis.read(bbuf))> 0){
//取出字节，将字节数组转化为字符串输出
System.out.println(new String(bbuf, 0 , hasRead));
}
}finally{
//关闭文件输入流
fis.close();
}
}
/**
* 使用FileReader读取该类本身
* */
public static void FileReaderTest() throws Exception{
FileReader fr = null;
try{
//创建字节输入流
fr = new FileReader("src/xidian/sl/io/InputStreamTest.java");
//创建一个长度为1024的字节数组来存取
char[] bbuf = new char[40];
//用于保存实际读取的字节数
int hasRead = 0;
//使用循环来进行重复读取
while((hasRead = fr.read(bbuf))> 0){
//取出字节，将字节数组转化为字符串输出
System.out.println(new String(bbuf, 0 , hasRead));
}
}finally{
//关闭文件输入流
fr.close();
}
}
public static void main(String[] args) throws Exception{
InputStreamTest.FileInputStreamTest();
InputStreamTest.FileReaderTest();
}
}

可以看到这两个子类的使用方式可以说是完全一样的，不过这里要注意一个问题：字节流FileInputStream是根据字节来读取的，而一个中文是占两个字节的，如果包含很多中文的文件被字节流分多次进行读取，可能会造成乱码，因为有可能会导致刚好将一个中文分两次读取，这样就会乱码了，因此如果中文包含多的话还是使用字符流FileReader比较好，

在字节流与字符流之间选择的规律：如果需要进行输入/输出的内容是文本内容，则应该考虑使用字符流，如果需要进行输入/输出的是二进制内容，则应该考虑使用字节流，因为字节流的功能比字符流强大，计算机中所有的数据都是二进制的，而字节流可以处理所有的二进制文件；

OutputStream中最重要的write方法：



Writer中最重要的write方法：



Writer类中多了两个对字符串的操作类，因此如果是直接输出字符串就选用Writer会比较的方便；

与输入流一样，输出流也有两个文件操作的子类：FileOutputStream和FileWrite

package xidian.sl.io;

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileWriter;

public class OutputStreamTest {
/**
* 使用字节流输出
* */
public static void FileOutputStreamTest() throws Exception{
FileInputStream fis = null;
FileOutputStream fos = null;
try{
//创建字节输入流
fis = new FileInputStream("src/xidian/sl/io/InputStreamTest.java");
//创建字节输出流
fos = new FileOutputStream("src/xidian/sl/io/Output.txt");
byte[] bt = new byte[40];
int hasRead = 0;
//循环从输入流中读取数据
while((hasRead = fis.read(bt))> 0){
//每读取一个，即写入文件输出流，读了多少就写多少
fos.write(bt, 0, hasRead);
}

}catch (Exception e) {
e.printStackTrace();
}finally{
/**
* 流在关闭时会自动执行flash，将缓冲中的数据flush到物理节点中
* 所以关闭时很重要的
* */
if(fis != null){
fis.close();
}
if(fos != null){
fos.close();
}
}
}
/**
* 使用字符流输出字符串会显得比较的方便
* */
public static void FileWriteTest() throws Exception{
FileWriter fw = null;
try{
//创建字节输出流
fw = new FileWriter("src/xidian/sl/io/Output.txt");
fw.write("温州医学院\r\n");
fw.write("信息与管理专业\r\n");
fw.write("温州医学院\r\n");
fw.write("温州医学院\n");
fw.write("温州医学院");
}catch (Exception e) {
e.printStackTrace();
}finally{
if(fw != null){
fw.close();
}
}
}
public static void main(String[] args) throws Exception{
OutputStreamTest.FileOutputStreamTest();
OutputStreamTest.FileWriteTest();
}
}

上面是节点流的基本使用，下面将了解处理流的使用，处理流会显得更加的高效

区分节点流于处理流的方法是：只要流的构造器的参数不是一个物理节点，而是已存在的流，那这个流一定是处理流，因为所有的节点流都是直接以物理io节点作为构造器的参数、

（如file）。

举例：PrintStream处理流来封装FileOutputStream节点流，进行输出，由于PrintStream类的输出功能非常的强大，因此我们需要输出文本内容一般都会将输出流包装成PrintStream后输出

package xidian.sl.io;

import java.io.FileOutputStream;
import java.io.PrintStream;

public class PrintStreamTest {
public static void main(String[] args){
PrintStream ps = null;
try{
//创建一个节点输出流
FileOutputStream fos = new FileOutputStream("src/xidian/sl/io/Output.txt");
//以PrintStream处理流来包装FileOutputStream节点流
ps = new PrintStream(fos);
ps.println("普通字符串");
ps.println(new PrintStreamTest());
}catch (Exception e) {
e.printStackTrace();
}finally{
ps.close();
}
}
}

其实我们一直使用的标准输出System.out的类型都是PrintStream：



从上面的实例就可以看出将节点流封装成处理流很简单，只需调用处理流的构造方法来传入节点流就可以了；而且看到上面流的关闭只是关闭了处理流而未去关闭节点流，这样做是完全正确的，以后我们在关闭流的时候只需要关闭最上层的处理流即可；

字符流中有两个特别的流来处理字符串的：StringReader和StringWriter,



可以看到使用时实例化只需要传入一个字符串即可：例子：

package xidian.sl.io;

import java.io.StringReader;
import java.io.StringWriter;

public class StringNodeTest {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
String src = "你是个神";
StringReader sr = new StringReader(src);
char[] chars = new char[40];
int hasRead = 0;
try{
//采用循环的方式
while((hasRead = sr.read(chars))>0){
System.out.println(new String(chars, 0, hasRead));
}
}catch (Exception e) {
e.printStackTrace();
}finally{
sr.close();
}
//创建StringWriter
StringWriter sw = new StringWriter(40);
sw.write("你是一个大神");
sw.write("你也是一个大神");
System.out.println(sw.toString());

}

}

io系统提供的两个转换流：InputStreamReader和OutputStreamWriter,都是将字节流转化为字符流

在java中是使用System.in来提供键盘输入的，但这个标准输入流是InputStream类的实例：



而前面讲到了当处理的是文本内容时，使用字符流会显得比较方便，正好键盘输入就是文本的操作，因此我们有必须将System.in转换为字符流：

package xidian.sl.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class KeyinTest {
public static void main(String[] args){
BufferedReader br = null;
try{
//将System.in对象转化为Reader对象
InputStreamReader isr = new InputStreamReader(System.in);
//将节点流包装为处理流
br = new BufferedReader(isr);
String buffer = null;
//采用循环的方式一行一行读取
while((buffer = br.readLine()) != null){
System.out.print("输入的内容 = "+ buffer);
}
}catch (Exception e) {
e.printStackTrace();
}finally{
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

PrintStream是有强大的输出功能，而BufferReader有强大的输入（即读取），因此在操作读取文本内容时尽可能将其转化为BufferReader，可以方便的使用readLine()方法

接下来最为强大的文件操作类RandomAccessFile来了，这个类既可以向文件输入数据，也可以输出数据，并且他与不同的流最大的不同就是“支持文件任意位置的访问”，即程序可以控制读取文件哪个位置的内容；



从构造方法上可以看出，除了提供一个文件或文件名外还需要提供一个String参数mode,mode规定了RandomAccessFile类访问文件的模式：

1. “r”:以只读的方式打开指定文件

2. “rw”:以读取，写入方式打开指定文件，并且文件不存在会自动进行创建

3.“rws”与“rwd”:与“rw”类似，只是要求文件内容或元数据的每个更新都同步写入底层存储设备