概述：

  1. 什么是IO?
    input/output 输入输出
  2. Java如何处理IO？
    1. java把不同的输入/输出（键盘、文件、网络等）抽象描述为 "流"（stream）。
    2. 用相同的方式--"流"来处理 不同的输入/输出。
  3. 什么是"流"？
    和电流、水流一样，只不过这里是数据流。
  4. 流的分类 (具体解释看扩展阅读)
    1. 输入流/输出流（流向）
    2. 字节流和字符流
  5. 字节流和字符流的转化：
    InputStreamReader 和 OutputStreamWriter
  6. java io功能强大看似复杂但实际是有规律的，它采用的是“装饰器设计模式”。
  7. 部分io相关类
    解释： 
    文件流：顾名思义，提供了更加便利和强大的文件流操作。 
    缓冲流：增加了缓冲功能，提高了读写效率 但是注意一定要是使用flush()方法来处理缓冲区。 
    转换流：将字节流转换成字符流。 
    管道流：处理线程之间的通讯。 
    更多的请看java.io包
  8. 序列化(请关注后续文章)

 

程序演示： 

  1. package com.cxyapi.io;  
  2.   
  3. import java.io.BufferedInputStream;  
  4. import java.io.BufferedOutputStream;  
  5. import java.io.File;  
  6. import java.io.FileInputStream;  
  7. import java.io.FileOutputStream;  
  8. import java.io.FileWriter;  
  9. import java.io.InputStream;  
  10. import java.io.OutputStream;  
  11.   
  12. /** IO 
  13.  * @author cxy @ www.cxyapi.com 
  14.  */  
  15. public class IoTest  
  16. {  
  17.     public static void main(String[] args) throws Exception  
  18.     {  
  19.         writeDataToFile();  
  20.         System.out.println("-------------------------");  
  21.         readDataFromFile();  
  22.         System.out.println("-------------------------");  
  23.         copyFile("D:"+File.separator, "cxyapi.txt", "D:"+File.separator, "cxyapi复制.txt");  
  24.     }  
  25.       
  26.     /**写数据到文件 站在内存角度 将内存输出到文件，所以应该用输出流 
  27.      * @throws Exception 
  28.      */  
  29.     public static void writeDataToFile() throws Exception  
  30.     {  
  31.         String filePath="d:/cxyapi.txt";  
  32.         File f=new File(filePath);  
  33.         if(!f.exists())  
  34.         {  
  35.             f.createNewFile();  
  36.         }  
  37.           
  38.         OutputStream out=new FileOutputStream(f);  
  39.         String str="更多内容请访问：\r\nwww.cxyapi.com";  
  40.         byte[] buffer=str.getBytes();  
  41.         out.write(buffer);  
  42.         out.flush();  
  43.         out.close();  
  44.         System.out.println("文件写入完成");  
  45.     }  
  46.       
  47.     /**从文件读取数据 
  48.      * @throws Exception 
  49.      */  
  50.     public static void readDataFromFile() throws Exception  
  51.     {  
  52.         String filePath="d:/cxyapi.txt";  
  53.         File f=new File(filePath);  
  54.         if(!f.exists())  
  55.         {  
  56.             f.createNewFile();  
  57.         }  
  58.         InputStream in=new FileInputStream(f);    
  59.         byte[] buffer=new byte[(int)f.length()];  
  60.         int len=in.read(buffer);  
  61.         in.close();  
  62.         System.out.println(new String(buffer,0,len));  
  63.         //System.out.println("完成");  
  64.     }  
  65.       
  66.     /** 文件拷贝 字节流 (通用) 
  67.      * 字节流的方式和这个类似，只不过使用的是(FileReader和FileWriter)， 
  68.      * 但是他只能拷贝字符文件，字节文件 会出现文件丢失数据的情况。 
  69.      * 所以为了通用 这里只展示通用的字节流方式 
  70.      */  
  71.     public static void copyFile(String fromPath,String fromFileName,String toPath,String tofileName) throws Exception  
  72.     {  
  73.         long st=System.currentTimeMillis();  
  74.         File f1=new File(fromPath+File.separator+fromFileName);  
  75.         File f2=new File(toPath+File.separator+tofileName);  
  76.           
  77.         if(!f1.exists())  
  78.         {  
  79.             System.out.println("源文件不存在!");  
  80.             return;  
  81.         }  
  82.           
  83.         if(!f2.exists())  
  84.         {  
  85.             f2.createNewFile();  
  86.         }  
  87.           
  88.         //装饰器  
  89.         //new BufferedWriter(new OutputStreamWriter(new BufferedOutputStream(new FileOutputStream(f2))));  
  90.         BufferedInputStream br=new BufferedInputStream(new FileInputStream(f1));  
  91.         BufferedOutputStream bw=new BufferedOutputStream(new FileOutputStream(f2));  
  92.         //水桶打水的方式  
  93.         byte[] temp=new byte[256]; //“数据桶”，这个桶的大小视数据大小情况而定  
  94.         int read=0;  
  95.         while((read=br.read(temp))!=-1)  
  96.         {  
  97.             bw.write(temp,0,read);  
  98.         }  
  99.         bw.flush();  
  100.         //关闭操作应该放到finally块中，这里简单演示  
  101.         bw.close();  
  102.         br.close();  
  103.         long et=System.currentTimeMillis();  
  104.         System.out.println("拷贝完成，耗时:"+(et-st));  
  105.     }  
  106. }  

 

转载请加本站连接: 

  • 1.如何判断是输入流 还是输出流？

    这是一个相对问题！关键是找好参照？输入输出都是从程序运行所在的内存角度来看。
    我的记法： input*.read(); output*.write(); 最后你只要知道你现在是读还是写即可。

  • 2.字节流和字符流

    字节流操作数据的单元是8位的字节，字符流是16位的字符。
    字节流：InputStream和OutputStream作为父类。
    字符流：Reader和Write作为父类。
    处理文本的建议用 字符流。
    处理其他的建议用 字节流。
    比较通用的就是字节流。