Java中的IO流

思维导图

Java 流式输入/输出原理

在java程序中，对于数据的输入、输出操作以流方式进行；jdk提供各种各样的流类，用以获取不同种类的数据；程序中通过标准的输入或输出数据。

输入输出流的分类

Java.io包中定义了多个流类型类或抽象列来实现输入输出功能，可以从不同的角度对其进行分类：

• 按方向：输入流和输出流；
• 按数据单位不同：字节流和字符流；
• 按功能：节点流和处理流。

节点流：可以从一个特征的数据节点读写数据（如：文件，内存）

处理流：连接在已经存在的流之上，通过对数据的处理为程序提供更为强大的读写功能。

InputStream：继承自InputStream的流都是用于向程序输入数据，且数据的单位为字节。

OutputStream：继承自OUtputStream的流式用于程序中输入数据，且数据的单位为字节。

Reader：继承自Reader的流都是用于向程序中输入数据，且数据的单位为字符。

Writer：继承自Writer的流都是用于向程序中输出数据，且数据的单位为字符。

实例代码（InputStream）：

import java.io.*;
public class TestFileInputStream{
	public static void main(String[] args){
		int b = 0;
		FileInputStream in = null;
		try{
			in = new FileInputStream("g:\\eclipse-workspace\\java\\TestFileInputStream.java");
		}catch(FileNotFoundException e){
			System.out.println("找不到指定文件");
			System.exit(-1);
		}
		
		try{
			long num = 0;
			while((b=in.read()) != -1){
				System.out.print((char)b);
				num++;
			}
			in.close();
			System.out.println();
			System.out.println("供读取了"+num+"个字节");
		}catch(IOException e1){
			System.out.println("文件读取错误");
			System.exit(-1);
		}
	}
}

实例代码（OutputStream）：

import java.io.*;
public class TestFileOutputStream{
	public static void main(String[] args){
		int b = 0;
		FileInputStream in = null;
		FileOutputStream out = null;
		try{
			in = new FileInputStream("g:\\eclipse-workspace\\java\\HelloWorld.java");
			out = new FileOutputStream("g:\\eclipse-workspace\\java\\IO\\helloworld.java");
			while((b=in.read()) != -1){
				out.write(b);
			}
			in.close(); 
			out.close();
		}catch(FileNotFoundException e2){
			System.out.println("找不到指定文件");
			System.exit(-1);
		}catch(IOException e1){
			System.out.println("文件复制错误");
			System.exit(-1);
		}
		System.out.println("文件已复制");
	}
}

实例代码（FileReader）：

实例代码（FileReader）：
import java.io.*;
public class TestFileReader{
	public static void main(String[] args){
		FileReader  fr = null;
		int c = 0;
		try{
			fr = new FileReader("g:\\eclipse-workspace\\java\\TestFileReader.java");
			int ln = 0;
			while((c=fr.read()) != -1){
				System.out.print((char)c);
			}
			fr.close();
		}catch(FileNotFoundException e){
			System.out.println("找不到指定文件");
		}catch(IOException e){
			System.out.println("文件读取错误");
		}
	}
}

实例代码（FileWriter）：

import java.io.*;
public class TestFileWriter{
	public static void main(String[] args){
		FileWriter fw = null;
		try{
			fw = new FileWriter("g:\\eclipse-workspace\\java\\bak\\unicode.dat");
			for(int c=0;c<=50000;c++){
				fw.write(c);
			}
			fw.close();
		}catch(IOException e){
			e.printStackTrace();
			System.out.println("文件写入错误");
			System.exit(-1);
		}
	}
}

处理流类型

缓冲流：需要套接在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。

• 缓冲输入流支持其父类的Mark和reset方法；
• BufferedReader提供了readLine方法用于读写一行字符串；
• BufferedWriter提供了newLine用于写入一行分隔符；
• 对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush方法将会使内存找那个的数据立刻写出。

实例代码：

import java.io.*;
public class TestBufferStream{
	public static void main(String[] args){
		try{
			BufferedWriter bw = new BufferedWriter(new FileWriter("g:\\eclipse-workspace\\java\\dat.txt"));
			BufferedReader br = new BufferedReader(new FileReader("g:\\eclipse-workspace\\java\\dat.txt"));
			String s = null;
			for(int i=1;i<=100;i++){
				s = String.valueOf(Math.random());
				bw.write(s);
				bw.newLine();
			}
			bw.flush();
			while((s=br.readLine()) != null){
				System.out.println(s);
			}
			bw.close();
			br.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

转换流

• InputStreamReader和OutputStreamWriter用于字节数据到字符数据之间的转换；
• InputStreamReader需要和InputStream套接；
• OutputStreamWriter需要和OutputStream套接；
• 转换流在构造是可以指定其编码集合例如：InputStream sr = new InputStreamReader（System.in，“”）

实例代码：

实例代码：
import java.io.*;
public class TestTransForm1{
	public static void main(String[] args){
		try{
			OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("g:\\eclipse-workspace\\java\\char.txt"));
			osw.write("mircosoftibmsunapplehp");
			System.out.println(osw.getEncoding());
			osw.close();
			osw = new OutputStreamWriter(new FileOutputStream("g:\\eclipse-workspace\\java\\char.txt",true),"ISO8859_1");
			osw.write("mircosoftibmsunapplehp");
			System.out.println(osw.getEncoding());
			osw.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

数据流

• DataInputStream和DataOutputStream分别继承自InputStream和OutputStream，它属于处理流，需要分别套接在InputStream和OutputStream类型的节点流上；
• DataInputStream和DataOutputStream提供了可以存取与机器无关的java原始类型数据，如：int，double等的方法；
• DataInputStream和DataOutputStream的构造方法为：DataInputStream（InputStream in）；DataOutputStream（OutputStream out）。

实例代码：

import java.io.*;
public class TestDataStream{
	public static void main(String[] args){
		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		DataOutputStream dos = new DataOutputStream(baos);
		try{
			dos.writeDouble(Math.random());
			dos.writeBoolean(true);
			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
			System.out.println(bais.available());
			DataInputStream dis = new DataInputStream(bais);
			System.out.println(dis.readDouble());
			System.out.println(dis.readBoolean());
			dos.close();
			dis.close();
		}catch(IOException e){
			e.printStackTrace();
		}
	}
}

Print流

• PrintWriter和PrintStream都是输出流，分别针对于字符和字节；
• PrintWriter和PrintStream提供了重载的print；
• Println方法用于多种数据类型的输出；
• PrintWriter和PrintStream的输出操作不会抛出异常，用户通过检测错误状态获取错误信息；
• PrintWriter和PrintStream有自动flush功能。

实例代码：

import java.io.*;
public class TestPrintStream{
	public static void main(String[] args){
		PrintStream ps = null;
		try{
			FileOutputStream fos = new FileOutputStream("g:\\eclipse-workspace\\java\\IO\\log.txt");
			ps = new PrintStream(fos);
		}catch(IOException e){
			e.printStackTrace();
		}
		if(ps != null ){
			System.setOut(ps);
		}
		int ln = 0;
		for(char c=0;c<=60000;c++){
			System.out.print(c+"");
			if(ln ++>= 100){
				System.out.println();
				ln=0;
			}
		}
	}
}