IO流

   流 是一种抽象概念，它代表了数据的无结构化传递。按照流的方式进行输入输出，数据被当成无结构的字节序或字符序列。从流中取得数据的操作称为提取操作，而向流中添加数据的操作称为插入操作。用来进行输入输出操作的流就称为IO流。换句话说，IO流就是以流的方式进行输入输出。

                 流的简介

                 

              IO流的分类

      ①根据处理数据类型的不同分为：字符流和字节流

      ②根据数据流向不同分为：输入流和输出流

                   字符流和字节流

           一、字符流的由来：因为数据编码的不同，而有了对字符进行高效操作的流对象。本质其实就是基于字节流读取时，去查了指定的码表。

               二、字符流与字节流的区别：

              ①读写单位不同：字节流以字节（8bit）为单位，字符流以字符为单位，根据码表映射字符，一次可能读多个字节。

              ②处理对象不同：字节流能处理所有类型的数据（如图片、avi等），而字符流只能处理字符类型的数据。

                结论：只要是处理纯文本数据，就优先考虑使用字符流。 除此之外都使用字节流。

  

          字节流输入与输出

               1、 字节输入流------InputStream

1. InputStream 是所有的输入字节流的父类，它是一个抽象类。
2. ByteArrayInputStream、StringBufferInputStream、FileInputStream 是三种基本的介质流，它们分别从Byte 数组、StringBuffer、和本地文件中读取数据。PipedInputStream 是从与其它线程共用的管道中读取数据，与Piped 相关的知识后续单独介绍。
3. ObjectInputStream 和所有FilterInputStream 的子类都是装饰流（装饰器模式的主角）。

            代码实现:

[java]  view plain  copy

1. import java.io.BufferedInputStream;  
2. import java.io.BufferedOutputStream;  
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import java.io.FileNotFoundException;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. /** 
9.  * 实现文件的复制（字节流） 
10.  * 1.来一个文件 
11.  * 2.读文件 
12.  * 3.写文件 
13.  * @author 尹日成 
14.  * 
15.  */  
16.   
17. public class TestCopy {  
18.     public static void main(String[] args) {  
19.         //文件原路径  
20.         File f=new File("F:\\卓京\\S2复习\\03.复习JSP\\讲解视频\\JSP_02讲解.webm");   
21.         //文件存放路径  
22.         File fileout=new File("D:\\桌面文件\\桌面\\A\\a");      
23.         try {  
24.             //文件的字节输入流  
25.             FileInputStream fis = new FileInputStream(f);  
26.             //文件字节缓冲输入流  
27.             BufferedInputStream bis=new BufferedInputStream(fis);  
28.             //文件的字节输出流  
29.             FileOutputStream fos=new FileOutputStream(fileout+"\\"+f.getName());  
30.             //文件字节缓冲输出流  
31.             BufferedOutputStream bos=new BufferedOutputStream(fos);  
32.              int len=0;  
33.              byte b[]=new byte[1024];  
34.              long star=System.currentTimeMillis();  
35.              System.out.println("开始时间为："+star);  
36.              //没有使用缓冲流  
37.            /*  while((len=fis.read(b))!=-1){ 
38.                  //写 
39.                  fos.write(b, 0, len); 
40.              }*/  
41.              //使用缓冲流  
42.              while((len=bis.read(b))!=-1){  
43.                  bos.write(b, 0, len);  
44.              }  
45.              //关闭流  
46.              bos.close();  
47.              bis.close();  
48.              long stop=System.currentTimeMillis();  
49.              System.out.println("结束时间为："+stop);  
50.              System.out.println("复制OK:"+(stop-star));  
51.   
52.         } catch (FileNotFoundException e) {  
53.             e.printStackTrace();  
54.         } catch (IOException e) {  
55.             e.printStackTrace();  
56.         }     
57.     }  
58. }  

               2、字节输出流------OutputStream

1. OutputStream 是所有的输出字节流的父类，它是一个抽象类。
2. ByteArrayOutputStream、FileOutputStream 是两种基本的介质流，它们分别向Byte 数组、和本地文件中写入数据。PipedOutputStream 是向与其它线程共用的管道中写入数据，
3. ObjectOutputStream 和所有FilterOutputStream 的子类都是装饰流。

           字符流输入与输出

           1、 字符输入流------Reader

       

