I/O流

content:
1.流的基本概念

2.输入和输出

3.InputStream/OutputStream/Reader/Writer

4.对象序列化

5.源代码

 

 

一、流的基本概念：

      1. IO流可以理解为JAVA用来传递数据的管道，  创建一个IO,就相当于将管道与某个数据源连接到一起了.

      2.关系描述图：

 

 

二、输入和输出

1.输入是从数据源（文件、内存、网络等）读取数据。如：

   InputStream – 一个字节一个字节(byte)地从数据源读取
    Reader – 一个字符一个字符(char)地从数据源读取

2.输出是往某个目标数据源中写入数据。如：

   OutputStream – 一个字节一个字节地往数据源写入
    Writer – 一个字符一个字符地往数据源写入

 

 

三、InputStream/OutputStream

1.InputStream

   //读取一个字节并以整数的形式返回(0~255),
   //如果返回-1已到输入流的末尾。
   int read() throws IOException

   //读取一系列字节并存储到一个数组buffer，
   //返回实际读取的字节数，如果读取前已到输入流的末尾返回-1
    int read(byte[] buffer) throws IOException

    //读取length个字节
    //并存储到一个字节数组buffer，从off位置开始存,最多len
    //返回实际读取的字节数，如果读取前以到输入流的末尾返回-1
    int read(byte[] buffer, int off, int len) throws IOException
    //关闭流释放内存资源
   void close() throws IOException
 

2.OutputStream

   //向输出流中写入一个字节数据,该字节数据为参数b的低8位
   void write(int b) throws IOException

   //将一个字节类型的数组中的数据写入输出流
   void write(byte[] b) throws IOException

   //将一个字节类型的数组中的从指定位置（off）开始的
    //len个字节写入到输出流
    void write(byte[] b, int off, int len)  throws IOException
    //关闭流释放内存资源  
   void close() throws IOException

    //将输出流中缓冲的数据全部写出到目的地
    void flush() throws IOException

 

3.Reader

     //读取一个字符并以整数的形式返回(0~255),
     //如果返回-1已到输入流的末尾。
    int read() throws IOException

     //读取一系列字符并存储到一个数组buffer，
     //返回实际读取的字符数，如果读取前已到输入流的末尾返回-1
     int read(char[] cbuf) throws IOException

      //读取length个字符
     //并存储到一个数组buffer，从off位置开始存,最多读取len
     //返回实际读取的字符数，如果读取前以到输入流的末尾返回-1
      int read(char[] cbuf, int off, int len) throws IOException
      //关闭流释放内存资源
      void close() throws IOException

 

4.Writer

    //向输出流中写入一个字符数据,该字节数据为参数b的低16位
    void write(int c) throws IOException
    //将一个字符类型的数组中的数据写入输出流，
    void write(char[] cbuf) throws IOException
    //将一个字符类型的数组中的从指定位置（offset）开始的
    //length个字符写入到输出流
    void write(char[] cbuf, int offset, int length) throws IOException
    //将一个字符串中的字符写入到输出流
    void write(String string) throws IOException
    //将一个字符串从offset开始的length个字符写入到输出流
    void write(String string, int offset, int length) throws IOException
    //关闭流释放内存资源
    void close() throws IOException
    //将输出流中缓冲的数据全部写出到目的地
   void flush() throws IOException

 

四、常见的原始流类。如：

     FileInputStream/FileOutputStream – 把文件当数据源
    ByteArrayInputStream/ByteArrayOutputStream - 把byte[]当数据源
    StringReader/StringWriter – 把String当数据源
    CharArrayReader/CharArrayWriter – 把char[]当数据源
    FileReader/FileWriter – 把文件当数据源的Reader/Writer
    InputStreamReader/OutputStreamWriter – 把InputStream/OutputStream当成数据源的Reader/Writer

其中FileInputStream/FileOutputStream--一般用于操作二进制文件

       FileReader/FileWriter   一般用于操作文本文件

五、对象序列化

1.要对一个对象实现序列化，此对象应需实现serializable或Externalizable接口。其中实现Serializable接口最常见。

2.除了一个对象要时间Serializable接口外，类内部的所有属性也必须得是可序列化的（即实现了Serializable接口）。所有的基本数据类型，及常见的其它数据类型（比如：String、Date、List、Map等等）都是可序列化的！
六、常见程序源代码：
1.如何拷贝一个文件：

public static void main(String[] args){
		try {
			String source = "D:/word.txt";
			String dest = "D:/user.txt";
			
			//指定数据源（文件路径），创建FileInputStream
			FileInputStream fis = new FileInputStream(source);
			
			//指定数据源（文件路径），创建FileOutputStream
			FileOutputStream fos = new FileOutputStream(dest);
			
			//定义一个内存缓冲区，以便接收从InputStream读出来的数据
			byte[] cache = new byte[1024];
			
			//定义一个临时变量len，用来存放每次具体读取了多少个字节
			int len = 0;
			
			//从InputStream读取数据，放到内存缓冲区，read(byte[])方法
			//的返回值就是实际读取的字节数，如果已经到了文件的结束，返回-1
			while((len = fis.read(cache)) != -1){
				//将内存缓冲区中的数据写入目标FileOutputStream
				//将实际读取的字节数写入，所以需要后面两个参数
				fos.write(cache, 0, len);
			}
			
			fis.close();
			fos.flush();
			fos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}

 2.使用缓冲区读取文件

	public static void main(String[] args) throws Exception{
		
		String source = "d:\word.txt";
		
		//使用缓冲，提高文件的读写性能！
		BufferedReader reader = new BufferedReader(
				new FileReader(source)
			);
		//我们将文件的内容存放在一个StringBuffer中
		StringBuffer sb = new StringBuffer();
		
		//文本文件也是一段一段读取的，定义一个临时缓冲区
		char[] chars = new char[1024];
		int len = 0;
		while((len = reader.read(chars)) != -1){
			sb.append(chars,0,len);
		}
		//关闭输入流，释放资源
		reader.close();
		System.out.println(sb.toString());
	}

 

3.java序列化

public class Persistence {
	private static Map variables = null;
	private static String file = System.getProperty("java.io.dir") + "/temp.object";
	static{
		try{
			if(new File(file).exists()){
				FileInputStream in = new FileInputStream(file);
				ObjectInputStream s = new ObjectInputStream(in); 
			    	variables = (Map)s.readObject();
				s.close();
			}
			if(variables == null){
				variables = new HashMap();
			}
		}catch(Exception e){
			e.printStackTrace();
		}
	}
       //输出一个变量的值
	public static void setVariable(String name,Serializable object){
		if(variables != null){
			variables.put(name, object);
		}
		try {
			FileOutputStream fos = new FileOutputStream(tmpfile);
			ObjectOutputStream oos = new ObjectOutputStream(fos);
			oos.writeObject(variables);
			oos.flush();
			oos.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	//获取一个变量的值
	public static Serializable getVariable(String name){
		if(variables != null){
			return (Serializable)variables.get(name);
		}
		return null;
	}
}