[关闭]
@liayun 2016-06-19T08:29:20.000000Z 字数 17822 阅读 1639

Java IO(一)

java基础

IO(Input Output)流

IO流常用基类

注意：由这四个类派生出来的子类名称都是以其父类名作为子类名的后缀。

字符流

先学习一下字符流的特点。

字符流——创建文件

既然IO流是用于操作数据的，那么数据的最常见体现形式是：文件，那么先以操作文件为主来演示。
例，需求：在硬盘上，创建一个文件并写入一些文字数据。
解：
分析：找到一个专门用于操作文件的Writer子类对象——FileWriter，后缀名是父类名，前缀名是该流对象的功能。

如果想在原有文件上继续加入新的数据呢？
创建一个FileWriter对象时，传递一个true参数，代表不覆盖已有的文件，即在已有文件的末尾处进行数据续写。如：

  1. import java.io.*;
  3. class FileWriterDemo {
  4.     public static void main(String[] args) throws IOException {
  5.         FileWriter fw = new FileWriter("demo.txt", true);
  6.         fw.write("nihao\r\nxeixie");
  7.         fw.close();
  8.     }
  9. }

注意：\r\n在windows中表示行终止符。

IO异常的处理方式

IO异常的处理方式：最后无论如何都应关闭资源，所以应放在finally代码块中。

  1. import java.io.*;
  3. class FileWriterDemo {
  4.     public static void main(String[] args) {
  5.         FileWriter fw = null;
  6.         try {
  7.             fw = new FileWriter("demo.txt");
  8.             fw.write("abcdefg");
  9.         } catch(IOException e) {
  10.             System.out.println("catch:"+e.toString());
  11.         } finally {
  12.             try {
  13.                 if(fw!=null) // 写在外面也可
  14.                     fw.close(); 
  15.             } catch(IOException e) {
  16.                 System.out.println(e.toString());
  17.             }   
  18.         }
  19.     }
  20. }

字符流——读取文件

例，需求：从硬盘的一个文件中读取内容。
解：
第一种方式读取：

第二种方式读取：通过字符数组进行读取。

练习1、读取一个.java文件，并打印在控制台上。
解：

  1. import java.io.*;
  3. class FileReaderTest {
  4.     public static void main(String[] args) throws IOException {
  5.         FileReader fr = new FileReader("DateDemo.java");
  7.         char[] buf = new char[1024];
  9.         int num = 0;
  11.         while((num=fr.read(buf)) != -1) {
  12.             System.out.print(new String(buf, 0, num));
  13.         }
  15.         fr.close();
  16.     }
  17. }

练习2、将c盘一个文本文件复制到d盘中。
解：
分析：复制原理——其实就是将c盘下的文件数据存储到d盘的一个文件中。
步骤：

  1. 在d盘创建一个文件，用于存储c盘文件中的数据。
  2. 定义读取流和c盘文件关联。
  3. 通过不断的读写完成数据存储。
  4. 关闭资源。

第一种复制方式：从c盘读一个字符，就往d盘写一个字符。

  1. public static void copy_1() throws IOException {
  2.     // 创建目的地
  3.     FileWriter fw = new FileWriter("RuntimeDemo_copy.txt");
  4.     // 与已有文件关联
  5.     FileReader fr = new FileReader("RuntimeDemo.java");
  7.     int ch = 0;
  9.     while((ch=fr.read()) != -1) {
  10.         fw.write(ch);
  11.     }
  13.     fw.close();
  14.     fr.close();
  15. }

第二种复制方式：

  1. public static void copy_2() {
  2.     FileReader fr = null;
  3.     FileWriter fw = null;
  4.     try {
  5.         fw = new FileWriter("SystemDemo_copy.txt");
  6.         fr = new FileReader("SystemDemo.java");
  8.         char[] buf = new char[1024];
  9.         int len = 0;
  10.         while((len = fr.read(buf)) != -1) {
  11.             fw.write(buf, 0, len);
  12.         }
  13.     } catch(IOException e) {
  14.         throw new RuntimeException("读写失败");
  15.     } finally {
  16.         if(fr != null) 
  17.             try {
  18.                 fr.close();
  19.             } catch(IOException e) {
  21.             }
  22.         if(fw != null) 
  23.             try {
  24.                 fw.close();
  25.             } catch(IOException e) {
  27.             }
  28.     }
  29. }

原理：
复制文件

