Java笔记 - 输入输出流

java.io包中定义了各式各样的“流(stream)” 类型（类或抽象类），通过标准的方法实现对于数据的输入/输出操作。

一、流类型分类

以从不同的角度对其进行分类：按数据流的方向不同，可以分为  输入流  和  输出流（相对于程序来说的）；按处理数据单位不同，可以分为  字节流  和 字符流 ；按功能不同，可以分为  节点流 和  处理流，处理流需要套接在节点流之上使用。

1、节点流

节点流位可以从一个特定的数据源（节点）读写数据（如：文件、内存）。

常见的节点流类型如下：

2、处理流

处理流是 “连接/” 在已存在的流（节点流或处理流）之上，通过对数据的处理为程序提供更为强大的读写功能，

常见的处理流类型如下：

二、流的继承架构

java.io包中所有的流类型，都分别继承以下四种抽象流类型。

1、InputStream

继承自InputStream的流都是 向程序中输入数据，且数 据的单位为字节(8bit)。

（1）InputStream的子类

下图中深色为节点流、浅色为处理流。

（2）InputStream的基本方法

  1 //读取一个字节并以整数的形式返回（0 ~ 255）
  2 //若果返回-1，表示已经到了输入流的末尾
  3 int read() throws IOException;
  4
  5 //读取一系列字节并存储到一个数组buffer
  6 //返回实际读取的字节数；若果返回-1，表示已经到了输入流的末尾
  7 int read (byte [] buffer) throws IOException;
  8
  9 //从offset位置开始，读取length个字节，并存储到一个字节数组buffer
 10 //返回实际读取的字节数；若果返回-1，表示已经到了输入流的末尾
 11 int read (byte [] buffer,int offset,int length) throws IOException;
 12
 13 //关闭流释放内存资源
 14 void close () throws IOException ;
 15
 16 //跳过n个字节不读，返回实际跳过的字节数
 17 long skip(long n) throws IOException;

2、OutputStream

继承自OutputStream的流是用于从程序中输出数据，且数据的单位为字节(8bit)。

（1）OutputStream的子类

下图中深色为节点流、浅色为处理流。

（2）OutputStream的基本方法

  1 //向输出流中写入一个字节数据，该字节数据为参数b的低8位
  2 void write(iunt b) throws IOException;
  3
  4 //将一个字节类型的数组中的数据写入输出流
  5 void write(byte [] b) throws IOException;
  6
  7 //将一个字节类型的数组中，从off位置开始的len个字节写入到输出流
  8 int write (byte [] b,int off,int len) throws IOException;
  9
 10 //关闭流释放内存资源
 11 void close () throws IOException ;
 12
 13 //将输入流中缓存的数据全部写入到目的地
 14 long flush(long n) throws IOException; 

3、Reader

继承自Reader的流都是向程序中输入数据，且数据的单位为字符(16bit)。

（1）Reader的子类

下图中深色为节点流、浅色为处理流。

（2）Reader的基本方法

  1 //读取一个字符并以整数的形式返回（0 ~ 255）
  2 //若果返回-1，表示已经到了输入流的末尾
  3 int read() throws IOException;
  4
  5 //读取一系列字符并存储到一个数组buffer
  6 //返回实际读取的字符数；若果返回-1，表示已经到了输入流的末尾
  7 int read (char [] cbuf) throws IOException;
  8
  9 //从offset位置开始，读取length个字符，并存储到一个字符数组buffer
 10 //返回实际读取的字符数；若果返回-1，表示已经到了输入流的末尾
 11 int read (char [] cbuf,int offset,int length) throws IOException;
 12
 13 //关闭流释放内存资源
 14 void close () throws IOException ;
 15
 16 //跳过n个字符不读，返回实际跳过的字符数
 17 long skip(long n) throws IOException;

4、Writer

继承自Writer的流是用于从程序中输出数据，且数据的单位为字符(16bit)。

（1）Writer的子类