1. Reader 是所有的输入字符流的父类，它是一个抽象类。
2. CharReader、StringReader 是两种基本的介质流，它们分别将Char 数组、String中读取数据。PipedReader 是从与其它线程共用的管道中读取数据。
3. BufferedReader 很明显就是一个装饰器，它和其子类负责装饰其它Reader 对象。
4. FilterReader 是所有自定义具体装饰流的父类，其子类PushbackReader 对Reader 对象进行装饰，会增加一个行号。
5. InputStreamReader 是一个连接字节流和字符流的桥梁，它将字节流转变为字符流。FileReader 可以说是一个达到此功能、常用的工具类，在其源代码中明显使用了将FileInputStream 转变为Reader 的方法。我们可以从这个类中得到一定的技巧。Reader 中各个类的用途和使用方法基本和InputStream 中的类使用一致。后面会有Reader 与InputStream 的对应关系。

             2、字符输出流------Writer

      

1. Writer 是所有的输出字符流的父类，它是一个抽象类。
2. CharArrayWriter、StringWriter 是两种基本的介质流，它们分别向Char 数组、String 中写入数据。PipedWriter 是向与其它线程共用的管道中写入数据，
3. BufferedWriter 是一个装饰器为Writer 提供缓冲功能。
4. PrintWriter 和PrintStream 极其类似，功能和使用也非常相似。
5. OutputStreamWriter 是OutputStream 到Writer 转换的桥梁，它的子类FileWriter 其实就是一个实现此功能的具体类（具体可以研究一SourceCode）。功能和使用和OutputStream 极其类似，后面会有它们的对应图。

代码实现：

[java]  view plain  copy

1. import java.io.File;  
2. import java.io.FileInputStream;  
3. import java.io.FileNotFoundException;  
4. import java.io.FileOutputStream;  
5. import java.io.IOException;  
6. /** 
7.  * 需求： 字节流 
8.  * 指定一个文件： 
9.  *  如果这个文件存在，则读取这个文件中的内容 
10.  *  如果这个文件不存在，则写内容到这个文件中 
11.  *  
12.  * @author 尹日成 
13.  * 
14.  */  
15.   
16. public class TestFileByStream {  
17.     public static void main(String[] args) {  
18.         File f=new File("file.text");  
19.         //1.首先判断是否存在该文件夹(或者文件夹)  
20.         if(!f.exists()){  
21.             //1.1不存在 -我们就创建一个文件  
22.             System.out.println("该文件不存在,正在创建该文件...");  
23.             try {  
24.                 boolean b=f.createNewFile();  
25.                 if(b){  
26.                     //1.1.1创建成功  
27.                     System.out.println("创建成功！");  
28.                     //在文件中写内容(字节流)  
29.                     FileOutputStream fos=new FileOutputStream(f);  
30.                     fos.write("复习字节流的读写".getBytes());  
31.                     fos.close();  
32.                 }  
33.                   
34.             } catch (IOException e) {  
35.                 e.printStackTrace();  
36.             }  
37.               
38.         }else{  
39.             //1.2存在  
40.             //直接读取内容  
41.             try {  
42.                 FileInputStream fis=new FileInputStream(f);  
43.                 byte b[]=new byte[1024];  
44.                 int len=0;  
45.                 try {  
46.                     while((len=fis.read(b))!=-1){  
47.                         //将字节数组转成字符串  
48.                         String s=new String(b,0,len);  
49.                         System.out.println(s);  
50.                     }  
51.                 } catch (IOException e) {  
52.   
53.                     e.printStackTrace();  
54.                 }  
55.                 } catch (FileNotFoundException e) {  
56.   
57.                 e.printStackTrace();  
58.             }  
59.               
60.         }  
61.     }  
62.   
63. }  

            字节转字符流

          ①转换流的特点

1. 其是字符流和字节流之间的桥梁
2. 可对读取到的字节数据经过指定编码转换成字符
3. 可对读取到的字符数据经过指定编码转换成字节

          ②何时使用转换流

1. 当字节和字符之间有转换动作时；
2. 流操作的数据需要编码或解码时。

          ③具体的对象体现

1. InputStreamReader:字节到字符的桥梁
2. OutputStreamWriter:字符到字节的桥梁

           

这两个流对象是字符体系中的成员，它们有转换作用，本身又是字符流，所以在构造的时候需要传入字节流对象进来。

             ④代码实现

[java]  view plain  copy

