A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© yangkai69 中级黑马   /  2015-8-21 23:30  /  279 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

IO流是用来处理数据的输入和输出的流,分为字节流和字符流,字节流可处理所有文件,字符流只能处理二进制的文件,字符流的处理效率高与字符流。
以下是一些IO流常用的操作:
  1. /**
  2. * 功能:演示IO流字节流的一些常用功能,
  3. * 以下代码包括
  4. * 1、字节流读取文件的方法
  5. * 2、字节流写入文件的方法
  6. * 3、字节流复制文件的方法
  7. * 4、字符流读取文件的方法
  8. * 5、字符流写入文件的方法
  9. * 6、字符流复制文件的方法
  10. * 7、带缓冲功能的字符流复制文件的方法
  11. *
  12. */

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

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





复制代码

0 个回复

您需要登录后才可以回帖 登录 | 加入黑马