下图中深色为节点流、浅色为处理流。

（2）Writer的基本方法

  1 //向输出流中写入一个字符数据，该字节数据为参数b的低16位
  2 void write(int b) throws IOException;
  3
  4 //将一个字符类型的数组中的数据写入输出流
  5 void write(char [] cbuf) throws IOException;
  6
  7 //将一个字符类型的数组中，从off位置开始的len个字节写入到输出流
  8 int write (char [] cbuf,int off,int len) throws IOException;
  9
 10 //将一个字符串中的字符写入到输出流
 11 void write(String str) throws IOException;
 12
 13 //将一个字符串从offset位置开始的length个字符写入输出流
 14 void write (String str ,int offset,int length) throws IOException;
 15
 16 //关闭流释放内存资源
 17 void close () throws IOException ;
 18
 19 //将输入流中缓存的数据全部写入到目的地
 20 long flush(long n) throws IOException;

三、流的详细用法

1、文件流 类型

  1 import java.io.*;
  2 public class Main {
  3   public static void main(String[] args) {
  4 	  int b = 0;
  5 	  FileReader in = null;//输入字符流，若采用FileinputStream则不能读取中文
  6 	  FileWriter out = null;//输出字符流，若采用FileOutputStream则不能写入中文
  7
  8 	  try {
  9 		    in = new FileReader("file.txt");  //若没有该文件，则抛出FileNotFoundException
 10 		    out = new FileWriter("copy.txt");  //若没有该文件，则会自动创建copy.java
 11 	    while((b=in.read())!=-1){
 12 	      System.out.print((char)b); //必须进行类型转换，否则打印的是Unicode码
 13 	      out.write(b);//以字节为单位，向输出流写入数据
 14 	    }
 15 	  } catch (FileNotFoundException e1) {
 16 	    System.out.println("找不到指定文件"); System.exit(-1);
 17 	  } catch (IOException e2) {
 18 	    System.out.println("文件复制错误"); System.exit(-1);
 19 	  }finally{
 20 		   try {
 21 			in.close();
 22 			out.close();
 23 		} catch (IOException e) {
 24 			System.out.println("连接已关闭失败！");System.exit(-1);
 25 		}
 26 	  }
 27 	  System.out.println("文件已复制");
 28   }
 29 }
 30 

2、数据流 类型

DataInputStream 和DataOutputStream 属于处理流，提供了可以存取与机器无关的JAVA原始类型数据（如：long、double、UTF）等的方法，多用于进行网络数据传输。

（1）构造方法

DataInputStream （InputStream  in）

DataOutputStream (OutputStream  out)

（2）举例

  1 import java.io.*;
  2 public class Main {
  3   public static void main(String[] args) {
  4
  5 	  ByteArrayOutputStream baos = new ByteArrayOutputStream(); //字节数组输出流
  6 	  ByteArrayInputStream bais = null;//字节数组输入流
  7
  8       DataOutputStream dos = new DataOutputStream(baos);//输出流
  9       DataInputStream dis = null;//输入流
 10
 11     try {
 12       dos.writeDouble(Math.random());//向字节数组写入一个随机数
 13       dos.writeBoolean(true);//向字节数组写入一个布尔变量
 14
 15       bais =  new ByteArrayInputStream(baos.toByteArray());
 16       dis = new DataInputStream(bais);
 17
 18       System.out.println(bais.available());//字符数组大小
 19       System.out.println(dis.readDouble());//先写的先读
 20       System.out.println(dis.readBoolean());
 21
 22     } catch (IOException e) {
 23       e.printStackTrace();
 24     }finally {
 25     	 try {
 26 			dos.close();
 27 			dis.close();
 28 		} catch (IOException e) {
 29 			e.printStackTrace();
 30 		}
 31     }
 32   }
 33 }

3、缓冲流 类型

