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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

        学到I/O流后,字节流、字符流的各个类很多,在开发过程中,判断使用哪个类是比较困难的。下面总结了选取流类型的方法,并提供了各种事例程序。在程序中也体现了字符流中的编码问题。
  1. public class ReadIn {

  2.         public static void main(String[] args) throws IOException{
  3.                 //testInputStream();
  4.                 //testIO();
  5.                 //readLine();
  6.                 //write_1();
  7.                 //write_2();
  8.                 //read_1();
  9.                 //read_2();
  10.                 system_in_out();

  11.         }
  12.        
  13.         public static void testInputStream() throws IOException{
  14.                 InputStream in = System.in;
  15.                 int by = in.read();
  16.                 int by2 = in.read();
  17.                 int by3 = in.read();
  18.                 int by4 = in.read();
  19.                
  20.                 //回车符也会被读取到,/r/n
  21.                 System.out.println(by);
  22.                 System.out.println(by2);
  23.                 System.out.println(by3);
  24.                 System.out.println(by4);
  25.         }
  26.        
  27.         public static void testIO() throws IOException{
  28.                
  29.                 //包装输入/输出流
  30.                 BufferedReader bufr =
  31.                         new BufferedReader(new InputStreamReader(System.in));
  32.                 BufferedWriter bufw =
  33.                         new BufferedWriter(new OutputStreamWriter(System.out));
  34.         }

  35.         /*
  36.          * 需求:实现控制台readLine方法。
  37.          * 通过键盘录入数据
  38.          * 当录入一行数据后,就将该行数据进行打印
  39.          * 如果录入的数据是over,就结束程序
  40.          *
  41.          * */
  42.        
  43.         public static void readLine() throws IOException{
  44.                 InputStream in = System.in;
  45.                 StringBuilder sb = new StringBuilder();
  46.                 int ch;
  47.                 int i = 0;
  48.                 while(true){
  49.                         ch = in.read();
  50.                         if(ch=='\r')
  51.                                 continue;
  52.                         if(ch=='\n'){
  53.                                 if("over".equals(sb.toString())){
  54.                                         break;
  55.                                 }
  56.                                 System.out.println(sb.toString());
  57.                                 sb.delete(0, sb.length());
  58.                         }else{
  59.                                 sb.append((char)ch);
  60.                         }                       
  61.                 }
  62.         }
  63.        
  64.         /*
  65.          * 需求:
  66.          * 从控制台(键盘)录入数据,保存到文本中(硬盘),使用系统默认GBK编码。
  67.          *
  68.          * 分析:
  69.          *                 1、
  70.          *                 从控制台录入数据:Reader/InputStream
  71.          *                 录入文本内容:Reader
  72.          *                 键盘设备:标准输入流System.in
  73.          *                 使用系统默认GBK编码:InputStreamReader
  74.          *                 需要提高读取效率:BufferedReader
  75.          *
  76.          *                 2、
  77.          *                 向硬盘写数据:Writer/OutputStream
  78.          *                 写入的是文本文件:Writer
  79.          *                 使用系统默认GBK编码:FileWriter
  80.          *                 需要提高写入效率:BufferedWriter
  81.          * */       
  82.         public static void write_1(){
  83.                 BufferedReader bufr = null;
  84.                 BufferedWriter bufw =null;
  85.                 try{
  86.                         bufr = new BufferedReader(new InputStreamReader(System.in,"GBK"));//不写"GBK"即为默认
  87.                         bufw = new BufferedWriter(new FileWriter("TextFileFromSystemIn_GBK.txt"));//使用默认编码方式写入文件
  88.                         String s;
  89.                         while(!"over".equals(s=bufr.readLine())){
  90.                                 bufw.write(s);
  91.                                 bufw.newLine();
  92.                                 bufw.flush();
  93.                         }
  94.                         bufr.close();
  95.                         bufw.close();
  96.                        
  97.                 }catch(IOException e){
  98.                         throw new RuntimeException("读取/写入失败!");
  99.                 }finally{
  100.                         try{
  101.                                 if(null!=bufr)
  102.                                         bufr.close();
  103.                         }catch(IOException re){
  104.                                 throw new RuntimeException("关闭读取流失败!");
  105.                         }
  106.                         try{
  107.                                 if(null!=bufw)
  108.                                         bufr.close();
  109.                         }catch(IOException we){
  110.                                 throw new RuntimeException("关闭写入流失败!");
  111.                         }
  112.                 }
  113.         }
  114.        
  115.         /*
  116.          * 需求:
  117.          * 从控制台(键盘)录入数据,保存到文本中(硬盘),使用指定UTF-8编码。
  118.          *
  119.          * 分析:
  120.          *                 1、
  121.          *                 从控制台录入数据:Reader/InputStream
  122.          *                 录入文本内容:Reader
  123.          *                 键盘设备:标准输入流System.in
  124.          *                 使用指定的*****UTF-8*****编码:InputStreamReader
  125.          *                 需要提高读取效率:BufferedReader
  126.          *
  127.          *                 2、
  128.          *                 向硬盘写数据:Writer/OutputStream
  129.          *                 写入的是文本文件:Writer
  130.          *                 使用指定的*****UTF-8*****编码:FileOutputStream
  131.          *                 需要提高写入效率:BufferedWriter
  132.          * */
  133.         public static void write_2(){
  134.                 BufferedReader bufr = null;
  135.                 BufferedWriter bufw =null;
  136.                 try{
  137.                         bufr = new BufferedReader(new InputStreamReader(System.in));
  138.                        
  139.                         //将字节流(FileOutputStream)通过桥梁(OutputStreamWriter)转换成字符流(BufferedWriter);
  140.                         bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("TextFileFromSystemIn_UTF-8.txt"), "UTF-8"));
  141.                        
  142.                         //以下写法错误,OutputStreamWriter是字符流通向字节流的桥梁,不能使用字符流参数
  143.                         //bufw = new BufferedWriter(new OutputStreamWriter(new FileWriter(""), "UTF-8"));
  144.                        
  145.                         String s;
  146.                         while(!"over".equals(s=bufr.readLine())){
  147.                                 bufw.write(s);
  148.                                 bufw.newLine();
  149.                                 bufw.flush();
  150.                         }
  151.                         bufr.close();
  152.                         bufw.close();
  153.                        
  154.                 }catch(IOException e){
  155.                         throw new RuntimeException("读取/写入失败!");
  156.                 }finally{
  157.                         try{
  158.                                 if(null!=bufr)
  159.                                         bufr.close();
  160.                         }catch(IOException re){
  161.                                 throw new RuntimeException("关闭读取流失败!");
  162.                         }
  163.                         try{
  164.                                 if(null!=bufw)
  165.                                         bufr.close();
  166.                         }catch(IOException we){
  167.                                 throw new RuntimeException("关闭写入流失败!");
  168.                         }
  169.                 }
  170.         }
  171.        
  172.         /*
  173.          * 需求:
  174.          * 从硬盘读取一个文本文件,将内容打印到控制台,使用系统默认GBK编码。
  175.          * 分析:
  176.          *                 1、
  177.          *                 读取数据:Reader/InputStream
  178.          *                 读取文本:Reader
  179.          *                 硬盘文件:FileReader
  180.          *                 编码系统默认GBK:FileReader
  181.          *                 需要优化效率:BufferedReader
  182.          *                
  183.          *                 2、
  184.          *                 输出数据:Writer/OutputStream
  185.          *                 文本:Writer
  186.          *                 输出到控制台:标准输出设备System.out
  187.          *                 编码系统默认GBK:System.out
  188.          *                                 (需要转换编码时就用到OutputStreamWriter,)
  189.          *                 需要提高效率:BufferedWriter
  190.          *                                 (此处只是为了做演示,所以用BufferedWriter包装System.out,此时就用到了OutputStreamWriter)
  191.          *
  192.          * */
  193.         public static void read_1(){
  194.                 BufferedReader bufr = null;
  195.                 BufferedWriter bufw = null;
  196.                 try{
  197.                         //此处读取的是GBK编码文件,若读取UTF-8编码的文件会出现乱码
  198.                         bufr = new BufferedReader(new FileReader("TextFileFromSystemIn_GBK.txt"));
  199.                         //乱码
  200.                         //bufr = new BufferedReader(new FileReader("TextFileFromSystemIn_UTF-8.txt"));
  201.                         bufw = new BufferedWriter(new OutputStreamWriter(System.out));       
  202.                         String s ;
  203.                         while((s=bufr.readLine())!=null){
  204.                                 bufw.write(s);
  205.                                 bufw.newLine();
  206.                                 bufw.flush();
  207.                         }
  208.                 }catch(IOException e){
  209.                         throw new RuntimeException("读取/写入失败!");
  210.                 }finally{
  211.                         try{
  212.                                 if(null!=bufr)
  213.                                         bufr.close();
  214.                         }catch(IOException re){
  215.                                 throw new RuntimeException("关闭读取流失败!");
  216.                         }
  217.                         try{
  218.                                 if(null!=bufw)
  219.                                         bufr.close();
  220.                         }catch(IOException we){
  221.                                 throw new RuntimeException("关闭写入流失败!");
  222.                         }
  223.                 }
  224.         }
  225.        
  226.         /*
  227.          * 需求:
  228.          * 从硬盘读取一个文本文件,将内容打印到控制台,使用指定UTF-8编码。
  229.          *
  230.          * * 分析:
  231.          *                 1、
  232.          *                 读取数据:Reader/InputStream
  233.          *                 读取文本:Reader
  234.          *                 硬盘文件:FileReader
  235.          *                 编码指定UTF-8:******InputStreamReader******
  236.          *                 需要优化效率:BufferedReader
  237.          *                
  238.          *                 2、
  239.          *                 输出数据:Writer/OutputStream
  240.          *                 文本:Writer
  241.          *                 输出到控制台:标准输出设备System.out
  242.          *                 编码系统默认GBK:System.out
  243.          *                                 (需要转换编码时就用到OutputStreamWriter,)
  244.          *                 需要提高效率:BufferedWriter
  245.          *                                 (此处只是为了做演示,所以用BufferedWriter包装System.out,此时就用到了OutputStreamWriter)
  246.          *
  247.          * */
  248.                 public static void read_2(){
  249.                         BufferedReader bufr = null;
  250.                         BufferedWriter bufw = null;
  251.                         try{
  252.                                 //此处读取的是UTF-8编码的文件,需要用字节流读取,然后指定UTF-8编码查表,再转换成字符流。
  253.                                 bufr = new BufferedReader(new InputStreamReader(new FileInputStream("TextFileFromSystemIn_UTF-8.txt"),"UTF-8"));
  254.                                 //标准输出设备接收的是GBK编码的字符流,不能指定为"UTF-8",否则乱码
  255.                                 bufw = new BufferedWriter(new OutputStreamWriter(System.out));
  256.                                 //乱码
  257.                                 //bufw = new BufferedWriter(new OutputStreamWriter(System.out));
  258.                                 String s ;
  259.                                 while((s=bufr.readLine())!=null){
  260.                                         bufw.write(s);
  261.                                         bufw.newLine();
  262.                                         bufw.flush();
  263.                                 }
  264.                         }catch(IOException e){
  265.                                 throw new RuntimeException("读取/写入失败!");
  266.                         }finally{
  267.                                 try{
  268.                                         if(null!=bufr)
  269.                                                 bufr.close();
  270.                                 }catch(IOException re){
  271.                                         throw new RuntimeException("关闭读取流失败!");
  272.                                 }
  273.                                 try{
  274.                                         if(null!=bufw)
  275.                                                 bufr.close();
  276.                                 }catch(IOException we){
  277.                                         throw new RuntimeException("关闭写入流失败!");
  278.                                 }
  279.                         }
  280.                 }
  281.                
  282.                 /**
  283.                  * 重定向标准输入/输出设备
  284.                  * 将System.in和System.out的源和目的,改成指定的文件
  285.                  * 实现文件的复制
  286.                  * @throws IOException
  287.                  */
  288.                 public static void system_in_out() throws IOException{
  289.                         //指定数据源为一个文件
  290.                         System.setIn(new FileInputStream("CopyTextFile.java"));
  291.                         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  292.                         //指定输出到另一个文件
  293.                         System.setOut(new PrintStream("PrintStream.txt"));
  294.                         String s;
  295.                         //将文件内复制到另一个文件
  296.                         while((s=bufr.readLine())!=null){
  297.                                 System.out.println(s);
  298.                         }
  299.                 }
  300. }
复制代码



0 个回复

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