Java 文件IO

文件IO

Java IO
    IO流用来处理设备之间的数据传输 Java对数据的操作是通过流的方式 Java用于操作流的对象都在IO包中
    按操作数据分为 字节流和字符流
        字符流的由来：
        其实就是：字节流读取文字字节数据后，不直接操作而是先查指定的编码表。获取对应的文字。
        再对这个文字进行操作。简单说：字节流+编码表
    按流向分为 输入流和输出流
        输入流和输出流相对于内存设备而言
        将外设中的数据读取到内存中:输入
        将内存的数写入到外设中：输出。

字节流的两个顶层父类：
1，InputStream  2，OutputStream

字符流的两个顶层父类：
1，Reader 2，Writer

Demo1 将一些文字存储到硬盘一个文件中

public class FileWriterDemo {
 
  private static final String LINE_SEPARATOR = System.getProperty("line.separator");
 
  public static void main(String[] args) throws IOException {
 
    // 创建一个可以往文件中写入字符数据的字符输出流对象。
    /*
     * 既然是往一个文件中写入文字数据，那么在创建对象时，就必须明确该文件(用于存储数据的目的地)。
     * 如果文件不存在，则会自动创建。 如果文件存在，则会被覆盖。
     * 如果构造函数中加入true，可以实现对文件进行续写！
     */
    FileWriter fw = new FileWriter("demo.txt", true);
 
    /*
     * 调用Writer对象中的write(string)方法，写入数据。
     * 其实数据写入到临时存储缓冲区中。
     */
    fw.write("abcde" + LINE_SEPARATOR + "hahaha");
    // fw.write("xixi");
 
    // fw.flush(); 进行刷新，将数据直接写到目的地中。
 
    fw.close(); //关闭流，关闭资源。在关闭前会先调用flush刷新缓冲中的数据到目的地。
 
    // fw.write("haha");// java.io.IOException: Stream closed
 
  }
 
}

Demo2 读取一个文本文件。将读取到的字符打印到控制台

public class FileReaderDemo {
  public static void main(String[] args) throws IOException {
 
    // 1,创建读取字符数据的流对象。
    //在创建读取流对象时，必须要明确被读取的文件。一定要确定该文件是存在的。
    //用一个读取流关联一个已存在文件。
    FileReader fr = new FileReader("F:\\demo.txt");
 
    int ch = 0;
 
    while ((ch = fr.read()) != -1) {
      System.out.println((char) ch);
    }
 
    /*
     * //用Reader中的read方法读取字符。 int ch = fr.read(); System.out.println((char)ch);
     * int ch1 = fr.read(); System.out.println(ch1); int ch2 = fr.read();
     * System.out.println(ch2);
     */
 
    fr.close();
  }
}

Demo3 读取一个文本文件 采用字符数组的方法

public class FileReaderDemo2 {
  public static void main(String[] args) throws IOException {
 
    FileReader fr = new FileReader("F:\\demo.txt");
 
    //使用read(char[])读取文本文件数据。先创建字符数组。
    char[] buf = new char[1024];
 
    int len = 0;
 
    while((len=fr.read(buf))!=-1){
      System.out.println(new String(buf,0,len));
    }
 
    /*
    int num = fr.read(buf);//将读取到的字符存储到数组中。
    System.out.println(num+":"+new String(buf,0,num));
    int num1 = fr.read(buf);//将读取到的字符存储到数组中。
    System.out.println(num1+":"+new String(buf,0,num1));
    int num2 = fr.read(buf);//将读取到的字符存储到数组中。
    System.out.println(num2+":"+new String(buf));
    */
 
    fr.close();
  }
}

Demo4 文本文件复制

public class CopyTextTest {
  public static void main(String[] args) throws IOException {
 
    // 1,读取一个已有的文本文件，使用字符读取流和文件相关联。
    FileReader fr = new FileReader("F:\\demo.txt");
    // 2,创建一个目的，用于存储读到数据。
    FileWriter fw = new FileWriter("F:\\copydemo.txt");
    // 3,频繁的读写操作。
    int ch = 0;
    while ((ch = fr.read()) != -1) {
      fw.write(ch);
    }
    // 4,关闭流资源。
 
    fw.close();
    fr.close();
  }
}

Demo5 文本文件复制加缓存