缓冲流是  “套接” 在相应的节点流之上，对读取的数据提供缓冲的功能，提高读写效率，同时也增加了一些新的方法，如readLine阻塞式方法等。

（1）常用构造方法

  1  BufferedReader(Reader in)
  2  BufferedReader(Reader in,int sz)  //sz为自定义缓冲大小
  3
  4  BufferedWriter(Writer out)
  5  BufferedWriter(Writer out,int sz)
  6
  7  BufferedInputStream(InputStream out)
  8  BufferedInputStream(InputStream out,int sz)
  9
 10  BufferedOutputStream(OutputStream out)
 11  BufferedOutputStream(OutputStream out,int sz)

（2）使用readLine和write读写数据

BufferedReader提供了readLine方法用于读取一行字符串(以\r或\n分隔)、newLine用于写入一行分隔符、flush方法用于将先在内存中缓存的数据立刻写出。

  1 import java.io.*;
  2 public class Main {
  3   public static void main(String[] args) {
  4 	String s = null;
  5 	BufferedReader br = null;//输入字符流，若采用BufferedInputStream则不能读取中文
  6 	BufferedWriter bw = null;//输入字符流，若采用BufferedOutputStream则不能写入中文
  7     try {
  8     	 br = new BufferedReader(new FileReader("file.txt"));
  9     	 bw = new BufferedWriter(new FileWriter("copy.txt"));
 10
 11 	      while((s=br.readLine())!=null){
 12 	        System.out.println(s);
 13 	        bw.write(s);
 14 	        bw.newLine();
 15 	      }
 16 	      bw.flush();
 17
 18     } catch (IOException e) {
 19     	e.printStackTrace();
 20     }finally {
 21         try {
 22 			br.close();
 23 			bw.close();
 24 		} catch (IOException e) {
 25 			e.printStackTrace();
 26 		}
 27     }
 28   }
 29 }

（3）使用mark和reset方法

mark(int readlimit)方法标记当前位置，并保证在mark以后最多可以读取readlimit字节数据，mark标记仍有效。如果在mark后读取超过readlimit字节数据，mark标记就会失效，调用reset()方法会有异常。但实际上只要在mark标记后读取的数据没有超出缓冲区的大小，mark标记就不会失效，仍然能正确调用reset方法重置。 。
     

  1 import java.io.*;
  2 public class Main {
  3   public static void main(String[] args) {
  4 	int c = 0;
  5 	String s = null;
  6 	BufferedReader br = null;
  7
  8     try {
  9     	 br = new BufferedReader(new FileReader("file.txt"));
 10
 11     	 for(int i=0;i<=15 && (c=br.read())!=-1;i++){
 12     		 if(c == 'd') br.mark(5);
 13     	        System.out.print((char)c+" ");//包含了回车换行符
 14     	      }
 15 	      br.reset();
 16
 17 	      while((s=br.readLine())!=null){
 18 	        System.out.println(s);
 19 	      }
 20
 21     } catch (IOException e) {
 22     	e.printStackTrace();
 23     }finally {
 24         try {
 25 			br.close();
 26 		} catch (IOException e) {
 27 			e.printStackTrace();
 28 		}
 29     }
 30   }
 31 }

4、转换流 类型

InputStreamReader和OutputStreamWriter用于字节数据转换到字符数据，转换流在构造时可以指定其编码集合。

  1 import java.io.*;
  2 public class Main {
  3    public static void main(String args[]) {
  4      BufferedReader istr = null;
  5      OutputStreamWriter ostr = null;
  6      String s = null;
  7
  8     try {
  9     	istr = new BufferedReader(
 10     			new InputStreamReader( new FileInputStream("file.txt")));
 11      	ostr = new OutputStreamWriter(
 12      			new FileOutputStream("copy.txt", true),"utf-8"); // ISO8859_1
 13
 14       	ostr.write(ostr.getEncoding());
 15      	while((s=istr.readLine())!=null){
 16      		System.out.println(s);
 17    		ostr.write(s);
 18     	}
 19      	ostr.flush();
 20
 21       } catch (IOException e) {
 22       e.printStackTrace();
 23      }finally {
 24       	try {
 25 			istr.close();
 26 			ostr.close();
 27 		} catch (IOException e) {
 28 			// TODO Auto-generated catch block
 29 			e.printStackTrace();
 30 		}
 31      }
 32    }
 33  }