字符流的缓冲区

缓冲区的出现是为了提高流的操作效率而出现的，所以在创建缓冲区之前，必须要先有流对象。

BufferedWriter

该缓冲区中提供了一个跨平台的换行符：newLine()。

BufferedReader

字符读取流缓冲区，该缓冲区提供了一个一次读一行的方法：readLine()，方便于对文本数据的获取，当返回null时，表示读取到文件末尾。
readLine()方法返回的时候只返回回车符之前的数据内容，并不返回回车符（行终止符）。

  1. import java.io.*;
  3. class MyBufferedReader extends Reader {
  4.     private Reader r;
  5.     MyBufferedReader(Reader r) {
  6.         this.r = r;
  7.     }
  8.     // 可以一次读一行数据的方法
  9.     public String myReadLine() throws IOException {
  10.         // 定义一个临时容器，原BufferReader封装的是一个字符数组
  11.         // 为了演示方便，定义一个StringBuilder容器，因为最终还是要将数据变为字符串。
  12.         StringBuilder sb = new StringBuilder();
  13.         int ch = 0;
  14.         while((ch=r.read()) != -1) {
  15.             if(ch == '\r')
  16.                 continue;
  17.             if(ch == '\n')
  18.                 return sb.toString();
  19.             else 
  20.                 sb.append((char)ch);
  21.         }
  22.         if(sb.length() != 0) // 如果文本数据最后的行终止符故意去掉，那么StringBuilder里面还是有数据的 ，也要给予返回
  23.             return sb.toString(); 
  24.         return null; // 如果已到达流末尾，则返回null
  25.     }
  26.     public void myClose() throws IOException {
  27.         r.close();
  28.     }
  29.     /*
  30.     覆盖Reader类中的抽象方法。
  31.     */
  32.     public int read(char[] cbuf, int off, int len) throws IOException {
  33.         return r.read(cbuf, off, len);
  34.     }
  35.     public void close() throws IOException {
  36.         r.close();
  37.     }
  38. }

测试自定义类MyBufferedReader。

  1. class MyBufferedReaderDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         FileReader fr = new FileReader("buf.txt");
  4.         MyBufferedReader myBuf = new MyBufferedReader(fr);
  5.         String line = null;
  6.         while((line=myBuf.myReadLine()) != null) {
  7.             System.out.println(line);
  8.         }
  9.         myBuf.myClose();
  10.     }
  11. }
装饰设计模式

装饰设计模式：当想要对已有的对象进行功能增强时，可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。那么自定义的该类称为装饰类。
装饰类通常会通过构造方法接收被装饰的对象。并基于被装饰的对象的功能，提供更强的功能。
举例来说明装饰设计模式：

  1. class Person {
  2.     public void chiFan() {
  3.         System.out.println("吃饭");
  4.     }
  5. }
  6. class SuperPerson {
  7.     private Person p;
  8.     SuperPerson(Person p) {
  9.         this.p = p;
  10.     }
  11.     public void superChiFan() {
  12.         System.out.println("开胃酒");
  13.         p.chiFan();
  14.         System.out.println("甜点");
  15.         System.out.println("来一根");
  16.     }
  17. }
  18. class PersonDemo {
  19.     public static void main(String[] args) {
  20.         Person p = new Person();
  21.         // p.chiFan();
  22.         SuperPerson sp = new SuperPerson(p);
  23.         sp.superChiFan();
  24.     }
  25. }
装饰模式与继承之间的区别

假设有这样一个继承体系：

可发现这样的继承体系很臃肿，所以应该换一个继承体系。这样设计类呢？

  1. class MyBufferReader {
  2.     MyBufferReader(MyTextReader text) {
  4.     }
  5.     MyBufferReader(MyMediaReader media) {
  7.     }
  8. }

可发现该类扩展性很差，可以找到其参数的共同类型，通过多态的形式，可以提高扩展性。

  1. class MyBufferReader extends MyReader {
  2.     private MyReader r;
  3.     MyBufferReader(MyReader r) {
  5.     }
  6. }

这样，最后的继承体系就是这个样子的：

结论：装饰模式比继承要灵活，避免了继承体系臃肿，而且降低了类与类之间的关系。装饰类因为增强已有对象，具备的功能和已有的是相同的，只不过提供了更强功能，所以装饰类和被装饰类通常都是属于一个体系中的。

