现在的位置: 首页 > 综合 > 正文

java IO 流 黑马程序员_<<字节流(含子类)和字节缓冲流(InputStream,OutputStream,BufferedInputStream,BufferedOutputStream)>>黑马程序员_<<转换流(InputStreamReader,OutputStreamWriter)>>

2017年11月04日 ⁄ 综合 ⁄ 共 19566字 ⁄ 字号 小 中 大 ⁄ 评论关闭

 

黑马程序员_<<字节流(含子类)和字节缓冲流(InputStream,OutputStream,BufferedInputStream,BufferedOutputStream)>>

分类： IO流2013-10-03
12:53 120人阅读 评论(0) 收藏 举报
字节流InputStreamOutputStreamBufferedInputStreamBufferedOutputStream

目录(?)[+]

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！
--------------------

1.字节流

字符流：Writer，Reader 主要是用来操作的是文本文件

字节流：InputStream，OutputStream主要是用来操作的是媒体文件，例如：图片，音乐，电影…等。但是也可以操作文件。

 

如果用字符流操作媒体文件的话，复制文件的话：也能复制，只是复制后的图片不能看，因为查看的编码是不一样的，

不管是读还是写，都不需要刷新缓冲，除非用到了缓冲对象。

2. FileOutStream

     操作文件，向文本文件中写入数据，其没有写入字符串耳朵方法，有字节数组的写入，所以我们要把字符串转换成数组。然后写入。

 

 

[java] view
plaincopy

  1. importjava.io.FileNotFoundException;  
  2. importjava.io.FileOutputStream;  
  3. importjava.io.IOException;  
  4. importjava.io.OutputStream;  
  5.    
  6. public classOutStreamDemo {  
  7.       public static void main(String[]args)  {  
  8.            OutputStream out=null;  
  9.            try {  
  10.                  out=new FileOutputStream("F:\\demo.txt");  
  11.                  out.write("helloworld".getBytes());//写入数据，把字符串转换为字节数组  
  12.            } catch (IOException e) {  
  13.                  e.printStackTrace();  
  14.            }finally{  
  15.                  if(out!=null){  
  16.                       try {  
  17.                             out.close();  
  18.                       } catch (IOException e) {  
  19.                             e.printStackTrace();  
  20.                       }  
  21.                  }  
  22.            }  
  23.       }  
  24.    
  25. }  

3.     FileInputStream

读取文件，有三种方法，

第一种：一个一个字符的读取，

第二种：字节数组的读取。

第三种：使用available()方法，读取到文件的总大小，然后定义相同大小的字节数组，读取一次即可，但是加入文件过大，大于了虚拟的内存的大小，那么就会加载不进去，所以最好的办法是定义恰当合适的数组，然后循环读取。
 

          1.  单个字节读取

使用的read()方法，进行循环读取。

[java] view
plaincopy

  1. import java.io.FileInputStream;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4.    
  5. public class InputStreamDemo {  
  6.   public static void main(String[] args) {  
  7.     InputStream in = null;  
  8.     try {  
  9.       in = new FileInputStream("F:\\demo.txt");  
  10.       /* 这个为一个一个的读取，使用read()方法，然后读取到的字符的ASCII码，到结尾就返回-1*/  
  11.       int r = -1;  
  12.       while ((r = in.read()) != -1) {//开始读取  
  13.          System.out.print((char) r);  
  14.       }  
  15.     } catch (IOException e) {  
  16.       e.printStackTrace();  
  17.     }finally{  
  18.       if(in!=null){  
  19.          try {  
  20.            in.close();//关闭流  
  21.          } catch (IOException e) {  
  22.            e.printStackTrace();  
  23.          }  
  24.       }  
  25.     }  
  26.   }  
  27.    
  28. }  

         2.  字节数组读取

定义恰当的数组，然后循环读取 使用的read(byte [] b)
然后转换成字符串，返回。