public class CopyTextTest_2 {
  private static final int BUFFER_SIZE = 1024;
 
  public static void main(String[] args) {
 
    FileReader fr = null;
    FileWriter fw = null;
    try {
      fr = new FileReader("F:\\demo.txt");
      fw = new FileWriter("F:\\democopy2.txt");
 
      // 创建一个临时容器，用于缓存读取到的字符。
      char[] buf = new char[BUFFER_SIZE];// 这就是缓冲区。
 
      // 定义一个变量记录读取到的字符数，(其实就是往数组里装的字符个数 )
      int len = 0;
 
      while ((len = fr.read(buf)) != -1) {
        fw.write(buf, 0, len);
      }
 
    } catch (Exception e) {
      // System.out.println("读写失败");
      throw new RuntimeException("读写失败");
    } finally {
      if (fw != null)
        try {
          fw.close();
        } catch (IOException e) {
 
          e.printStackTrace();
        }
      if (fr != null)
        try {
          fr.close();
        } catch (IOException e) {
 
          e.printStackTrace();
        }
    }
  }
}

字符流的缓存区
    缓存区的出现提高了对数据的读写效率
    对应类 BufferedReader BufferedWriter
    缓存区要结合流才可以使用 在流的基础上对流的功能进行了增强

Demo6 缓存写

public class BufferedWriterDemo {
  private static final String LINE_SEPARATOR = System.getProperty("line.separator");
 
  public static void main(String[] args) throws IOException {
 
    FileWriter fw = new FileWriter("F:\\buf.txt");
 
    // 为了提高写入的效率。使用了字符流的缓冲区。
    // 创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联
    BufferedWriter bufw = new BufferedWriter(fw);
 
    // 使用缓冲区的写入方法将数据先写入到缓冲区中。
    // bufw.write("abcdefq"+LINE_SEPARATOR+"hahahha");
    // bufw.write("xixiixii");
    // bufw.newLine();
    // bufw.write("heheheheh");
 
    for (int x = 1; x <= 4; x++) {
      bufw.write("abcdef" + x);
      bufw.newLine();
      bufw.flush();
    }
 
    // 使用缓冲区的刷新方法将数据刷目的地中。
    // bufw.flush();
 
    // 关闭缓冲区。其实关闭的就是被缓冲的流对象。
    bufw.close();
 
    // fw.write("hehe");
 
    // fw.close();
  }
}

Demo7 缓存读

public class BufferedReaderDemo {
  public static void main(String[] args) throws IOException {
 
    FileReader fr = new FileReader("F:\\buf.txt");
 
    BufferedReader bufr = new BufferedReader(fr);
 
    String line = null;
 
    while ((line = bufr.readLine()) != null) {
      System.out.println(line);
    }
    /*
     * String line1 = bufr.readLine(); System.out.println(line1); String line2 =
     * bufr.readLine(); System.out.println(line2); String line3 =
     * bufr.readLine(); System.out.println(line3); String line4 =
     * bufr.readLine(); System.out.println(line4); String line5 =
     * bufr.readLine(); System.out.println(line5);
     */
 
    bufr.close();
 
  }
 
}

Demo8 缓存复制

public class CopyTextByBufTest {
  public static void main(String[] args) throws IOException {
 
    FileReader fr = new FileReader("F:\\buf.txt");
    BufferedReader bufr = new BufferedReader(fr);
 
    FileWriter fw = new FileWriter("F:\\buf_copy.txt");
    BufferedWriter bufw = new BufferedWriter(fw);
 
    String line = null;
    while ((line = bufr.readLine()) != null) {
      bufw.write(line);
      bufw.newLine();
      bufw.flush();
    }
 
    /*
     * int ch = 0;
     *
     * while((ch=bufr.read())!=-1){
     *
     * bufw.write(ch); }
     */
    bufw.close();
    bufr.close();
  }
 
}

Demo9 自定义缓存区

public class MyBufferedReader extends Reader {
  private Reader r;
 
  // 定义一个数组作为缓冲区。
  private char[] buf = new char[1024];
  // 定义一个指针用于操作这个数组中的元素。当操作到最后一个元素后，指针应该归零。
  private int pos = 0;
  // 定义一个计数器用于记录缓冲区中的数据个数。 当该数据减到0，就从源中继续获取数据到缓冲区中。
  private int count = 0;
 