例，通过缓冲区复制一个.java文件。
解：
分析：readLine()方法的原理：无论是读一行，或者读取多个字符，其实最终都是在硬盘上一个一个读取，所以最终使用的还是read()方法，一次读一个的方法。

  1. import java.io.*;
  3. class CopyTextByBuf {
  4.     public static void main(String[] args) {
  5.         BufferedReader bufr = null;
  6.         BufferedWriter bufw = null;
  7.         try {
  8.             bufr = new BufferedReader(new FileReader("BufferedWriterDemo.java"));
  9.             bufw = new BufferedWriter(new FileWriter("bufWriter_Copy.txt"));
  11.             String line = null; // 中转站
  13.             while((line = bufr.readLine()) != null) {
  14.                 bufw.write(line);
  15.                 bufw.newLine();
  16.                 bufw.flush();
  17.             }
  18.         } catch(IOException e) {
  19.             throw new RuntimeException("读写失败");
  20.         } finally {
  21.             try {
  22.                 if(bufr != null)
  23.                     bufr.close();
  24.             } catch(IOException e) {
  25.                 throw new RuntimeException("读取关闭失败");
  26.             } 
  27.             try {
  28.                 if(bufw != null)
  29.                     bufw.close();
  30.             } catch(IOException e) {
  31.                 throw new RuntimeException("写入关闭失败");
  32.             } 
  33.         }
  34.     }
  35. }
LineNumberReader

一个带行号的缓冲区。

  1. import java.io.*;
  3. class LineNumberReaderDemo {
  4.     public static void main(String[] args) throws IOException {
  5.         FileReader fr = new FileReader("PersonDemo.java");
  6.         LineNumberReader lnr = new LineNumberReader(fr);
  7.         String line = null;
  8.         lnr.setLineNumber(100);
  9.         while((line=lnr.readLine()) != null) {
  10.             System.out.println(lnr.getLineNumber()+":"+line);
  11.         }
  12.         lnr.close();
  13.     }
  14. }

练习：模拟一个带行号的缓冲区对象。
解：

  1. class MyLineNumberReader {
  2.     private Reader r;
  3.     private int lineNumber;
  5.     MyLineNumberReader(Reader r) {
  6.         this.r = r;
  7.     }
  8.     public String myReadLine() throws IOException {
  9.         lineNumber++; // myReadLine()方法读一次自增一次
  10.         StringBuilder sb = new StringBuilder();
  11.         int ch = 0;
  12.         while((ch=r.read()) != -1) {
  13.             if(ch=='\r')
  14.                 continue;
  15.             if(ch=='\n')
  16.                 return sb.toString();
  17.             else
  18.                 sb.append((char)ch);
  19.         }
  20.         if(sb.length() != 0)
  21.             return sb.toString();
  22.         return null;
  23.     }
  25.     public void setLineNumber(int lineNumber) {
  26.         this.lineNumber = lineNumber;
  27.     }
  29.     public int getLineNumber() {
  30.         return lineNumber;
  31.     }
  33.     public void myClose() throws IOException {
  34.         r.close();
  35.     }
  36. }

可发现myReadLine()方法与我们自定义类MyBufferedReader中的myReadLine()类似，所以我们可如此做：

  1. class MyLineNumberReader extends MyBufferedReader {
  2.     private int lineNumber;
  4.     MyLineNumberReader(Reader r) {
  5.         super(r);
  6.     }
  8.     public String myReadLine() throws IOException {
  9.         lineNumber++; // myReadLine()方法读一次自增一次
  10.         return super.myReadLine();
  11.     }
  13.     public void setLineNumber(int lineNumber) {
  14.         this.lineNumber = lineNumber;
  15.     }
  17.     public int getLineNumber() {
  18.         return lineNumber;
  19.     }
  20. }

测试自定义类MyLineNumberReader：

  1. class MyLineNumberReaderDemo {
  2.     public static void main(String[] args) throws IOException {
  3.         FileReader fr = new FileReader("CopyTextByBuf.java");
  4.         MyLineNumberReader mylnr = new MyLineNumberReader(fr);
  5.         String line = null;
  6.         mylnr.setLineNumber(100);
  7.         while((line=mylnr.myReadLine()) != null) {
  8.             System.out.println(mylnr.getLineNumber()+"::"+line);
  9.         }
  10.         mylnr.myClose();
  11.     }
  12. }

字节流

字符流：

字节流：