[java] view
plaincopy

  1. import java.io.FileInputStream;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4.    
  5. public class InputStreamDemo {  
  6.   public static void main(String[] args) {  
  7.     InputStream in= null;  
  8.     try {  
  9.       in= new FileInputStream("F:\\demo.txt");  
  10.       /* 使用字节数组读取，然后转成字符串。到结尾就返回-1*/  
  11.       byte [] b=new byte[1024];  
  12.       int len=-1;  
  13.       while ((len = in.read(b)) != -1) {//开始读取  
  14.          System.out.print(new String(b,0,len));  
  15.       }  
  16.     } catch (IOException e) {  
  17.       e.printStackTrace();  
  18.     }finally{  
  19.       if(in!=null){  
  20.          try {  
  21.            in.close();//关闭流  
  22.          } catch (IOException e) {  
  23.            e.printStackTrace();  
  24.          }  
  25.       }  
  26.     }  
  27.   }  
  28.    
  29. }  

 

           3.  固定数组大小

使用的available()方法，读取到文件的大小，然后定义相应的大小的字节数组，如果文件小的话，可以这样使用，但是文件很大，超过了虚拟机的申请的内存，那么就会导致加载不进入，所以最好的方法是是哟第二种方法，定义合适的字节数组的大小。
 

[java] view
plaincopy

  1. import java.io.FileInputStream;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4.    
  5. public class InputStreamDemo {  
  6.   public static void main(String[] args) {  
  7.     InputStream in = null;  
  8.     try {  
  9.       in = new FileInputStream("F:\\demo.txt");  
  10.       /* 使用字节数组读取，数组的大小用：available()方法定，然后转成字符串。到结尾就返回-1 */  
  11.       byte[] b = new byte[in.available()];  
  12.       int len = in.read(b);  
  13.       System.out.print(new String(b, 0,len));  
  14.    
  15.     } catch (IOException e) {  
  16.       e.printStackTrace();  
  17.     } finally {  
  18.       if (in != null) {  
  19.          try {  
  20.            in.close();// 关闭流  
  21.          } catch (IOException e) {  
  22.            e.printStackTrace();  
  23.          }  
  24.       }  
  25.     }  
  26.   }  
  27.    
  28. }  

 

4. 复制图片

     使用的InputStream和OutputStream

     步骤：

     1.使用读取流InputStream，与要读取的图片关联。

     2.定义写入流，定义好复制到的位置和图片的名称。

     3.然后一边读取一边写入，循环读取和循环写入。使用的是数组读取和写入。

     4.最后关闭流。

   扩展：复制后的文件名称可以改变也可以不变，格式也可以改变，jpg或者bmp.或者其他的格式都可以

 

[java] view
plaincopy

  1. import java.io.FileInputStream;  
  2. import java.io.FileOutputStream;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.OutputStream;  
  6.    
  7. public class OutAndInputStreamDemo {  
  8.   public static void main(String[] args) {  
  9.     InputStream in = null;// 读取流字节流  
  10.     OutputStream out = null;// 写入流字节流  
  11.     try {  
  12.       in = new FileInputStream("F:\\A\\1.jpg");// 与复制的图片关联起来  
  13.       out = new FileOutputStream("F:\\B\\1.bmp");// 与复制到的目的关联起来，这里的图片的名称可以与原来的相同，也可以不一样  
  14.       byte[] b = new byte[1024];// 定义字节数组，并指定长度  
  15.       int l = -1;  
  16.       while ((l = in.read(b)) != -1) {// 读取  
  17.          out.write(b, 0, l);// 写入，读多少写入多少，所以用 write(b,0,len)  
  18.       }  
  19.       System.out.println("复制成功");  
  20.     } catch (IOException e) {  
  21.       e.printStackTrace();  
  22.     } finally {  
  23.       if (in != null) {  
  24.          try {  
  25.            in.close();// 关闭读取流  
  26.          } catch (IOException e) {  
  27.            System.out.println("读取流关闭失败");  
  28.          }  
  29.          if (out != null) {  
  30.            try {  
  31.              out.close();// 关闭写入流  
  32.            } catch (IOException e) {  
  33.              System.out.println("写入流关闭失败");  
  34.            }  
  35.          }  
  36.       }  
  37.    
  38.     }  
  39.   }  
  40.    
  41. }  
  42. 结果：  
  43. 复制成功  

5. 字节流的缓冲

      字符流：Writer，Reader

             BufferedWriter和BufferedReader

字节流：InputStream，OutputStream体文

                    BufferedInputStream和BufferedOutputStream

 

字节流的缓冲和字符流的花冲使用方法是类似的，用的对象是BufferedInputStream和BufferedOutputStream，他们增强了字节流的读取和写入效率。

         1.  利用缓冲对象复制MP3文件

 

