IO流

IO流的输入/输出是从程序的角度来讲的。（从外部（磁盘）流到内存或者程序中，称为输入流【数据从程序外流向程序】。从内存输出到磁盘中，称为输出流【数据从程序流出】）。 

流的分类

1、按照方向来分类：输入流（InputStream）、输出流（OutputStream）。

2、按照类型来分类：字节流（XXXStream）、字符流（Writer、Reader）。

3、按照操作方式来分类：节点流、过滤流

4、转换流（InputStremReader、OutPutStreamReader）

输入流

使用IO流的基本步骤：
1、定义流
2、创建流
3、创建一个字节数组来存取读取的信息
4、使用一个整数len来表示读取的长度
5、循环读取数据，只要len大于0说明读取到元素，可以直接对元素进行操作
6、读取完成后使用close方法关闭流

流使用完成后应记得在finally块中关闭

通过文件输入流读取文件内容，并在控制台打印：

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class InputStreamTest {
	public static void main(String[] args) {
		//1、定义一个文件流
		FileInputStream fis = null;
		try {
			//2、创建流
			fis = new FileInputStream("d:/1.txt");
			//3、创建一个文件输入流
			byte[] array = new byte[1024];
			//4、创建一个字节数组来存取读取的信息
			int len = 0;
			//5、循环读取数据，只要len大于0说明读取到元素，可以直接对元素进行操作
			while((len = fis.read(array))!=-1)
			{
				System.out.write(array,0,len);
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally
		{
			try {
				if(fis != null)
				{
					//读取完成后使用close方法关闭流
					fis.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

输出流

通过文件输出流实现实现文件的拷贝：

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

public class CopyFile {
	public static void main(String[] args) {
		FileInputStream fis = null;
		FileOutputStream fos = null;
		
		try {
			fis = new FileInputStream("d:/1.txt");
			//创建一个文件输出流
			fos = new FileOutputStream("d:/temp.txt");
			
			byte[] array = new byte[1024];
			int len = 0;
			//将数据通过输入流读取到程序中
			while((len = fis.read(array)) != -1)
			{
				//将数据通过输出流输出，此时是一个文件输出流，就把数据输出到文件中
				fos.write(array, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally
		{
			//关闭流
			try {
				if(fos != null)
				{
					fos.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
			try {
				if(fis != null)
				{
					fis.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

字节流

通过字节读取数据，通常是XXXStream

字符流

通过字符来读取数据,只要处理的数据是字符数据，全部用字符流
Writer和Reader


对于字符流而言：读用BufferedReader，写用PrintWriter


字符流用来读取字符数据，对于输入字符流而言，最为常用操作方法使用BufferedReader,因为该流有一个readLine()方法，该方法可以一行一行的读取数据并且返回字符串

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;

public class CharacterTest {
	public static void main(String[] args) {
		BufferedReader br = null;
		PrintWriter pw = null;
		
		try {
			br = new BufferedReader(new FileReader("d:/1.txt"));
			//使用文件字符流写文件，加上缓冲流提高效率，写用PrintWriter
			pw = new PrintWriter(new BufferedWriter(new FileWriter("d:/temp.txt")));
			
			String str = null;
			
			while((str = br.readLine()) != null)
			{
				pw.println(str);
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally
		{
			if(pw != null)
			{
				pw.close();
			}
			
			if(br != null)
			{
				try {
					br.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
	}
}

节点流

可以直接创建的流

过滤流

可以装饰节点流，增加相应的功能

对于缓冲流，一定要关闭，不然如果缓冲区不满就不会刷新，可以通过bos.flush()刷新缓冲

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class FilterTest {
	public static void main(String[] args) {
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		
		try {
			//在文件输入流的基础上加入一个缓冲流，以此提高效率
			bis = new BufferedInputStream(new FileInputStream("C:\\Users\\asus\\Pictures\\1.jpg"));
			bos = new BufferedOutputStream(new FileOutputStream("d:/temp.jpg"));
			
			byte[] array = new byte[1024];
			int len = 0;
			
			while((len = bis.read(array)) != -1)
			{
				bos.write(array, 0, len);
			}
			
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally
		{
			//对于缓冲流，一定要关闭，不然如果缓冲区不满就不会刷新，可以通过bos.flust()刷新缓冲
			try {
				if(bis != null)
				{
					bis.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		
			try {
				if(bos != null)
				{
					bos.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			
		}
	}
}

转换流

将字节流转换为字符流

InputStreamReader

OutputStreamWriter

在控制台输入，直到输入exit时退出程序：

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

public class Consoletest {
	public static void main(String[] args) {
		BufferedReader br = null;
		
		try {
			//把字节流转换为字符流方便进行字符处理
			br = new BufferedReader(new InputStreamReader(System.in));
			String str = null;
			while((str = br.readLine()) != null)
			{
				if("exit".equals(str))
				{
					break;
				}	
				System.out.println(str);
			}
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		finally
		{
			try {
				if(br != null)
				{
					br.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

流的操作

字节流的常用操作

读：

写：

字符流的操作

读数据使用BufferedReader，因为有readLine()方法，写数据使用PrintWriter,可以使用println

标准流的操作

System.in是标准输入流，但是由于是字节流，不方便操作，所以通过情况会将其转换为字符流来处理，通过转换流转换，然后再使用BufferedReader来封装

常用流

a)文件流（File）：

非常常用，进行文件的读写操作

b)

缓冲流（Buffered）:

过滤流用来提高效率的

c)数据流:

用来读取基本数据类型DataOuputStream和DateInputStream，数据流是过滤流

d)对象流（Object）:对象流可以完成对对象的存储

1、必须实现Serializable接口

2、可以把一些属性设置为transient,此时这个属性就不会被存储

读取和存储对象可以使用ObjectOutputStream和ObjectInputStream读取，如果要从文件中读取，需要用这两个流封装一下文件流

序列化

1、一个类若想被序列化，则需要实现java.io.Serializable接口，该接口中没有定义任何方法，是一个标识性接口（Marker Interface），当一个类实现了该接口，就表示这个类的对象是可以序列化的。

2、在序列化时，static变量是无法序列化的；如果A包含了对B的引用，那么在序列化A的时候也会将B一并地序列化；如果此时A可以序列化，B无法序列化，那么当序列化A的时候就会发生异常，这时就需要将对B的引用设为transient，该关键字表示变量不会被序列化。

IO流中的装饰模式。。。