基本操作与字符流类相同，但它不仅可以操作字符，还可以操作其他媒体文件。

例，向一个文本文件中写入数据。

  1. public static void writeFile() throws IOException {
  2.     FileOutputStream fos = new FileOutputStream("fos.txt");
  4.     fos.write("abcde".getBytes());
  6.     fos.close();
  7. }

例，从一个文本文件中读取数据。
第一种方式：

  1. public static void readFile_1() throws IOException {
  2.     FileInputStream fis = new FileInputStream("fos.txt");
  4.     int ch = 0;
  6.     while((ch=fis.read()) != -1) {
  7.         System.out.println((char)ch);
  8.     }
  10.     fis.close();
  11. }

第二种方式：

  1. public static void readFile_2() throws IOException { 
  2.     FileInputStream fis = new FileInputStream("fos.txt");
  4.     byte[] buf = new byte[1024];
  6.     int len = 0;
  8.     while((len=fis.read(buf)) != -1) {
  9.         System.out.println(new String(buf, 0, len));
  10.     }
  12.     fis.close();
  13. }

第三种方式(不建议使用，因为可能会有内存溢出异常)

  1. public static void readFile_3() throws IOException {
  2.     FileInputStream fis = new FileInputStream("fos.txt");
  4.     byte[] buf = new byte[fis.available()]; // 定义一个刚刚好的缓冲区，不用再循环了。不过慎用！！！
  6.     fis.read(buf);
  8.     System.out.println(new String(buf));
  10.     fis.close();
  11. }

练习1、复制一个图片。
解：
思路：

  1. 用字节读取流对象和图片关联。
  2. 用字节写入流对象创建一个图片文件，用于存储获取到的图片数据。
  3. 通过循环读写，完成数据的存储。
  4. 关闭资源。
  1. import java.io.*;
  3. class CopyPic {
  4.     public static void main(String[] args) {
  5.         FileOutputStream fos = null;
  6.         FileInputStream fis = null;
  7.         try {
  8.             fos = new FileOutputStream("c:\\2.jpg");
  9.             fis = new FileInputStream("c:\\1.jpg");
  11.             byte[] buf = new byte[1024];
  13.             int len = 0;
  15.             while((len=fis.read(buf)) != -1) {
  16.                 fos.write(buf, 0, len);
  17.             }
  18.         } catch(IOException e) {
  19.             throw new RuntimeException("复制文件失败");
  20.         } finally {
  21.             try {
  22.                 if(fis != null) 
  23.                     fis.close();
  24.             } catch(IOException e) {
  25.                 throw new RuntimeException("读取关闭失败");
  26.             }
  27.             try {
  28.                 if(fos != null) 
  29.                     fos.close();
  30.             } catch(IOException e) {
  31.                 throw new RuntimeException("写入关闭失败");
  32.             }
  33.         }
  34.     }
  35. }

练习2、复制一个MP3文件。
解：
分析：通过缓冲区(BufferedOutputStream/BufferedInputStream)，演示MP3的复制。

  1. import java.io.*;
  3. class CopyMp3 {
  4.     public static void main(String[] args) throws IOException {
  5.         long start = System.currentTimeMillis();
  6.         copy_1();
  7.         long end = System.currentTimeMillis();
  8.         System.out.println((end-start)+"毫秒");
  9.     }
  10.     // 通过字节流的缓冲区完成复制
  11.     public static void copy_1() throws IOException {
  12.         BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("c:\\爱的秘密 蓝调口琴曲.mp3"));
  13.         BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\爱的秘密 蓝调口琴曲_copy.mp3"));
  15.         int by = 0;
  17.         while((by=bufis.read()) != -1) {
  18.             bufos.write(by);
  19.         }
  21.         bufos.close();
  22.         bufis.close();
  23.     }
  24. }

练习3、自定义一个类模拟BufferedInputStream，完成一个MP3文件的复制。
解：
分析：

mp3是由二进制数据组成的，如：11111111-1110000000000000000000101010110111010111010010110001。
问题：自定义的myRead()函数为什么会返回int类型，而不直接返回byte类型呢？
分析：
byte: -1  ----> int: -1
11111111(-1)提升为11111111 11111111 11111111 11111111(-1)
11111111(-1)--->提升为一个int类型，那还不是-1吗？？是-1的原因是因为在8个1前面补的都是1导致的。那么我只要在前面补0，即可以保留原字节数据不变，又可以避免-1的出现。怎么补0呢？(&255)
    11111111 11111111 11111111 11111111