[java] view
plaincopy

  1. package www.fuxi.IO;  
  2.    
  3. import java.io.BufferedInputStream;  
  4. import java.io.BufferedOutputStream;  
  5. import java.io.FileInputStream;  
  6. import java.io.FileOutputStream;  
  7. import java.io.IOException;  
  8.    
  9. public class BufferedStreamDemo {  
  10.   public static void main(String[] args) {  
  11.     BufferedInputStream bis = null;// 读取缓冲流  
  12.     BufferedOutputStream bos = null;// 写入缓冲流  
  13.     try {  
  14.       bis = new BufferedInputStream(new FileInputStream("F:\\A\\1.mp3"));// 要复制的MP3文件  
  15.       bos = new BufferedOutputStream(new FileOutputStream("F:\\B\\1.mp3"));// 复制到的目的地  
  16.       byte[] b = new byte[1024];  
  17.       int len = 0;  
  18.       while ((len = bis.read(b)) != -1) {// 读取  
  19.          bos.write(b, 0, len);// 写入  
  20.       }  
  21.       System.out.println("复制成功");  
  22.     } catch (Exception e) {  
  23.       e.printStackTrace();  
  24.     } finally {  
  25.       if (bis != null) {  
  26.          try {  
  27.            bis.close();// 关闭读取缓冲对象流  
  28.          } catch (IOException e) {  
  29.            e.printStackTrace();  
  30.          }  
  31.          if (bos != null) {  
  32.            try {  
  33.              bos.close();// 关闭写入缓冲对象流  
  34.            } catch (IOException e) {  
  35.              e.printStackTrace();  
  36.            }  
  37.          }  
  38.       }  
  39.     }  
  40.   }  
  41.    
  42. }  
  43. 结果：  
  44. 复制成功  

         2.  模拟读取缓冲区

 

[java] view
plaincopy

  1. import java.io.IOException;  
  2. import java.io.InputStream;  
  3.    
  4. public class MyBufferedInputStream {  
  5.    privateInputStream in = null;  
  6.    private intcount = 0;// 计数器  
  7.    private intpos = 0;// 指针  
  8.    private byte[]bu = new byte[1024];// 封装的字节数组  
  9.    
  10.    publicMyBufferedInputStream(InputStream in) {  
  11.         this.in =in;  
  12.    }  
  13.    
  14.    public intMyRead() throws IOException {  
  15.    
  16.         if (count== 0) {// 说明此时缓冲区中没有数据，可能是缓冲区中还没有开始读取，或者是缓冲区中数据读取完毕  
  17.               count= in.read(bu);// 向缓冲区中读取数据  
  18.               if(count < 0) {  
  19.                    return-1;// 这里返回的是int类型的-1  
  20.               }  
  21.               pos=0;//每次把指针都初始化  
  22.               byteb = bu[pos];  
  23.               count--;//计数器减一  
  24.               pos++;//指针加一  
  25.               returnb & 0xff;// 这里b是byte类型，自动提升为整形，但是前面补充的是全是1，为了防止当读取道德byte数据为11111111时，&上0xff，那么使前面的是0，那么这样额可以是原数据不变，又能避免字节数据是-1的情况  
  26.    
  27.         } elseif(count>0){  
  28.               byteb = bu[pos];  
  29.               count--;//计数器减一  
  30.               pos++;//指针加一  
  31.               returnb & 0xff;// 这里b是byte类型，自动提升为整形，但是前面补充的是全是1，为了防止当读取道德byte数据为11111111时，&上0xff，那么使前面的是0，那么这样额可以是原数据不变，又能避免字节数据是-1的情况  
  32.         }  
  33.         return-1;  
  34.    }  
  35.    
  36.    public voidmyClose() throws IOException {  
  37.         in.close();  
  38.    }  
  39. }  
  40. import java.io.BufferedInputStream;  
  41. import java.io.BufferedOutputStream;  
  42. import java.io.FileInputStream;  
  43. import java.io.FileOutputStream;  
  44. import java.io.IOException;  
  45. /* 
  46.  *测试类，也是复制MP3*/  
  47. public class BufferedStreamDemo {  
  48.   public static void main(String[] args) {  
  49.     MyBufferedInputStream bis = null;// 读取缓冲流  
  50.     BufferedOutputStream bos = null;// 写入缓冲流  
  51.     try {  
  52.       bis = new MyBufferedInputStream(new FileInputStream("F:\\A\\1.mp3"));// 要复制的MP3文件  
  53.       bos = new BufferedOutputStream(new FileOutputStream("F:\\B\\1.mp3"));// 复制到的目的地  
  54.       // byte[] b = new byte[1024];  
  55.       int r = 0;  
  56.       while ((r = bis.MyRead()) != -1) {// 读取  
  57.          bos.write(r);// 写入  
  58.       }  
  59.       System.out.println("复制成功");  
  60.     } catch (Exception e) {  
  61.       e.printStackTrace();  
  62.     } finally {  
  63.       if (bis != null) {  
  64.          try {  
  65.            bis.myClose();// 关闭读取缓冲对象流  
  66.          } catch (IOException e) {  
  67.            e.printStackTrace();  
  68.          }  
  69.          if (bos != null) {  
  70.            try {  
  71.              bos.close();// 关闭写入缓冲对象流  
  72.            } catch (IOException e) {  
  73.              e.printStackTrace();  
  74.            }  
  75.          }  
  76.       }  
  77.     }  
  78.   }  
  79.    
  80. }  
  81.    
  82. 结果：复制成功  

 