1. import java.io.BufferedReader;  
2. import java.io.File;  
3. import java.io.FileInputStream;  
4. import java.io.FileNotFoundException;  
5. import java.io.IOException;  
6. import java.io.InputStreamReader;  
7. import java.io.PrintWriter;  
8.   
9. /** 
10.  * 转换流 
11.  * 实现文件的复制 
12.  * 1.来一个文件（字节流） 
13.  * 2.读文件 
14.  * 3.写文件 
15.  * @author 尹日成 
16.  * 
17.  */  
18.   
19. public class TestCopyChange {  
20.     public static void main(String[] args) {  
21.         File f=new File("change.text");//文件路径  
22.         try {  
23.             //获取字节文件输入流  
24.             FileInputStream fis=new FileInputStream(f);  
25.             //使用字符缓冲输入流  
26.             BufferedReader br=new BufferedReader(new InputStreamReader(fis));  
27.             String s=br.readLine();  
28.             System.out.println(s);    
29.             //打印流  
30.             PrintWriter pw=new PrintWriter(f);  
31.             pw.write("新内容");  
32.             pw.close();  
33.         } catch (FileNotFoundException e) {  
34.             e.printStackTrace();  
35.         } catch (IOException e) {  
36.             e.printStackTrace();  
37.         }                 
38.     }  
39. }  

     缓冲流

       缓存流是计算机领域中输入输出流的一种常见形式。包括BufferedInputStream/ BufferedOutputStream 类和BufferedReader/ BufferedWriter类。 

这种流把数据从原始流成块读入或把数据积累到一个 大数据块后再成批写出，通过减少 系统资源的读写次数来加快程序的执行。BufferedOutputstream 或BufferedWriter 类仅仅在缓冲区满或调用flush()方法时才将数据写到目的地。

缓存流是 过滤流，在创建具体流时需要给出一个InputStream / OutputStream 类型的流座位前端流，并可以指明缓冲区的大小。

Java序列化与反序列化

java序列化：是指把Java对象转换为字节序列的过程；

java反序列化：是指把字节序列恢复为Java对象的过程。

为什么需要序列化和反序列化呢？

我们知道，当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等， 而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，能否实现进程间的对象传送呢？答案是可以的。如何做到呢？这就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送；另一方面，接收方需要从字节序列中恢复出Java对象。

 当我们明晰了为什么需要Java序列化和反序列化后，我们很自然地会想Java序列化的好处。其好处一是实现了数据的持久化，通过序列化可以把数据永久地保存到硬盘上（通常存放在文件里），二是，利用序列化实现远程通信，即在网络上传送对象的字节序列。

代码实现：

实体类：Users

[java]  view plain  copy

1. import java.io.Serializable;  
2.   
3. public class Users implements Serializable{  
4.     private String uname;  
5.     private String upass;  
6.       
7.     public Users() {  
8.         super();  
9.         // TODO Auto-generated constructor stub  
10.     }  
11.   
12.     public Users(String uname, String upass) {  
13.         super();  
14.         this.uname = uname;  
15.         this.upass = upass;  
16.     }  
17.   
18.     public String getUname() {  
19.         return uname;  
20.     }  
21.   
22.     public void setUname(String uname) {  
23.         this.uname = uname;  
24.     }  
25.   
26.     public String getUpass() {  
27.         return upass;  
28.     }  
29.   
30.     public void setUpass(String upass) {  
31.         this.upass = upass;  
32.     }  
33.   
34.     @Override  
35.     public String toString() {  
36.         return "Users [uname=" + uname + ", upass=" + upass + "]";  
37.     }  
38.       
39.       
40.   
41. }  

实现类： 先执行注释的序列化，执行反序列化

[java]  view plain  copy

1. import java.io.FileInputStream;  
2. import java.io.FileNotFoundException;  
3. import java.io.FileOutputStream;  
4. import java.io.IOException;  
5. import java.io.ObjectInputStream;  
6. import java.io.ObjectOutputStream;  
7.   
8. import com.zking.entity.Users;  
9.   
10. public class TestSer {  
11.     public static void main(String[] args) {  
12.         Users u=new Users("admin","123");  
13.       
14.         try {  
15.             //序列化  
16.         /*  ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("ser.text")); 
17.             oos.writeObject(u); 
18.             oos.close();*/  
19.             //反序列化  
20.             ObjectInputStream ois=new ObjectInputStream(new FileInputStream("ser.text"));  
21.             try {  
22.                 Users u2=(Users) ois.readObject();  
23.                 System.out.println(u2);  
24.                 ois.close();  
25.             } catch (ClassNotFoundException e) {  
26.                 // TODO Auto-generated catch block  
27.                 e.printStackTrace();  
28.             }  
29.         } catch (FileNotFoundException e) {  
30.             // TODO Auto-generated catch block  
31.             e.printStackTrace();  
32.         } catch (IOException e) {  
33.             // TODO Auto-generated catch block  
34.             e.printStackTrace();  
35.         }  
36.           
37.         //反序列化  
38.           
39.     }  
40.