&   00000000 00000000 00000000 11111111(255)
------------------------------------------
    00000000 00000000 00000000 11111111
所以应把11111111(-1)提升为00000000 00000000 00000000 11111111(255)，避免返回-1这种情况。

自定义一个MyBufferedInputStream类，如下：

  1. import java.io.*;
  3. class MyBufferedInputStream {
  4.     private InputStream in;
  6.     private byte[] buf = new byte[1024*4];
  8.     private int pos = 0, count = 0;
  10.     MyBufferedInputStream(InputStream in) {
  11.         this.in = in;
  12.     }
  13.     //  一次读一个字节，从缓冲区（字节数组）获取。
  14.     public int myRead() throws IOException {
  15.         // 通过in对象读取硬盘上数据，并存储到buf中。
  16.         if(count == 0) {
  17.             count = in.read(buf);
  18.             if(count < 0)
  19.                 return -1;
  20.             pos = 0;
  21.             byte b = buf[pos];
  23.             count--;
  24.             pos++;
  25.             return b & 255; // 必须&255(0xff)，然后再返回
  26.         } else if (count > 0) {
  27.             byte b = buf[pos];
  29.             count--;
  30.             pos++;
  31.             return b & 0xff; // 必须&255(0xff)，然后再返回
  32.         }
  33.         return -1;
  34.     }
  36.     public void myClose() throws IOException {
  37.         in.close();
  38.     }
  39. }

复制MP3：

  1. class CopyMp3 {
  2.     public static void main(String[] args) throws IOException {
  3.         long start = System.currentTimeMillis();
  4.         copy_2();
  5.         long end = System.currentTimeMillis();
  6.         System.out.println((end-start)+"毫秒");
  7.     }
  8.     public static void copy_2() throws IOException {
  9.         MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("c:\\爱的秘密 蓝调口琴曲.mp3"));
  10.         BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("c:\\爱的秘密 蓝调口琴曲_copy_2.mp3"));
  12.         int by = 0;
  14.         // System.out.println("第一个字节:"+bufis.myRead()); // 第一个字节:-1，因为读到了连续的11111111
  16.         while((by=bufis.myRead()) != -1) {
  17.             bufos.write(by);
  18.         }
  20.         bufos.close();
  21.         bufis.myClose();
  22.     }
  23. }

System类对IO的支持

例，需求：通过键盘录入数据。当录入一行数据后，就将该行数据进行打印，如果录入的数据是over，那么录入停止。
解：

  1. import java.io.*;
  3. class ReadIn {
  4.     public static void main(String[] args) throws IOException {
  5.         InputStream in = System.in;
  7.         StringBuilder sb = new StringBuilder();
  9.         while(true) {
  10.             int ch = in.read();
  11.             if(ch == '\r')
  12.                 continue;
  13.             if(ch == '\n') {
  14.                 String s = sb.toString();
  15.                 if("over".equals(s))
  16.                     break;
  17.                 System.out.println(s.toUpperCase());
  18.                 sb.delete(0, sb.length()); // 清空缓冲区
  19.             } else {
  20.                 sb.append((char)ch);
  21.             } 
  22.         }
  23.     }
  24. }

通过以上的键盘录入一行数据并打印其大写，发现其实就是读一行数据的原理。也就是readLine()方法。
能不能直接使用readLine()方法来完成键盘录入的一行数据的读取呢？
readLine()方法是字符流BufferedReader类中的方法，而键盘录入的read()方法是字节流InputStream的方法，那么能不能将字节流转成字符流，再使用字符流缓冲区的readLine()方法呢？此时就需要用到转换流。

转换流