注意点：在MyRead()方法中return 返回的必须写b&0xff，因为这样byte类型的提升为整形后,可以保证原数据保持不变，把原来的数据前面相当于添加的0.

例如：

byte  ： 11111111  这是-1

自动提升为整形后的数据是

        1111111111111111 11111111 11111111 此时这是-1

那么当byte类型的数据是八个1的时候，那么直接返回b,那么提升为整形后是四个八个1，那么还是-1，所以程序直接结束，读取完毕，解决方法是，要是在前面补充的是全是0的话，那么原数据不变没这样也避免的读取-1的情况。

      1111111111111111 11111111 11111111

&     00000000 00000000 00000000 11111111 这是255，

-----------------------------------------------------------------

      0000000000000000 00000000 11111111

 

所以这样结果就是我们想要的数据，既避免了读取byte是11111111的缺点，同时还保证了原数据不变。

Read方法是byte类型的提升，从1个字节提升为整形为四个字节。Write方法是把4个字节变成了1个字节，值去最后的一个字节。所以复制后的文件的大小和原来的大小一下，而不是其4倍的大小。

6. 键盘读取

  

[java] view
plaincopy

  1.    import java.io.IOException;  
  2. import java.io.InputStream;  
  3.    
  4. public class ClassDemo {  
  5.   public static void main(String[] args) throws IOException {  
  6.     /* 
  7.      * InputStream in“标准”输入流:读取的设备是键盘 PrintStream out“标准”输出流。输出到控制台 
  8.      */  
  9.     /* 
  10.      * 我们可以循环输入，当输入为over时候，结束输入 
  11.      */  
  12.     InputStream in = System.in;  
  13.     StringBuilder bu= new StringBuilder();  
  14.     while (true) {  
  15.       int ch = in.read();  
  16.       if (ch == '\r')  
  17.          continue;  
  18.       if (ch == '\n') {  
  19.          String s = bu.toString();  
  20.          if ("over".equals(s))// 如果输入的是over，那么结束输入  
  21.            break;  
  22.          System.out.println("输入的内容是：" + s);  
  23.          bu.delete(0,bu.length());  
  24.       } else  
  25.          bu.append((char) ch);  
  26.     }  
  27.    
  28.   }  
  29.    
  30. }  
  31. 结果：  
  32. aa  
  33. 输入的内容是：aa  
  34. bb  
  35. 输入的内容是：bb  
  36. cc  
  37. 输入的内容是：cc  
  38. over  
 

黑马程序员_<<转换流(InputStreamReader,OutputStreamWriter)>>

分类： IO流2013-10-03
22:42 52人阅读 评论(0) 收藏 举报
转换流InputStreamReaderOutputStreamWriter黑马程序员

目录(?)[+]

--------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！
--------------------

1.字节流转换成字符流(InputStreamReader)

            字节流：InputStream   -------读取

     字符流：Reader       ------读取

     在字节流读取的时候用的是一个一个字节的读取方式或者是字节数组的读取方式，

在字符流中读取的时候，除了有一个一个字符的读取方式和数组 的读取 方式外 ，在缓冲技术里面有一行一行的读取，这个方法在读取的时候很好用也很方面，那么我们就可以把字节流的转换成字符流，然后利用缓冲对象来使用读取一行的方法。

 

