IO流相关类

代码：

package io;

import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Reader;
import java.io.Serializable;
import java.io.Writer;
import java.util.Random;
import java.util.StringTokenizer;

public class MyTestIO {
	
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		
		//----FileInputStream/FileOutputStream---文件字节输入/输出流
		InputStream is = new FileInputStream("E:\\IO_resouce\\a.txt");
		OutputStream os = new FileOutputStream("E:\\IO_resouce\\b.txt",true);
		int c ;
		byte [] b = new byte[100];
		while((c = is.read(b,0,2))!=-1){//汉子占两个字节，所以如果读取汉字，每次至少读两个字节到缓冲中，c是返回读取的字节数
			os.write(b,0,c);
			String s = new String(b,0,20);
			System.out.println(s);
		}
		
		//----FileReader/FileWriter--文件字符输入流/输出流
		FileReader fr = new FileReader("E:\\IO_resouce\\a.txt");
		File file = new File("E:\\IO_resouce\\c.txt");
		FileWriter fw = new FileWriter(file,true);
		int ch ;
		char[] s = new char[20];
		Random ran = new Random();
		int dom = ran.nextInt(100);
		fw.write(dom);
		fw.write("|");
		fw.flush();
		while((ch = fr.read(s,0,2)) != -1){
			fw.write(s);
		}
		fw.flush();
		fw.close();
		
		//----BufferedReader/BufferedWriter：缓冲流，两者的源和目的流必须是字符数据流和字符输出流
		Reader fileR = new FileReader("E:\\IO_resouce\\stu.txt");
		BufferedReader br = new BufferedReader(fileR);
		
		Writer filew = new FileWriter("E:\\IO_resouce\\stucopy.txt",true);
		BufferedWriter bw = new BufferedWriter(filew);
		
		String str ;
		while((str = br.readLine())!=null){//每次读一行
			
			/*StringTokenizer st = new StringTokenizer(str);
			int count = st.countTokens();*/
			int count = str.length();
			bw.write(str + "**句子中字符个数为：" + count);//每次写一行
			bw.newLine();//新起一行
		}
		
		bw.flush();//刷新缓存，将缓冲区数据刷到硬盘
		bw.close();//关闭缓冲输出流
		br.close();//关闭缓冲输入流
		
		fileR = new FileReader("E:\\IO_resouce\\stucopy.txt");
		br = new BufferedReader(fileR);
		String st =  null;
		while ((st = br.readLine()) != null){
			System.out.println(st);
		}
		
		br.close();
		fr.close();
		
		//----RandomAccessFile：随机流
		
		//--ByteArrayInputStream/ByteArrayOutputStream --字节数组流，源和目的是计算机内存,写到缓冲区。
		ByteArrayOutputStream outbyte = new ByteArrayOutputStream();
		byte [] byteContent = " Happy New Year ".getBytes();
		outbyte.write(byteContent);
		
		ByteArrayInputStream inbyte = new ByteArrayInputStream(outbyte.toByteArray());
		byte[] backdata = new byte[byteContent.length];
		inbyte.read(backdata);
		System.out.println(new String(backdata));//String s = new String(byte[]),或者new String(byte[]，'Gb2312'),使用当前机器的默认编码将字节数组转化为字符串。
		
		byte[] demobyte = " 测试 123 ！".getBytes();
		ByteArrayInputStream demo = new ByteArrayInputStream(demobyte);
		byte[] backdata2 = new byte[demobyte.length];
		demo.read(backdata2);
		System.out.println(new String(backdata2));
		
		//--CharArrayWriter/CharArrayReader--
		CharArrayWriter outchar = new CharArrayWriter();
		char[] chContent = " 新年快乐 ".toCharArray();
		outchar.write(chContent);
		//outchar.write(" 新年快乐 ");
		
