I/O数据流

流的概念：内存与存储设备之间传输数据的通道。
流的分类：
按方向：
输入流：将《存储设备》中的内容读入《内存》中。
输出流：将《内存》中的内容写入到《存储设备》中。

按单位：
字节流：以字节为单位，可以读写所有数据。
字符流：以字符为单位，只能读写文本数据。

按功能：
节点流：具有实际传输数据的读写功能。
过滤流：在节点流的基础之上增强功能。

字节流的父类（抽象类）：
InputStream:字节输入流
OutputStream:字节输出流

• 字节节点流
  FileOutputStream:
  public void write(byte[] b) //一次写对个字节，将b数组中的所有字节，写入输出流。
  FileInputStream:
  public int read(byte[] b) // 从流中读取多个字节，将读取到的内容存入b数组，返回实际读到的字节数；如果达到文件的尾部，则返回-1。

文件输出流：

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class TestStream{
	public static void main(String[] args) throws Exception{
		//绝对路径：E:\\code\\src\\Target.txt
		//相对路径：File\\Target.txt 与上一种形式等价
		
        //字节输出流
        FileOutputStream fos = new FileOutputStream("File\\Target.txt");
        //fos.write(65);//一次输出一个字节
        //fos.write(66);
        //fos.write('C');
        byte[] bs = new byte[]{65,66,67,68,69};
        //for.write(bs);//一次输出一组字节
        fos.write(bs,1,3);//一次输出一组字节的一部分
     }
}     

文件输入流：

public class TestFileInputStream{
	public static void main(String [] args) thrwos IOException{
		FileInputStream fis = new FileInputStream("File\\Targe.txt");
		//一次读一个字节
		while(true){	
			int n = fis.read();
			if(n==-1){
				break;
			}
			System.out.println((char)n);
		}
		//一次读一组字节
		byte[] cache = new byte[4];//创建了一个长度为4的数组，作为读取时的缓存
		while(true){
			int count = fis.read(cache);
			if(count == -1){
				break;
			}
			for(int i = 0;i<count;i++){ //根据读取字节的个数，决定打印的次数
				System.out.print((char)cache[i] + "\t");
			}
			System.out.println();
		}
	}

• 字节过滤流
  缓冲流：BufferedOutputStream / BufferedInputStream
  提高I/O效率，减少访问磁盘的次数；
  数据存储在缓冲区中，flush是将缓冲区的内容写入文件中，也可以直接close。

import java.io.BufferedOutputStream;

public class TestBufferedStream{
	public static void main(String[] args) throws IOException{
		FileOutputStream os = new FileOutputStream("Files\\buffer.txt");//节点流
		BufferedOutputStream bos = new BufferedOutputStream(os);//过滤流
		bos.write('A');
		bos.write('B');
		bos.write('C');
		bos.flush();//刷新缓冲（将缓冲中的数据，一次性写入文件中，并清空缓冲区）
		bos.write('D');
		bos.write('E');
		bos.close();//级联执行flush
	//----------------------------------------------------------------------
		FileInputStream is = new FileInputStream("Files\\buffer.txt");
		byte[] cache = new byte[4];
		while(true){
			int conut = is.read(cache);
			if(count == -1) break;
			for(int i = 1;i<count;i++){
				System.out.println(cache[i]+"\t");
			}
			System.out.println();
		}
	}
}

• 对象流：ObjectOutStream / ObjectInputStream

  增强了缓冲区功能。
  增强了读写8中基本数据类型和字符串功能。
  增强了读写对象的功能：1、readObject()从流中读取一个对象。2、writeObject(Object obj) 向流中写入一个对象。

import java.io.FileNotFountException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.InputStream;
import java.io.OutputStream;

public class TestObjectStream{
	public static void main(String[] args) throws IOException;
		OutputStream os = new OutputStream("Files\\object.txt");
		ObjectOutputStream oos = new ObjectOutputStream(os);
		Object obj = oos.readObject();
		Student stu = (Student) obj;
		System.out.println(stu.name+"\t"+sut.age+"\t"+stu.sex+"\t"+stu.score);
	}
}
class Student implements Serializable{
	String name;
	Interger age;
	String sex;
	Double score;
	public Student(String name,Interget age,String sex,Double score){
		super();
		this.name = name;
		this.age = age;
		this.sex = sex;
		this.score = score;
	}
}

• 字符流
  Reader:字符输入流。

Writer：字符输出流。

• 字符节点流
  FileWriter:
  public void write(String str) //一次写多个字符，将b数组中所有字符，写入输出流。
  FileReader:
  public void read(char[] c) //从流中读取多个字符，将读到的内容存入c数组，返回实际读到的字符数；如果达到文件的尾部，则返回-1.

import java.io.Filewriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.Reader;
import java.io.Writer;

public class TestReaderWriter{
	public fw = new FileWriter("Files\\chars.txt");
		fw.Writer("helloword");
		fw.flush();
		fw.close();
		Reader fr = new FileReader("Files\\chars.txt");
		char[] cache = new char[4];
		while(true){
			int n = fr.read(cache);
			if(n==-1)break;
			for(int i=0;i<n;i++){
				System.out.println(cache[i]);
			}
			System.out.println();
		} 
	}

• 字符过滤流
  缓冲流：BufferedWriter / BufferedReader
  支持输入换行。
  可一次写一行，读一行。

  PrintWriter:
  PrintWriter封装了print（）和println().支持自动换行。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Writer;
public class TestBuffered{
	public static void main(String[] args) throws IOException{
		Writer fw = new FileWriter("Files\\b.txt");
		BufferedWriter bw = new BufferedWriter(fw);
		bw.write("hello");
		bw.newLine();
		bw.write("World");
		bw.close();
		Reader fr = new FileReader("Files\\b.txt");
		BufferedReader br = new BufferedReader(fr);
		for(;;){
			String s = br.readLine();
			if(s==null)bread;
			System.out.println(s);
		}
	}
}

• 字符节点流
  桥接换流：InputStreamReader / OutputStreamWriter
  可将字节流转换为字符流
  可设置字符的编码方式

public class TestConvertStream{
	public static void main(String[] args) throws IOException{
		//原来持有字节输出流
		OutputStream os = new FileOutputStream("Files\\convert.txt");
		//转换为字符输出流
		OutputStreamWriter osw = new OutputStreamWriter(os,"GBK");//设置编码方式
		//在包装一层
		PrintWriter pw = new PrintWriter(osw);
		pw.println("你好");
		pw.println("世界");
		pw.close();
		//----------------------------------------------------
		InputStream is = new FileInputStream("Files\\convert.txt");
		InputStreamReader isr = new InputStreamReader(is,"GBK");//设置解码方式
		BufferedReader br = new BufferedReader(isr);
		while(true){
			String s = br.readLine();
			if(s==null) break;
			System.out.println(s);
		}
	}
}

• 使用步骤
  1、创建节点流
  （创建过滤流 设置字符编码集）
  2、封装过滤流
  3、读写数据
  4、关闭流