例，需求：通过键盘录入数据。当录入一行数据后，就将该行数据进行打印，如果录入的数据是over，那么录入停止。
解：

  1. import java.io.*;
  3. class TransStreamDemo {
  4.     public static void main(String[] args) throws IOException {
  5.         // 获取键盘录入对象。
  6.         // InputStream in = System.in;
  8.         // 将字节流对象转成字符流对象，使用转换流——InputStreamReader
  9.         // InputStreamReader isr = new InputStreamReader(in);
  11.         // 为了提高效率，将字符流进行缓冲区技术高效操作，使用BufferedReader
  12.         // BufferedReader bufr = new BufferedReader(isr);
  14.         // 简写格式，键盘录入最常见写法
  15.         BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
  20.         // OutputStream out = System.out; // 屏幕输出
  21.         // OutputStreamWriter osw = new OutputStreamWriter(out); // 字符流输出对象转换成字节流输出对象
  22.         // BufferedWriter bufw = new BufferedWriter(osw);
  23.         BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));
  26.         String line = null;
  28.         while((line=bufr.readLine()) != null) {
  29.             if("over".equals(line))
  30.                 break;
  31.             bufw.write(line.toUpperCase());
  32.             bufw.newLine();
  33.             bufw.flush();
  34.         }
  36.         bufr.close();
  37.         bufw.close();
  38.     }
  39. }

流操作的基本规律

最痛苦的就是流对象有很多，不知道该用哪一个。但通过三个明确来完成：

  1. 明确源和目的。
    • 源：输入流。InputStream Reader
    • 目的：输出流。 OutputStream Writer
  2. 操作的数据是否是纯文本。
    • 是：字符流。
    • 不是：字节流。
  3. 当体系明确后，再明确要使用哪个具体的对象。通过设备来进行区分：
    • 源设备：内存、硬盘、键盘。
    • 目的设备：内存、硬盘、控制台。

例1，将一个文本文件中的数据存储到里另一个文件中(复制文件)。
分析：

  1. 源：因为是源，所以使用读取流。InputStream Reader
  2. 是不是操作文本文件？
    • 是！这时就可以选择Reader，这样体系就明确了。
  3. 接下来要明确要使用该体系中的那个对象？
    • 明确设备：硬盘上的一个文件。Reader体系中可以操作文件的对象是FileReader。
  4. 是否需要提高效率？
    • 是！加入Reader体系中的缓冲区BufferedReader。
  1. FileReader fr = new FileReader("a.txt");
  2. BufferedReader bufr = new BufferedReader(fr);
  1. 目的：OutputStream Writer
  2. 目的是否是纯文本？
    • 是！Writer。
  3. 设备：硬盘上的一个文件。
    • Writer体系中可以操作文件的对象是FileWriter
  4. 是否需要提高效率？
    • 是！加入Reader体系中的缓冲区BufferedWriter。
  1. FileWriter fw = new FileWriter("b.txt");
  2. BufferedWriter bufw = new BufferedWriter(fw);

练习：将一个图片文件中的数据存储到另一个文件中。（复制图片）
解：

  1. import java.io.*;
  3. class MyCopyPicture {
  4.     public static void main(String[] args) {
  5.         BufferedInputStream bis = null;
  6.         BufferedOutputStream bos = null;
  7.         try {
  8.             bis = new BufferedInputStream(new FileInputStream("c:\\1.jpg"));
  9.             bos = new BufferedOutputStream(new FileOutputStream("c:\\ye.jpg")); 
  10.             // 方式一
  11.             /*
  12.             int by = 0;
  13.             while((by=bis.read()) != -1) {
  14.                 bos.write(by);
  15.             } 
  16.             */
  17.             // 方式二
  18.             byte[] buf = new byte[1024];
  19.             int len = 0;
  20.             while((len=bis.read(buf)) != -1) {
  21.                 bos.write(buf, 0, len);
  22.             }   
  23.         } catch(IOException e) {
  24.             throw new RuntimeException("复制图片失败");
  25.         } finally {
  26.             try {
  27.                 if(bis != null)
  28.                     bis.close();
  29.             } catch(IOException e) {
  30.                 throw new RuntimeException("读取关闭失败");
  31.             }
  32.             try {
  33.                 if(bos != null)
  34.                     bos.close();
  35.             } catch(IOException e) {
  36.                 throw new RuntimeException("写入关闭失败");
  37.             }
  38.         }
  39.     }
  40. }

例2，需求：将键盘录入的数据保存到一个文件中。
分析：这个需求中有源和目的都存在，那么分别分析：

  1. 源：InputStream Reader
  2. 是不是纯文本？
    • 是！Reader

  3. 设备：键盘。对应的对象是System.in。
    不是选择Reader吗？System.in对应的不是字节流吗？为了操作键盘的文本数据方便，转成字符流，按照字符串操作是最方便的，所以既然明确了Reader，那么就将System.in转换成字符流Reader，用到了Reader体系中的转换流，InputStreamReader。

    1. InputStreamReader isr = new InputStreamReader(System.in);
  4. 需要提高效率吗？
    • 需要！BufferedReader
  1. BufferedReader bufr = new BufferedReader(isr);
  1. 目的：OutputStream Writer
  2. 是不是纯文本？
    • 是！Writer

  3. 设备：硬盘上的一个文件。使用FileWriter。

    1. FileWriter fw = new FileWriter("c.txt");
  4. 需要提高效率吗？
    • 需要！BufferedWriter
  1. BufferedWriter bufw = new BufferedWriter(fw);