字符流要向获得从键盘录入的信息，那么必须使用字节流，然后把字节流准换成字符流

步骤：

   1.准备好一个字节流(InputStream  in)

   2.利用InputStreamReader(isr)把字节流对象作为其构造函数的参数，new InputStreamReader(in)

   3.然后使用缓冲技术(BufferedReader对象封装转换流)newBufferedReader(isr),然后就可以使用读取行的方法了。

   4.最后要关闭流

举例：读取键盘的录入的数据

InputStream in = System.in;

     InputStreamReader isr = new InputStreamReader(in);

    BufferedReader br = newBufferedReader(isr);

然后我们就可以使用br对象纪念性读取键盘录入的数据了。

我们也可以把这三句转换成一句。

BufferedWriter bw = new BufferedWriter(newOutputStreamWriter(System.out));

2. 字节输入流转换成字符输入流(OutputStreamWriter)

      字符流：Writer   -----写入流

字节流：OutputStream  ---写入流

OutputStreamWriter 是字符流通向字节流的桥梁：可使用指定的 charset 将要写入流中的字符编码成字节。

步骤：

1.准备一个字符流

2.利用OutputStreamWriter(OutputStream out)把其转换成字节流，

3.可以利用其缓冲对象对其进行封装。然后做相应的操作。

4.最后关闭流

 举例：

OutputStream out = System.out;

OutputStreamWriter osw = new OutputStreamWriter(out);

BufferedWriter bw = new BufferedWriter(osw);

也可以将这三句合成一句话

BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));

 

3.     流操作(转换流练习)

        1.   源：键盘录入  (输出)目的：控制台

 

 

[java] view
plaincopy

  1.  import java.io.BufferedReader;  
  2. import java.io.BufferedWriter;  
  3. import java.io.IOException;  
  4. import java.io.InputStream;  
  5. import java.io.InputStreamReader;  
  6. import java.io.OutputStream;  
  7. import java.io.OutputStreamWriter;  
  8.    
  9. public class ZhuanhuanDemo {  
  10.    
  11.   public static void main(String[] args) throws IOException {  
  12.     /*InputStream in = System.in;//原始键盘 
  13.     InputStreamReader isr = new InputStreamReader(in); 
  14.     BufferedReader br = new BufferedReader(isr);//封装类字符流*/  
  15.     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));  
  16.    
  17.     /*OutputStream out = System.out;//输出的目的是控制台 
  18.     OutputStreamWriter osw = new OutputStreamWriter(out);//将字符流转换成字节流 
  19.     BufferedWriter bw = new BufferedWriter(osw);*/  
  20.      
  21.     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));  
  22.    
  23.     String line = null;  
  24.     while ((line = br.readLine()) != null) {  
  25.       if ("over".equals(line))  
  26.          break;  
  27.       bw.write("输入的内容是：" + line);  
  28.       bw.newLine();  
  29.       bw.flush();  
  30.     }  
  31.    
  32.   }  
  33.    
  34. }结果：  
  35. 张三  
  36. 输入的内容是：张三  
  37. 李四  
  38. 输入的内容是：李四  
  39. abc  
  40. 输入的内容是：abc  
  41. over  

 

            2.  源：键盘  输出目的：文件

就是将键盘录入的数据写到了文件中

 

[java] view
plaincopy

  1. import java.io.BufferedReader;  
  2. import java.io.BufferedWriter;  
  3. import java.io.FileOutputStream;  
  4. import java.io.IOException;  
  5. import java.io.InputStreamReader;  
  6. import java.io.OutputStreamWriter;  
  7.    
  8. public class ZhuanhuanDemo {  
  9.    
  10.   public static void main(String[] args) throws IOException {  
  11.    
  12.     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// 源：键盘  
  13.     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(  
  14.         new FileOutputStream("F:\\demo.txt")));// 目的：文件  
  15.    
  16.     String line = null;  
  17.     while ((line = br.readLine()) != null) {  
  18.       if ("over".equals(line))  
  19.          break;  
  20.       bw.write(line);//写入  
  21.       bw.newLine();  
  22.       bw.flush();  
  23.     }  
  24.     bw.close();// 关闭流  
  25.     br.close();// 关闭流  
  26.    
  27.   }  
  28.    
  29. }  
  30.    

    3. 源：文件  目的：控制台

将文件的内容打印在控制台上