		CharArrayReader inchar = new CharArrayReader(outchar.toCharArray());
		char[] backinfo = new char[chContent.length];
		inchar.read(backinfo);
		System.out.println(new String(backinfo));
		
		
		//----DataInputStream/DataOutputStream---文件字节输入/输出流
		FileOutputStream x = new FileOutputStream("E:\\IO_resouce\\apple.txt");
		DataOutputStream dos = new DataOutputStream(x);
		dos.writeInt(100);
		dos.writeLong(123456);
		dos.writeFloat(3.1415926f);
		dos.writeDouble(98765.4321);
		dos.writeBoolean(true);
		dos.writeShort('x');
		dos.writeUTF(" 我是英雄rom .");
		dos.writeChars(" how are you ! ");
		
		FileInputStream y = new FileInputStream("E:\\IO_resouce\\apple.txt");
		DataInputStream dis = new DataInputStream(y);
		System.out.println(dis.readInt());
		System.out.println(dis.readLong());
		System.out.println(dis.readFloat());
		System.out.println(dis.readDouble());
		System.out.println(dis.readBoolean());
		System.out.println(dis.readShort());
		System.out.println(dis.readUTF());
		char cc = '\0'; //'\0'表示空字符
		/*while((cc = dis.readChar()) != '\0'){
			System.out.println(cc);
		}*/
		
		//--ObjectInputStream/ObjectOutputStream--对象输入/输出流
		TV tv = new TV();
		tv.setName("changhong");
		tv.setPrice(1200);
		
		File f = new File("E:\\IO_resouce\\television.txt");
		FileOutputStream fos = new FileOutputStream(f);
		ObjectOutputStream oos = new ObjectOutputStream(fos);
		oos.writeObject(tv);
		oos.close();
		
		FileInputStream fis = new FileInputStream(f);
		ObjectInputStream ois =  new ObjectInputStream(fis);
		TV tv2 = (TV) ois.readObject();
		System.out.println(tv2.getName());
		ois.close();
		
		tv2.setName("xinfei");
		tv2.setPrice(2300);
		System.out.println(tv2.getName());
		
		
		//继承自InputStream/OutputStream的类操作字节流，继承自Writer/Reader的类操作字符流。
	}

	
}


class TV implements Serializable{
	
	private String name ;
	private int price;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getPrice() {
		return price;
	}
	public void setPrice(int price) {
		this.price = price;
	}
	
}

知识点：

1.inputstream /outputstream  是抽象类，其内部 read/write方法只写低8位，高24位忽略。
fileinputstream /fileoutputstream 继承 inputstream /outputstream 类  ，其中write()方法 的参数是byte[].
DataOutputStream extends FilterOutputStream implements DataOutput. 它的写读方法是若参数是int类型（即writeInt()），调用inputstream /outputstream的
读写方法--读4次，若是long则读8次，writeChar(int v)则需要读2次。
read()方法返回的整数范围是0-255的原因，一个字符8位最大长度是Unicode编码是255。
程序结束时会自动关闭所有打开的流，但是显示的关闭仍是好习惯，如果打开的流没有被关闭，则不允许另外的程序操作这些流中所用到的资源。
2.输出流指向的文件若不存在则创建，若存在则刷新该文件，使文件的长度为0.可以使用 FileOutputStream(String name, boolean append)，如果文件已存在
，则 append 为true时，输出流不会刷新所指的文件，只是从文件末尾向文件写入数据。
一般inputstream中read(byte b[])/read(byte b[], int off, int len)返回的为字节数，而read()则返回的为输入流的下一个字节。
每次调write()方法 顺序的 向目的文件写数据，直到输出流被关闭。
显示的调close()可以保证把操作系统流缓冲区的内容写到目的地（输出文件），关闭输出流可以把该流所用到的缓冲区的内容冲洗掉（通常冲洗到硬盘文件上）。
3.当使用对象输入输出流时，要保证对象是可序列化的，这是为了保证能把对象写到文件，并能再把对象正确的读回到程序中；需注意，不仅该对象，而且该对象的成员对象也必须是序列化的。