扩展一下，想要把录入的数据按照指定的编码表(如UTF-8)，将数据存到文件中，怎么办呢？

  1. 目的：OutputStream Writer
  2. 是不是纯文本？
    • 是！Writer

  3. 设备：硬盘上的一个文件，使用FileWriter。但是FileWriter是使用的默认编码表(GBK)，但是存储时，需要加入指定的编码表(UTF-8)，而指定的编码表只有转换流可以指定，所以要使用的对象是OutputStreamWriter，而该转换流对象要接收一个字节输出流，而且还可以操作文件的字节输出流，FileOutputStream。

    1. OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("d.txt"), "UTF-8");
  4. 需要提高效率吗？
    • 需要！BufferedWriter
  1. BufferedWriter bufw = new BufferedWriter(osw);

所以，记住，转换流什么时候使用？字符和字节之间的桥梁，通常涉及到字符编码转换时，需要用到转换流。
练习：将一个文本数据打印在控制台上。
解：

  1. import java.io.*;
  3. class MyTest {
  4.     public static void main(String[] args) {
  5.         BufferedReader bufr = null;
  6.         BufferedWriter bufw = null;
  7.         try {
  8.             bufr = new BufferedReader(new FileReader("MyCopyPicture.java"));
  9.             bufw = new BufferedWriter(new OutputStreamWriter(System.out));
  10.             String line = null;
  11.             while((line=bufr.readLine()) != null) {
  12.                 bufw.write(line);
  13.                 bufw.newLine();
  14.                 bufw.flush();
  15.             }
  16.         } catch(IOException e) {
  17.             throw new RuntimeException("打印文件到控制台失败");
  18.         } finally {
  19.             try {
  20.                 if(bufr != null)
  21.                     bufr.close();
  22.             } catch(IOException e) {
  23.                 throw new RuntimeException("读取文件关闭失败");
  24.             }
  25.             try {
  26.                 if(bufw != null)
  27.                     bufw.close();
  28.             } catch(IOException e) {
  29.                 throw new RuntimeException("写入关闭失败");
  30.             }
  31.         }
  32.     }
  33. }

标准输入输出流

System类中的字段：in，out，它们各代表了系统标准的输入和输出设备，默认输入设备是键盘，输出设备是显示器。

可通过System类的setIn，setOut方法对默认设备进行改变，不建议使用。

  1. System.setIn(new FileInputStream("PersonDemo.java")); // 将源改成文件PersonDemo.java
  2. System.setOut(new PrintStream("zzz.txt")); // 将目的改成文件zzz.txt

异常的日志信息

log4j：记录日志信息的一个工具。

  1. import java.io.*;
  2. import java.util.*;
  3. import java.text.*;
  5. class ExceptionInfo {
  6.     public static void main(String[] args) throws IOException {
  7.         try {
  8.             int[] arr = new int[2];
  9.             System.out.println(arr[3]);
  10.         } catch(Exception e) {
  11.             try {
  12.                 Date d = new Date();
  13.                 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  14.                 String s = sdf.format(d);
  16.                 PrintStream ps = new PrintStream("exception.log");
  18.                 // ps.write(d.toString().getBytes());
  19.                 ps.println(s);
  21.                 System.setOut(ps);
  22.             } catch(IOException ex) {
  23.                 throw new RuntimeException("日志文件创建失败");
  24.             }
  25.             e.printStackTrace(System.out);
  26.         }
  27.     }
  28. }

系统信息

  1. import java.util.*;
  2. import java.io.*;
  3. class SystemInfo {
  4.     public static void main(String[] args) throws IOException {
  5.         Properties prop = System.getProperties(); 
  7.         // System.out.println(prop);
  9.         prop.list(new PrintStream("sysinfo.txt"));
  10.     }
  11. }

通过sysinfo.txt文本文件可以知道平台默认的字符集，即默认字符编码是GBK。
sysinfo

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注