  MyBufferedReader(Reader r) {
    this.r = r;
  }
 
  //该方法从缓冲区中一次取一个字符。
  public int myRead() throws IOException {
 
    if (count == 0) {
      count = r.read(buf);
      pos = 0;
    }
    if (count < 0)
      return -1;
 
    char ch = buf[pos++];
 
    count--;
 
    return ch;
 
  }
 
  public String myReadLine() throws IOException {
 
    StringBuilder sb = new StringBuilder();
 
    int ch = 0;
    while ((ch = myRead()) != -1) {
 
      if (ch == '\r')
        continue;
      if (ch == '\n')
        return sb.toString();
      // 将从缓冲区中读到的字符，存储到缓存行数据的缓冲区中。
      sb.append((char) ch);
 
    }
 
    if (sb.length() != 0)
      return sb.toString();
    return null;
  }
 
  public void myClose() throws IOException {
 
    r.close();
  }
 
  @Override
  public int read(char[] cbuf, int off, int len) throws IOException {
 
    return 0;
  }
 
  @Override
  public void close() throws IOException {
  }
}

public class MyBufferedReaderDemo {
  public static void main(String[] args) throws IOException {
 
    FileReader fr = new FileReader("F:\\buf.txt");
 
    MyBufferedReader bufr = new MyBufferedReader(fr);
 
    String line = null;
 
    while ((line = bufr.myReadLine()) != null) {
      System.out.println(line);
    }
 
    bufr.myClose();
  }
}

装饰设计模式
    对一组对象的功能进行增强时，就可以使用该模式进行问题的解决。
    
装饰和继承都能实现一样的特点：进行功能的扩展增强。

有什么区别呢？

首先有一个继承体系。
Writer
    |--TextWriter:用于操作文本
    |--MediaWriter：用于操作媒体。
    
想要对操作的动作进行效率的提高。
按照面向对象，可以通过继承对具体的进行功能的扩展。
效率提高需要加入缓冲技术。
    
Writer
    |--TextWriter:用于操作文本
        |--BufferTextWriter:加入了缓冲技术的操作文本的对象。
    |--MediaWriter：用于操作媒体。
        |--BufferMediaWriter:

但是这样做好像并不理想 如果这个体系进行功能扩展，又多了流对象。
那么这个流要提高效率，是不是也要产生子类呢？是。这时就会发现只为提高功能，进行的继承，
导致继承体系越来越臃肿。不够灵活。

重新思考这个问题？
既然加入的都是同一种技术--缓冲。
前一种是让缓冲和具体的对象相结合。
可不可以将缓冲进行单独的封装，哪个对象需要缓冲就将哪个对象和缓冲关联。

class Buffer{
    Buffer(TextWriter w)
    {}
 
    Buffer(MediaWirter w)
    {
 
    }
}
class BufferWriter extends Writer{
    BufferWriter(Writer w)
    {
    }
}

Writer
    |--TextWriter:用于操作文本
    |--MediaWriter：用于操作媒体。
    |--BufferWriter:用于提高效率。
    
装饰比继承灵活。

特点：装饰类和被装饰类都必须所属同一个接口或者父类。

Demo10 装饰设计模式例子

public class PersonDemo {
 
    public static void main(String[] args) {
 
        Person p = new Person();
//        p.chifan();
 
        NewPerson p1 = new NewPerson(p);
        p1.chifan();
 
        NewPerson2 p2 = new NewPerson2();
        p2.chifan();
    }
 
}
 
class Person{
    void chifan(){
        System.out.println("吃饭");
    }
}
//这个类的出现是为了增强Person而出现的。
class NewPerson{
    private Person p ;
    NewPerson(Person p){
        this.p = p;
    }
 
    public void chifan(){
        System.out.println("开胃酒");
        p.chifan();
        System.out.println("甜点");
 
    }
 
}
 
class NewPerson2 extends Person{
    public void chifan(){
        System.out.println("开胃酒");
        super.chifan();
        System.out.println("甜点");
    }
}

Demo11 LineNumberReaderDemo

public class LineNumberReaderDemo {
  public static void main(String[] args) throws IOException {
 
    FileReader fr = new FileReader("F:\\demo.txt");
    LineNumberReader lnr = new LineNumberReader(fr);
 
    String line = null;
    lnr.setLineNumber(100);
    while((line=lnr.readLine())!=null){
      System.out.println(lnr.getLineNumber()+":"+line);
    }
 
    lnr.close();
  }
}

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

