黑马程序员技术交流社区

标题: IO流的一些总结 [打印本页]
作者: yangkai69    时间: 2015-8-21 23:30
标题: IO流的一些总结
IO流是用来处理数据的输入和输出的流，分为字节流和字符流，字节流可处理所有文件，字符流只能处理二进制的文件，字符流的处理效率高与字符流。
以下是一些IO流常用的操作：
  1. /**
  2. * 功能：演示IO流字节流的一些常用功能,
  3. * 以下代码包括
  4. * 1、字节流读取文件的方法
  5. * 2、字节流写入文件的方法
  6. * 3、字节流复制文件的方法
  7. * 4、字符流读取文件的方法
  8. * 5、字符流写入文件的方法
  9. * 6、字符流复制文件的方法
  10. * 7、带缓冲功能的字符流复制文件的方法
  11. *
  12. */

  14. package myblog;
  15. import java.io.*;
  16. public class IoLiu {
  17.             
  18.         public static void main(String []args){

  20.         }
  21.     //字节流读取文件的方法
  22.         public static void dqmothed(File f)
  23.         {
  24.                 byte []bytes=new byte[1024];
  25.                 int n=0;
  26.                 FileInputStream fis=null;
  27.                 try {
  28.                         fis=new FileInputStream(f);
  29.                         while((n=fis.read(bytes))!=-1)
  30.                         {
  31.                                 System.out.println(new String(bytes,0,n));
  32.                         }
  33.                 } catch (Exception e) {
  34.                         e.printStackTrace();
  35.                 }finally{
  36.                         try {
  37.                                 fis.close();
  38.                         } catch (IOException e) {
  39.                                 e.printStackTrace();
  40.                         }
  41.                 }
  42.         }
  43.        
  44.         //字节流写入文件的方法
  45.         public static void xrmothed(File f,String s)
  46.         {
  47.                 BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
  48.                 int n=0;
  49.                 FileOutputStream  fos=null;
  50.                 try {
  51.                         fos=new FileOutputStream(f);
  52.                        
  53.                        
  54.                                 fos.write(s.getBytes());
  55.                        
  56.                        
  57.                 } catch (Exception e) {
  58.                         e.printStackTrace();
  59.                 }finally{
  60.                         try {
  61.                                 fos.close();
  62.                         } catch (IOException e) {
  63.                                 e.printStackTrace();
  64.                         }
  65.                 }
  66.         }
  67.        
  68.         //字节流复制的功能的方法
  69.         public static void fzmothed(File f1,File f2)
  70.         {
  71.                 FileInputStream fis=null;
  72.                 FileOutputStream fos=null;
  73.                
  74.                 try {
  75.                         fis=new FileInputStream(f1);
  76.                         fos=new FileOutputStream(f2);
  77.                        
  78.                         byte []bytes=new byte[1024];
  79.                         int n=0;
  80.                         while((n=fis.read(bytes))!=-1)
  81.                         {
  82.                                 fos.write(bytes, 0, n);
  83.                         }
  84.                 } catch (Exception e) {
  85.                         e.printStackTrace();
  86.                 }finally{
  87.                         try {
  88.                                 fos.close();
  89.                                 fis.close();
  90.                         } catch (IOException e) {
  91.                                 // TODO Auto-generated catch block
  92.                                 e.printStackTrace();
  93.                         }
  94.                 }
  95.         }
  96.        
  97.         //字符流读取的方法
  98.         public static void zfldu(File f)
  99.         {
  100.                 FileReader fr=null;
  101.                 try {
  102.                         fr=new FileReader(f);
  103.                         char []c=new char[1024];
  104.                         int n=0;//记录读取的字符数
  105.                         while((n=fr.read(c))!=-1)
  106.                         {
  107.                                 String s=new String(c,0,n);
  108.                                 System.out.println(s);
  109.                         }
  110.                        
  111.                 } catch (Exception e) {
  112.                         e.printStackTrace();
  113.                 }finally{
  114.                         try {
  115.                                 fr.close();
  116.                         } catch (Exception e) {
  117.                                 e.printStackTrace();
  118.                         }
  119.                 }
  120.         }
  121.        
  122.        
  123.         //字符流写入的方法
  124.         public static void zflXie(File f,String s)
  125.         {
  126.                 FileWriter fw=null;
  127.                  try {
  128.                         fw=new FileWriter(f);
  129.                         fw.write(s);
  130.                 } catch (IOException e) {
  131.                         e.printStackTrace();
  132.                 }finally{
  133.                         try {
  134.                                 fw.close();
  135.                         } catch (IOException e) {
  136.                                 e.printStackTrace();
  137.                         }
  138.                 }
  139.         }
  140.        
  141.        
  142.         //字符流复制的方法
  143.         public static void zflfz(File f1,File f2)
  144.         {
  145.                 FileReader fr=null;
  146.                 FileWriter fw=null;
  147.                
  148.                 try {
  149.                         fr=new FileReader(f1);
  150.                         fw=new FileWriter(f2);
  151.                        
  152.                         char []c=new char[1024];
  153.                         int n=0;
  154.                        
  155.                         while((n=fr.read(c))!=-1)
  156.                         {
  157.                                 fw.write(c);
  158.                         }
  159.                 } catch (Exception e) {
  160.                        
  161.                         e.printStackTrace();
  162.                 }finally{
  163.                         try {
  164.                                 fw.close();
  165.                                 fr.close();
  166.                         } catch (IOException e) {
  167.                                
  168.                                 e.printStackTrace();
  169.                         }
  170.                 }
  171.         }
  172.        
  173.         //带缓冲功能的字符流复制方法
  174.         public static void bufferZflfz(File f1,File f2)
  175.         {
  176.                 BufferedReader br=null;
  177.                 BufferedWriter bw=null;
  178.                
  179.                 try {
  180.                         br=new BufferedReader(new FileReader(f1));
  181.                         bw=new BufferedWriter(new FileWriter(f2));
  182.                        
  183.                         char []c=new char[1024];
  184.                         int n=0;
  185.                         while((n=br.read(c))!=-1)
  186.                         {
  187.                                 bw.write(c, 0, n);
  188.                         }
  189.                        
  190.                        
  191.                 } catch (Exception e) {
  192.                        
  193.                         e.printStackTrace();
  194.                 } finally{
  195.                         try {
  196.                                 bw.close();
  197.                                 br.close();
  198.                         } catch (IOException e) {
  199.                                
  200.                                 e.printStackTrace();
  201.                         }
  202.                 }
  203.         }
  204.        
  205. }





复制代码




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2