5、Print流 类型

PrintWriter和PrintStream都属于输出流，处理数据的单位分别是字符和字节。PrintWriter和PrintStream提供了重载的print和println方法用于多种数据类型的输出 以及 在关闭连接之前可以自动flush的功能。另外，Print流的操作不会抛出异常，用户通过检测错误状态获取错误信息。

注：System.in和System.out默认是键盘输入输出。

（1）构造方法

PrintWriter( Writer out )

PrintWriter( Writer out , boolean autoFlush)  //true表示以追加的方式写入

PrintWriter( OutputStream  out )

PrintWriter( OutputStream  out , boolean autoFlush)

PrintWriter( OutputStream  out )

PrintWriter( OutputStream  out ,,boolean autoFlush)

（2）举例

  1 import java.util.*;
  2 import java.io.*;
  3 public class Main {
  4   public static void main(String[] args) {
  5     String s = null;
  6     BufferedReader br = new BufferedReader( new InputStreamReader(System.in));
  7
  8     PrintWriter log1 = null;
  9     PrintStream log2 = null;
 10
 11     try {
 12       log1 = new PrintWriter(new FileWriter ("file.txt", true));
 13       log2 = new PrintStream(new FileOutputStream ("file.txt", true));
 14
 15       if(log2 != null){
 16           System.setOut(log2);  //将System.out输出目的地设置成文件
 17         }
 18
 19       while ((s = br.readLine())!=null) {
 20         if(s.equalsIgnoreCase("exit")) break;
 21
 22         //在文件file中换行打印
 23         log1.println(s.toUpperCase());
 24         log2.println(s.toUpperCase());
 25         System.out.println(s.toUpperCase());//默认立即flush
 26       }
 27       log1.println("==="+new Date()+"===");
 28       log1.flush();//显式写出默认的flush方式，即在循环完成后一起flush
 29       log2.flush();//也可写在循环中达到立即flush的效果
 30
 31     } catch (IOException e) {
 32       e.printStackTrace();
 33     }finally {
 34     	log1.close(); //不会抛出异常
 35             log2.close();
 36     }
 37   }
 38 }

6、Object流 类型

Object流可以直接将Object写入或写出，但Object类必须实现序列化接口。

（1）序列化接口

Serializable是序列化接口，标记类可以被序列化，无需重写方法，序列化过程由JRE控制。Externalizable是外部化接口，是Serializable的子接口，提供了readExternal和writeExternal方法，程序员可以重写这两个方法控制序列化过程。

（2）举例

  1 import java.io.*;
  2
  3 public class Main {
  4 	public static void main(String args[]) throws Exception {
  5 		T t = new T();
  6
  7 		//保存类
  8 		ObjectOutputStream oos = new ObjectOutputStream(
  9 					new FileOutputStream("file.dat"));
 10 		oos.writeObject(t);
 11 		oos.flush();
 12 		oos.close();
 13
 14 		//读取类
 15 		ObjectInputStream ois = new ObjectInputStream(
 16 					new FileInputStream("file.dat"));
 17 		T tReaded = (T)ois.readObject();
 18 		System.out.println(tReaded.i + " " + tReaded.j + " " +
 19 							tReaded.d + " " + tReaded.k);
 20
 21 	}
 22 }
 23
 24 class T implements Serializable
 25 {
 26 	int i = 10;
 27 	int j = 9;
 28 	double d = 2.3;
 29 	transient int k = 15;//transient修饰的成员变量在序列化时不予考虑,显示默认值0
 30 }

7、管道 类型