Demo12 写文件

public class ByteStreamDemo {
  public static void main(String[] args) throws IOException {
 
    // 1，创建字节输出流对象。用于操作文件.
    FileOutputStream fos = new FileOutputStream("F:\\bytedemo.txt");
 
    // 2,写数据。直接写入到了目的地中。
    fos.write("abcdefg".getBytes());
 
    // fos.flush();
    fos.close();// 关闭资源动作要完成。
  }
}

Demo13 拷贝文件

public class CopyMp3Test {
 
  public static void main(String[] args) throws IOException {
 
    copy_1();
    copy_2();
    copy_3();
    // copy_4();
 
  }
 
  // 千万不要用，效率没有！
  public static void copy_4() throws IOException {
    FileInputStream fis = new FileInputStream("F:\\0.zip");
    FileOutputStream fos = new FileOutputStream("F:\\4.zip");
 
    long start = System.currentTimeMillis();
 
    int ch = 0;
 
    while ((ch = fis.read()) != -1) {
      fos.write(ch);
    }
 
    long end = System.currentTimeMillis();
    System.out.println("拷贝完成4---" + (start - end));
 
    fos.close();
    fis.close();
  }
 
  // 不建议。 测试速度还可以
  public static void copy_3() throws IOException {
    FileInputStream fis = new FileInputStream("F:\\0.zip");
    FileOutputStream fos = new FileOutputStream("F:\\3.zip");
 
    long start = System.currentTimeMillis();
 
    byte[] buf = new byte[fis.available()];
    fis.read(buf);
    fos.write(buf);
 
    long end = System.currentTimeMillis();
    System.out.println("拷贝完成3---" + (start - end));
 
    fos.close();
    fis.close();
  }
 
  // 速度一般
  public static void copy_2() throws IOException {
 
    FileInputStream fis = new FileInputStream("F:\\0.zip");
    BufferedInputStream bufis = new BufferedInputStream(fis);
 
    FileOutputStream fos = new FileOutputStream("F:\\2.zip");
    BufferedOutputStream bufos = new BufferedOutputStream(fos);
 
    long start = System.currentTimeMillis();
 
    int ch = 0;
 
    while ((ch = bufis.read()) != -1) {
      bufos.write(ch);
    }
 
    long end = System.currentTimeMillis();
    System.out.println("拷贝完成2---" + (start - end));
 
    bufos.close();
    bufis.close();
  }
 
  // 速度最快
  public static void copy_1() throws IOException {
 
    FileInputStream fis = new FileInputStream("F:\\0.zip");
    FileOutputStream fos = new FileOutputStream("F:\\1.zip");
 
    byte[] buf = new byte[1024];
 
    int len = 0;
 
    long start = System.currentTimeMillis();
 
    while ((len = fis.read(buf)) != -1) {
      fos.write(buf, 0, len);
    }
 
    long end = System.currentTimeMillis();
 
    System.out.println("拷贝完成1---" + (start - end));
 
    fos.close();
    fis.close();
  }
}

Demo14 读取键盘输入

public class ReadKey {
  public static void main(String[] args) throws IOException {
 
    // readKey();
    // System.out.println((int)'\r');
    // System.out.println((int)'\n');
 
    readKey2();
 
  }
 
  public static void readKey2() throws IOException {
 
    /*
     * 获取用户键盘录入的数据， 并将数据变成大写显示在控制台上， 如果用户输入的是over，结束键盘录入。
     *
     * 思路： 1，因为键盘录入只读取一个字节，要判断是否是over，需要将读取到的字节拼成字符串。 2，那就需要一个容器。StringBuilder.
     * 3，在用户回车之前将录入的数据变成字符串判断即可。
     */
 
    // 1，创建容器。
    StringBuilder sb = new StringBuilder();
 
    // 2，获取键盘读取流。
    InputStream in = System.in;
 
    // 3，定义变量记录读取到的字节，并循环获取。
    int ch = 0;
 
    while ((ch = in.read()) != -1) {
 
      // 在存储之前需要判断是否是换行标记 ,因为换行标记不存储。
      if (ch == '\r')
        continue;
      if (ch == '\n') {
        String temp = sb.toString();
        if ("over".equals(temp))
          break;
        System.out.println(temp.toUpperCase());
        sb.delete(0, sb.length());
      } else
        // 将读取到的字节存储到StringBuilder中。
        sb.append((char) ch);
 
      // System.out.println(ch);
    }
 
  }
 