[java] view
plaincopy

  1. import java.io.BufferedReader;  
  2. import java.io.BufferedWriter;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.InputStreamReader;  
  7. import java.io.OutputStreamWriter;  
  8.    
  9. public class ZhuanhuanDemo {  
  10.    
  11.   public static void main(String[] args) throws IOException {  
  12.    
  13.     BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("F:\\demo.txt")));// 源：文本  
  14.     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));// 目的：控制台  
  15.    
  16.     String line = null;  
  17.     while ((line = br.readLine()) != null) {  
  18.       bw.write(line);//输出  
  19.       bw.newLine();  
  20.       bw.flush();  
  21.     }  
  22.     bw.close();// 关闭流  
  23.     br.close();// 关闭流  
  24.    
  25.   }  
  26.    
  27. }  
  28. 结果：  
  29. 张三  
  30. 李四  
  31. 王五  

 

4. 流操作规律

1.明确源和目的

源:输入流：InputStream   Reader

目的：输出流：OutputStream Writer

2.操作的数据是否是纯文本

     是：字符流

     不是：字节流

3.当体系明确后，在明确要使用那个具体的对象。

通过设备来进行区分：

源设备：内存，硬盘，键盘

目的内存：内存，硬盘，控制台

 

需求：

1.将一个文件数据存储到另一个文件中，复制文件

 源：文件  使用读取流： InputStream Reader

            是否是文本文件： 是：用Reader

             明确对象:明确设备：硬盘中的文件FileReader对象

提高效率。利用缓冲区。BufferedReader。

FileReader fr=new FileReader(“a.txt”);

BufferedReader br=new BufferedReader(fr);

目的 ：文件：OutputStream Writer

是否是纯文本：Writer

设备：硬盘中的文件

提高效率。利用缓冲区。BufferedWriter。

对象：FileWriter

FileWriter fw=new FileWriter();

BufferedWriter bw=new BufferedWriter(fw);

2.需求

将键盘录入的数据保存到另一个文件中。

源：InputStream Reader

纯文本：Reader

设备：键盘 对象 System.in

 InputStreamReader idr=new InputStreamReader(System.in);

 提高效率用BufferedReader

BufferedReader bufr=new BufferedReader(idr);

目的：OurStream ,Writer

     纯文本：Writer

 设备：硬件的文件

  FileWrite fw=new FileWriter(“文件”);

 BufferefWriter bufW=new BufferefWriter(fw);

 

  

要指定编码方式，必须使用转换流，OutputStreamWriter扩展：指定编码方式

OutputStreamWriter(OutputStream out,String charsetName)

 

OutputStreamWriter osw=new OutputStreamWriter(newFileOutputStream(“F:\\demo.txt”,”utf-8”))这制订了编码方式;

在转换流构造方法中指定。

 

当需要指定编码方式的时候，那么就需要此转换流OutputStreamWriter。

当需要指定编码方式的时候那么就需要转换流来操作。

当需要读取别的编码方式的文件的时候，也得需要使用转换流

字节流不用刷新缓冲区，字符流要刷新缓冲区

 

[java] view
plaincopy

  1. public class ZhuanhuanDemo {  
  2.    
  3.   public static void main(String[] args) throws IOException {  
  4.    
  5.     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// 源：键盘  
  6.     /*默认的编码是jbk。*/  
  7.     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(  
  8.          new FileOutputStream("F:\\demo1.txt"),"utf-8"));// 目的：控制台  
  9.    
  10.     String line = null;  
  11.     while ((line = br.readLine()) != null) {  
  12.       if ("over".equals(line))  
  13.          break;  
  14.       bw.write(line);// 输出  
  15.       bw.newLine();  
  16.       bw.flush();  
  17.     }  
  18.     bw.close();// 关闭流  
  19.     br.close();// 关闭流  
  20.    
  21.   }  

当你输入两个汉字就结束的话，那么文件大小是8个字节，要是默认的话就是6个字节，指定GBK的话，那也是6个字节，所以可以确认默认的是GBK编码。



      