  public static void readKey() throws IOException {
 
    InputStream in = System.in;
 
    int ch = in.read();// 阻塞式方法。
    System.out.println(ch);
    int ch1 = in.read();// 阻塞式方法。
    System.out.println(ch1);
    int ch2 = in.read();// 阻塞式方法。
    System.out.println(ch2);
 
    // in.close();
 
    // InputStream in2 = System.in;
    // int ch3 = in2.read();
 
  }
}

流的操作规律：

之所以要弄清楚这个规律，是因为流对象太多，开发时不知道用哪个对象合适。

想要知道开发时用到哪些对象。只要通过四个明确即可。

1，明确源和目的(汇)
    源：InputStream  Reader
    目的：OutputStream  Writer

2，明确数据是否是纯文本数据。
    源：是纯文本：Reader
        否：InputStream
    目的：是纯文本 Writer
        否：OutputStream
    
    到这里，就可以明确需求中具体要使用哪个体系。

3，明确具体的设备。
    源设备：
        硬盘：File
        键盘：System.in
        内存：数组
        网络：Socket流
        
    目的设备：
        硬盘：File
        控制台：System.out
        内存：数组
        网络：Socket流

4，是否需要其他额外功能。
    1，是否需要高效(缓冲区);
        是，就加上buffer.
    2，转换。

需求1：复制一个文本文件。
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2,是否是纯文本？
        是！
        源：Reader
        目的：Writer
        
    3,明确具体设备。
        源：
            硬盘：File
        目的：
            硬盘：File
    
        FileReader fr = new FileReader("a.txt");
        FileWriter fw = new FileWriter("b.txt");
        
    4,需要额外功能吗？
        需要，需要高效。
        BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));

需求2：读取键盘录入信息，并写入到一个文件中。
        
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2，是否是纯文本呢？
        是，
        源：Reader
        目的：Writer
    3，明确设备
        源：
            键盘。System.in
        目的：
            硬盘。File
            
        InputStream in = System.in;
        FileWriter fw = new FileWriter("b.txt");
        这样做可以完成，但是麻烦。将读取的字节数据转成字符串。再由字符流操作。
    4，需要额外功能吗？
        需要。转换。    将字节流转成字符流。因为名确的源是Reader，这样操作文本数据做便捷。
            所以要将已有的字节流转成字符流。使用字节-->字符 。InputStreamReader
        InputStreamReader isr = new InputStreamReader(System.in);
        FileWriter fw = new FileWriter("b.txt");
        
        还需要功能吗？
        需要：想高效。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufw = new BufferedWriter(new FileWriter("b.txt"));
                
    
需求3：将一个文本文件数据显示在控制台上。
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2，是否是纯文本呢？
        是，
        源：Reader
        目的：Writer
    3，明确具体设备
        源：
            硬盘：File
        目的：
            控制台：System.out
            
        FileReader fr = new FileReader("a.txt");
        OutputStream out = System.out;//PrintStream
    4，需要额外功能吗？
        需要，转换。
        FileReader fr= new FileReader("a.txt");
        OutputStreamWriter osw = new OutputStreamWriter(System.out);
        需要，高效。
        BufferedReader bufr = new BufferedReader(new FileReader("a.txt"));
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

需求4：读取键盘录入数据，显示在控制台上。
    1,明确源和目的。
        源：InputStream Reader
        目的：OutputStream  Writer
    2，是否是纯文本呢？
        是，
        源：Reader
        目的：Writer
    3，明确设备。
        源：
            键盘：System.in
        目的：
            控制台：System.out
        
        InputStream in = System.in;
        OutputStream out = System.out;
        
    4，明确额外功能？
        需要转换，因为都是字节流，但是操作的却是文本数据。
        所以使用字符流操作起来更为便捷。
        InputStreamReader isr = new InputStreamReader(System.in);
        OutputStreamWriter osw = new OutputStreamWriter(System.out);
        
        为了将其高效。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
        BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(System.out));