[java] view
plaincopy

  1.  import java.io.BufferedReader;  
  2. import java.io.BufferedWriter;  
  3. import java.io.FileInputStream;  
  4. import java.io.FileOutputStream;  
  5. import java.io.IOException;  
  6. import java.io.InputStreamReader;  
  7. import java.io.OutputStreamWriter;  
  8.    
  9. public class ZhuanhuanDemo {  
  10.    
  11.   public static void main(String[] args) throws IOException {  
  12.    
  13.     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// 源：键盘  
  14.     /*默认的编码是jbk。*/  
  15.     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(  
  16.          new FileOutputStream("F:\\demo1.txt"),"utf-8"));// 目的：控制台  
  17.    
  18.     String line = null;  
  19.     while ((line = br.readLine()) != null) {  
  20.       if ("over".equals(line))  
  21.          break;  
  22.       bw.write(line);// 输出  
  23.       bw.newLine();  
  24.       bw.flush();  
  25.     }  
  26.     bw.close();// 关闭流  
  27.     br.close();// 关闭流  
  28.    
  29.   }  
  30.    
  31. }  

 

5. 改变标准输入输出设备

 

      

[java] view
plaincopy

  1. public static void main(String[] args) throws IOException {  
  2. /* 
  3.  * static void setIn(InputStream in)改变输入设备 
  4.  * static void setOut(PrintStream out)改变输出的设备目的 
  5.  * */  
  6.     System.setIn(new FileInputStream("F:\\demo.txt"));//把输入设备定义到了一个文件流上，就是源：文件  
  7.     System.setOut(new PrintStream("F:\\demo1.txt"));//把输入设备定义到一个文件上，就是把内容输入到一个文件中  
  8.     BufferedReader br = new BufferedReader(new InputStreamReader(System.in));// 源：键盘  
  9.     /*默认的编码是jbk。*/  
  10.     BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(  
  11.          new FileOutputStream("F:\\demo1.txt"),"utf-8"));// 目的：控制台  
  12.    
  13.     String line = null;  
  14.     while ((line = br.readLine()) != null) {  
  15.       if ("over".equals(line))  
  16.          break;  
  17.       bw.write(line);// 输出  
  18.       bw.newLine();  
  19.       bw.flush();  
  20.     }  
  21.     bw.close();// 关闭流  
  22.     br.close();// 关闭流  
  23.    
  24.   }  

6. 异常日志文件

      我们可以将程序中出现的异常保存到一个文件中，那么我就可以方便我们查看，在开发中也是把异常打印到文件中，不可能让用户看到异常。我们也可以下载logf4工具，这是专门处理异常的工具。

下面我们写一个字节的异常日志文件。

void   printStackTrace(PrintStream s) 
          将此 throwable 及其追踪输出到指定的输出流。

[java] view
plaincopy

  1. public class ExceptionDemo {  
  2.   public static void main(String[] args) {  
  3.     try {  
  4.       int a = 4 / 0;  
  5.     } catch (Exception e) {  
  6.       try {  
  7.          PrintStream ps = new PrintStream("F:\\exception.log");  
  8.          SimpleDateFormat sdf = new SimpleDateFormat(  
  9.              "yyyy-MM-DDHH:mm:ss");  
  10.          String s = sdf.format(new Date());  
  11.          ps.println(s);//将日期传进入  
  12.          e.printStackTrace(ps);// 将流传入，指定目的  
  13.       } catch (FileNotFoundException e1) {  
  14.          System.out.println("日志文件创建失败");  
  15.       }  
  16.    
  17.     }  
  18.    
  19.   }  
  20.    
  21. }  
  22.    
  23. 结果：  

7.系统属性信息

系统日志

 

将系统的实现存到文件中

  

[java] view
plaincopy

  1.  import java.io.FileNotFoundException;  
  2. import java.io.PrintStream;  
  3. import java.util.Properties;  
  4.    
  5. public class PropertiesDemo {  
  6.    
  7.   public static void main(String[] args) {  
  8.     /*list(PrintStream out)将属性列表输出到指定的输出流。*/  
  9.     Properties p=new Properties();  
  10.     p=System.getProperties();  
  11.     try {  
  12.       p.list(new PrintStream("F:\\SystemInfo.txt"));  
  13.     } catch (FileNotFoundException e) {  
  14.       System.out.println("创建文件失败");  
  15.     }  
  16.   }  
  17.    
  18. }  
  19.    

返回
【上篇】
【下篇】

作者:

抱歉!评论已关闭.

返回首页

Copyright © 2013-2018 学步园  保留所有权利.
软文销售 QQ客服：2265327166 点击这里给我发消息（其他合作也可洽谈）
必威体育
必威电竞