5，将一个中文字符串数据按照指定的编码表写入到一个文本文件中.
    
    1，目的。OutputStream，Writer
    2，是纯文本，Writer。
    3，设备：硬盘File
    FileWriter fw = new FileWriter("a.txt");
    fw.write("你好");
    
    注意：既然需求中已经明确了指定编码表的动作。
    那就不可以使用FileWriter，因为FileWriter内部是使用默认的本地码表。
    只能使用其父类。OutputStreamWriter.
    OutputStreamWriter接收一个字节输出流对象，既然是操作文件，那么该对象应该是FileOutputStream
    
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName);
    
    需要高效吗？
    BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("a.txt"),charsetName));

什么时候使用转换流呢？

转换流：
InputStreamReader ：字节到字符的桥梁。解码。
OutputStreamWriter：字符到字节的桥梁。编码。

1，源或者目的对应的设备是字节流，但是操作的却是文本数据，可以使用转换作为桥梁。
        提高对文本操作的便捷。
    2，一旦操作文本涉及到具体的指定编码表时，必须使用转换流 。

转换Demo1

public class TransStreamDemo {
  public static void main(String[] args) throws IOException {
 
    // 字节流。
    InputStream in = System.in;
 
    // 将字节转成字符的桥梁。装换流。
    InputStreamReader isr = new InputStreamReader(in);
 
    // int ch = isr.read();
    // System.out.println((char)ch);
 
    // 字符流。
    BufferedReader bufr = new BufferedReader(isr);
 
    OutputStream out = System.out;
 
    OutputStreamWriter osw = new OutputStreamWriter(out);
 
    BufferedWriter bufw = new BufferedWriter(osw);
 
    String line = null;
 
    while ((line = bufr.readLine()) != null) {
      if ("over".equals(line))
        break;
      // System.out.println(line.toUpperCase());
      // osw.write(line.toUpperCase()+"\r\n");
      // osw.flush();
 
      bufw.write(line.toUpperCase());
      bufw.newLine();
      bufw.flush();
    }
 
  }
 
}

转换Demo2

public class TransStreamDemo2 {
public static void main(String[] args) throws IOException {
 
    BufferedReader bufr = new BufferedReader(new InputStreamReader(System.in));
    BufferedWriter bufw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("F:\\b.txt")));
 
    String line = null;
 
    while((line=bufr.readLine())!=null){
      if("over".equals(line))
        break;
 
      bufw.write(line.toUpperCase());
      bufw.newLine();
      bufw.flush();
    }
 
  }
}

转换Demo3

public class TransStreamDemo3 {
  public static void main(String[] args) throws IOException {
 
    readText_2();
  }
 
  public static void readText_2() throws IOException, FileNotFoundException {
 
    InputStreamReader isr = new InputStreamReader(new FileInputStream("F:\\demo.txt"), "utf-8");
    char[] buf = new char[10];
    int len = isr.read(buf);
    String str = new String(buf, 0, len);
    System.out.println(str);
 
    isr.close();
  }
 
  public static void readText_1() throws IOException {
 
    FileReader fr = new FileReader("gbk_1.txt");
 
    char[] buf = new char[10];
    int len = fr.read(buf);
    String str = new String(buf, 0, len);
    System.out.println(str);
 
    fr.close();
 
  }
 
  public static void writeText_3() throws IOException {
 
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("u8_1.txt"), "UTF-8");
 
    osw.write("你好");
    osw.close();
 
  }
 
  public static void writeText_2() throws IOException {
 
    OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("gbk_3.txt"), "GBK");
 
    // OutputStreamWriter osw = new OutputStreamWriter(new
    // FileOutputStream("gbk_3.txt"),"GBK");
    // FileWriter fw = new FileWriter("gbk_1.txt");
 
    /*
     * 这两句代码的功能是等同的。 FileWriter：其实就是转换流指定了本机默认码表的体现。而且这个转换流的子类对象，可以方便操作文本文件。
     * 简单说：操作文件的字节流+本机默认的编码表。 这是按照默认码表来操作文件的便捷类。
     *
     * 如果操作文本文件需要明确具体的编码。FileWriter就不行了。必须用转换流。
     */
 
    osw.write("你好");
 
    osw.close();
 
  }
 
  public static void writeText_1() throws IOException {
 
    FileWriter fw = new FileWriter("gbk_1.txt");
 
    fw.write("你好");
 
    fw.close();
  }
}