javaSE笔记--分块 - 5. IO流 - 《Java全栈方向》

5. IO流

5. IO流

5.1 File类

5.1.1 文件对象的构造

这个类对一个文件（夹）的描述。

关于路径分隔符：

路径分隔符是对目录的分隔。表示一层嵌套关系。

在windows系统下，分隔符是：\

在UNIX体系下，分隔符是：/

构造方法	参数
File(String pathName)	使用一个指定的文件路径来实例化一个File对象
File(String parent, String name)	给定一个父目录路径和一个子文件名字，系统会自动的将其拼接在一起
File(File parent, String child)	给定一个父目录和一个子文件的名字，系统自动拼接路径

public class FileDemo {
       public static void main(String[] args) {
            //File构造函数演示
            String pathName = "hello.java";
            File f1 = new File(pathName);
            System.out.println(f1);
            File f2 = new File("/Users/IdeaProjects/JavaSE","hello.java");
            System.out.println(f2);
            //将parent封装成file对象。
            File dir = new File("/Users/IdeaProjects/JavaSE");
            File f3 = new File(dir,"hello.java");
            System.out.println(f3);
        }
}

5.1.2 文件和文件夹的常用方法

常用方	描述
boolean exists()	用来描述指定的路径下到底有没有文件（夹）存在。
boolean isFile()	判断指定路径的内容是不是一个文件
boolean isDirectory()	判断指定路径的内容是不是一个文件夹
boolean mkdir()	在指定的路径创建文件夹，返回值代表创建成功还是失败
boolean mkdirs()	在指定的路径创建文件夹，可以创建多级目录
boolean createNewFile()	在指定的路径创建一个空文件，会有一个IOException
boolean isHidden()	判断一个文件是否是隐藏的

 public static void main(String[] args) throws IOException {
                // 对文件或者文件加进行操作。
                File file = new File("/Users/IdeaProjects/JavaSE/file.txt");
                //获取文件的绝对路径，即全路径
                String absPath = file.getAbsolutePath();
                //File中封装的路径是什么获取到的就是什么。
                String path = file.getPath();
                //获取文件名称
                String filename = file.getName();
                //获取文件大小
                long size = file.length();
                System.out.println("absPath="+absPath);
                System.out.println("path="+path);
                System.out.println("filename="+filename);
                System.out.println("size="+size);
                // 创建文件，如果文件不存在，创建 true 如果文件存在，则不创建 false。 
                // 如果路径错误，IOException。
                boolean file1 = file.createNewFile();
                System.out.println("file1=" + file1);
                //-----------删除文件操作-------注意：不去回收站。慎用------
                boolean flag = file.delete();
                System.out.println("flag="+flag);
                //-----------需要判断文件是否存在------------
                boolean falg1 = file.exists();
                System.out.println("falg1="+falg1);
                //-----------对目录操作 创建，删除，判断------------
                File dir = new File("/Users/IdeaProjects/JavaSE/");
                //mkdir()创建单个目录。//dir.mkdirs();创建多级目录
                boolean flag2 = dir.mkdir();
                System.out.println("flag2="+flag2);
                //删除目录时，如果目录中有内容，无法直接删除。
                boolean flag3 = dir.delete();
                //只有将目录中的内容都删除后，保证该目录为空，这个目录才可以删除。
                System.out.println("flag3=" + flag3);
                //-----------判断文件，目录------------
                File file3 = new File("/Users/IdeaProjects/JavaSE/");
                 // 要判断是否是文件还是目录，必须先判断存在。
                System.out.println(file3.isFile());
                System.out.println(file3.isDirectory());
                //-----------目录遍历------------
                File dir1 = new File("/Users/IdeaProjects");
                //获取的是目录下的当前的文件以及文件夹的名称。
                String[] names = dir.list();
                for(String name : names){
                    System.out.println(name);
                }
                //获取目录下当前文件以及文件对象，只要拿到了文件对象，那么就可以获取其中想要的信息
                File[] files = dir.listFiles();
                for(File file4 : files){
                    System.out.println(file4);
                }
            }

5.1.3 文件过滤器

实现自己的文件过滤器

public class FileDemo{
    public static void main(String[] args) {
        //获取扩展名为.java所有文件
        //创建File对象
        File file = new File("/Users/IdeaProjects");
        //获取指定目录下的文件夹
        File[] files = file.listFiles(new FileFileterByDir());
        //遍历获取到的所有符合条件的文件
        for (File f : files) {
            System.out.println(f);
        }
    }
}
自定义类继承FileFilter过滤器接口
//文件过滤器
class FileFileterByDir implements FileFilter{
    public boolean accept(File pathname) {
        return pathname.isDirectory();
    }
}

5.2 流的分类

分类：

方向：输入流和输出流

数据单元：字节流和字符流

InputStream：字节输入流的超类

OutputStream：字节输出流的超类

Reader：字符输入流

Writer：字符输出流

无论是使用什么流，在使用结束之后，一定要记得关闭这个流。

5.3 字节流

InputStream：

int read(byte[] arr)：

参数：从流中读取数据，需要使用到一个字节数组。read方法会将读取到的数据填充到这个字节数组中。所以，读取完成后，我们直接从这个字节数组中取数据即可。

返回值：每次读取数据后，返回这一次读取到了多少个字节的数据。如果这个方法返回值为-1，说明本次没有读取到任何数据，读取完成。


 class FileInputStreamDemo {
     public static void main(String[] args) throws Exception {// 先声明
         InputStream is = null;
         try {
             // 实例化一个流
             is = new FileInputStream(new File("/Users/IdeaProjects/JavaSE/src/kaikeba/com/ArraysDemo.java"));
             // InputStream: 字节输入流，数据是以字节为单位
             // 从管道中读取数据：
             // 实例化一个数组，用来存储每次读取到的数据
             byte[] contents = new byte[100];
             // 用来记录每次读取到了多少数据
             int length = 0;
             // 循环读取，将每次读取到的数据长度给length赋值，并判断是否为-1
             while ((length = is.read(contents)) != -1) {
                 // 通过一个字节数组实例化一个字符串
                 String str = new String(contents, 0, length);
                 System.out.print(str);
             }
         } catch (FileNotFoundException e) {
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } finally {
             // 判断是否为空，因为如果最开始实例化的时候，文件不存在，则is实例化失败，依然为null
             // 此时，如果is是null，那么再去关闭的时候，就会出现NullPointerException
             if (is != null) {
                 try {
                     is.close();
                 } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
         }
     }
 }

outputStream：操作的数据都是字节，定义了输出字节流的基本共性功能方法。

OutputStream有很多子类，其中子类FileOutputStream可用来写入数据到文件。

FileOutputStream类，即文件输出流，是用于将数据写入 File的输出流。

public class FileOutputStreamDemo2 {
    public static void main(String[] args) throws Exception {
        File file = new File("myfile.txt");
        FileOutputStream fos = new FileOutputStream(file, true);
        String str = "\r\n"+"kaikeba.com";
        fos.write(str.getBytes());
        fos.close();
    }
}

5.4 字符流

Reader：字符输入流

Writer：字符输出流

写操作

    public static void main(String[] args) throws IOException {
        //1.创建FileWriter的对象并关联对应的文件
        //注意点:
        //一:如果只写文件的名字,不写具体路径,默认路径是当前的工程
        //二:对于关联的文件,如果之前不存在,程序会自动创建一个,如果存在,会将原来的内容覆盖
        //三:可以自己指定路径,但是必须保证路径是真实存在的,否则报异常---FileNotFountException(系统找不到指定的路径。)
        FileWriter fileWriter = new FileWriter("fileWrite.txt");
        //调用写入方法
        //注意点四:在执行write方法时,数据被临时放到了流对象的内部数组中,这个数组是一个字节数组,会默认去查编码表
        fileWriter.write("晨晨");
        //刷新---将临时数组中的数据放入磁盘
        //fileWriter.flush();
        //4.关闭流--两个功能:a:关闭流  b:刷新
        //第五个注意点:流对象使用完后必须关闭
        fileWriter.close();
        //第六个注意点:当流对象关闭之后,不能再进行操作,否则会报异常:Stream closed
        //fileWriter.write("haha");
    }

读操作

    public static void main(String[] args) throws IOException {
        //1.创建文件读入流
        FileReader fileReader = new FileReader("/Users/IdeaProjects/JavaSE/src/kaikeba/com/ArraysDemo.java");
        //开始读操作
        /*
         * read():一个字符一个字符的读,每次读出一个字符
         */
        //a:将当前的字符读出    b:将当前的指针后移一位
        int  value;
        while ((value = fileReader.read()) != -1) {
            System.out.println((char)value);
        }
        fileReader.close();
    }
    public static void main(String[] args) throws IOException {
        //1.创建文件读入流
        FileReader fileReader = new FileReader("/Users/liyunxia/IdeaProjects/JavaSE/src/kaikeba/com/ArraysDemo.java");
        //开始读操作
        /*
         * read(数组):一次可以读出多个字符   ,数组的作用:每次会将读出的字符临时放到这个数组中
         */
        /* 数组是临时存放数据的地方,我们会将读到的字符放到临时数组中,数组的大小决定了我们一次可以读到的字符个数.
         * 一般这个数组的大小<=1kB
         * 返回值代表本次读到的真实的字符个数,如果返回值是-1代表读完了.
         */
        char[] cbuf = new char[2];
        int num ;
        while ((num = fileReader.read(cbuf)) != -1) {
            //System.out.println(new String(cbuf)+"    num:"+num);
            System.out.println(new String(cbuf,0,num)+"    num:"+num);
        }
        fileReader.close();
    }

5.5 转换流

InputStreamReader、OutputStreamWriter

字节=》字符=》字节

转换流：保留了字符流对文本进行操作时候的便利性，保留了字节流的安全性。产生的一种新的流，主要用来做关于文本文件的处理。还可以解决：关于采用了不同字符集的文本之间的处理问题。可以使用指定的字符集来读取一个文本，也可以使用指定的字符集来写一个文本。

OutputStreamWriter

public class InputStreamReaderDemo {
  public static void writeCN() throws Exception {
        //创建与文件关联的字节输出流对象
        FileOutputStream fos = new FileOutputStream("OutputStreamWriter.txt");
        //创建可以把字符转成字节的转换流对象，并指定编码
        OutputStreamWriter osw = new OutputStreamWriter(fos,"utf-8");
        //调用转换流，把文字写出去，其实是写到转换流的缓冲区中
        osw.write("你好");//写入缓冲区。
        osw.close();
    }
}

InputStreamReader


public class InputStreamReaderDemo {
    public static void main(String[] args) throws IOException {
        //演示字节转字符流的转换流
        readCN();
    }
    public static void readCN() throws IOException{
        //创建读取文件的字节流对象
        InputStream in = new FileInputStream("/Users/IdeaProjects/JavaSE/src/kaikeba/com/ArraysDemo.java");
        //创建转换流对象 
        //InputStreamReader isr = new InputStreamReader(in);用本地默认码表读取，可能发生解码的错误
        InputStreamReader isr = new InputStreamReader(in,"utf-8");
        //使用转换流去读字节流中的字节
        int ch = 0;
        while((ch = isr.read())!=-1){
            System.out.println((char)ch);
        }
        //关闭流
        isr.close();
    }
}

5.6 缓冲流

Java提供一套缓冲流，可提高IO流的读写速度；

缓冲流，根据流的分类分类字节缓冲流与字符缓冲流。

BufferedInputStream、BufferedOutputStream、BufferedReader、BufferedWriter

BufferInputStream、BufferedOutputStream:

public class BufferedStreamDemo {
     public static void main(String[] args) throws IOException {
        //写数据到文件的方法
        write();
        read();
    }
    private static void write() throws IOException {
        //创建基本的字节输出流
        FileOutputStream fileOut = new FileOutputStream("bufferedStream.txt");
        //使用高效的流，把基本的流进行封装，实现速度的提升
        BufferedOutputStream out = new BufferedOutputStream(fileOut);
        //2，写数据
        out.write("hello".getBytes());
        //3，关闭流
        fileOut.close
        out.close();
    }
    private static void read() throws IOException {
        //1,创建缓冲流对象
        FileInputStream fileIn = new FileInputStream("bufferedStream.txt");
        //把基本的流包装成高效的流
        BufferedInputStream in = new BufferedInputStream(fileIn);
        //2，读数据
        int ch = -1;
        while ( (ch = in.read()) != -1 ) {
            //打印
            System.out.print((char)ch);
        }
        //3，关闭
        in.close();
    }
}

BufferedReader、BufferedWriter

public class BufferedWriterReaderDemo {
    public static void main(String[] args) throws IOException {
      write();
    read();
    }
      private static void write() throws IOException {
      //创建流
        //基本字符输出流
        FileWriter fileOut = new FileWriter("file.txt");
        //把基本的流进行包装
        BufferedWriter out = new BufferedWriter(fileOut);
        //2，写数据
        for (int i=0; i<5; i++) {
            out.write("hello");
            out.newLine();
        }
        //3,关闭流
        out.close();
      }
      private static void read() throws IOException {
      //1,创建流
        BufferedReader in = new BufferedReader(new FileReader("file.txt"));
        //2，读数据
        //一次一个字符
        //一次一个字符数组
        //一次读取文本中一行的字符串内容
        String line = null;
        while( (line = in.readLine()) != null ){
            System.out.println(line);
        }
        //3,关闭流
        in.close();
      }
}

5.7 序列化和反序列化流

用于从流中读取对象的操作流 ObjectInputStream 称为反序列化流

用于向流中写入对象的操作流 ObjectOutputStream 称为序列化流

特点：用于操作对象。可以将对象写入到文件中，也可以从文件中读取对象

import java.io.*;
class Person implements Serializable {
    private String name;
    private int age;
    public Person() {
        super();
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
}
 class ObjectStreamDemo {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        writeObj();//对象的序列化。
        readObj();//对象的反序列化。
    }
    public static void writeObj() throws IOException {
        //1,明确存储对象的文件。
        FileOutputStream fos = new FileOutputStream("object.txt");
        //2，给操作文件对象加入写入对象功能。
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        //3，调用了写入对象的方法。
        oos.writeObject(new Person("wangcai",20));
        //关闭资源。
        oos.close();
    }
    public static void readObj() throws IOException, ClassNotFoundException {
        //1,定义流对象关联存储了对象文件。
        FileInputStream fis = new FileInputStream("object.txt");
        //2,建立用于读取对象的功能对象。
        ObjectInputStream ois = new ObjectInputStream(fis);
        Person obj = (Person)ois.readObject();
        System.out.println(obj.toString());
    }
}

注意：

一个对象要能被序列化，对象所属的类必须实现Serializable接口。否则会发生NotSerializableException异常。

当反序列化对象时，如果对象所属的class文件在序列化之后进行的修改，那么进行反序列化也会发生异常InvalidClassException。发生这个异常的原因如下：该类的序列版本号与从流中读取的类描述符的版本号不匹配/该类包含未知数据类型/该类没有可访问的无参数构造方法.

Serializable标记接口，给需要序列化的类，提供了一个序列版本号：serialVersionUID，该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

静态修饰也不会被序列化，因为序列化是把对象数据进行持久化存储，而静态的属于类加载时的数据，不会被序列化。

当一个类的对象需要被序列化时，某些属性不需要被序列化，这时不需要序列化的属性可以使用关键字transient修饰。只要被transient修饰了，序列化时这个属性就不会琲序列化了。

5.8 标准输入输出流

System类，定义了一系列有用的属性和方法

System.in、System.out

PrintStream

System.in

结束控制台输入方案：

在Windows环境下，需要输入Ctrl+Z；在Linux/Unix/MAC环境下，需要输入Ctrl+D；
使用结束条件；

  public static void main(String[] args) throws IOException {
        //创建输入流对象
        InputStream is = System.in;
        //创建输出流对象
        FileWriter fw = new FileWriter("file.txt");
        //读取数据
        byte[] bys = new byte[1024];
        int len;
        while((len = is.read(bys))!=-1)
        {
            fw.write(new String(bys, 0, len));
            fw.flush();
        }
        fw.close();
        is.close();
    }

System.out

  public static void main(String[] args) throws IOException {
        //创建输入输出流对象
        BufferedReader br=new BufferedReader(new FileReader("file.txt"));
        OutputStream os=System.out;
        String line;//用于存储读取到的数据
        while((line=br.readLine())!=null) {
                   os.write(line.getBytes());
                   os.write("\r\n".getBytes());
                  }
             //释放资源
            os.close();
            br.close();
    }

由于标准输出流是一个字节输出流，所以只能输出字节或者字节数组，但是我们读到的数据则是字符串，如果想进行输出，还需要转换成字节数组，非常麻烦。我们要想通过标准输出流输出字符串，把标准输出流转换成一种字符输出流即可。可以使用转换流OutputStreamWriter。

 public static void main(String[] args) throws IOException {
        //创建输入输出流对象
        BufferedReader br=new BufferedReader(new FileReader("file.txt"));
        Writer w=new OutputStreamWriter(System.out);//多态，父类引用指向子类对象
        //进行数据读写
        String line;
        while((line=br.readLine())!=null) {
                   w.write(line);
                   w.write("\r\n");
                }
            //释放资源
             w.close();
             br.close();
          }

还可以结合高效缓冲流使用：

 public static void main(String[] args) throws IOException {
         //创建输入输出流对象
         BufferedReader br=new BufferedReader(new FileReader("file.txt"));
         BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
         //进行数据读写
         String line;
         while((line=br.readLine())!=null) {
                  bw.write(line);
                  bw.newLine();
               }
         //释放资源
          bw.close();
          br.close();
          }

5.9 打印流

打印流是输出信息最方便的类，注意包含字节打印流：PrintStream和字符打印流：PrintWriter

通过定义的构造方法可以发现，有一个构造方法可以直接接收OutputStream类的实例，与OutputStream相比起来，PrintStream可以更方便的输出数据，相当于把OutputStream类重新包装了一下，使之输出更方便。

JAVA对PrintStream功能进行了扩充，增加了格式化输出功能。直接使用Print即可。但是输出的时候需要指定输出的数据类型

提供了一系列重载的print()和println()方法，用于多种数据类型的输出。
PrintStream和PrintWriter的输出不会抛出IOException异常。
PrintStream和PrintWriter有自动flush功能。
PrintStream 打印的所有字符都使用平台的默认字符编码转换为字节。在需要写入字符而不是写入字节的情况下，应该使用 PrintWriter 类。
System.out返回的是PrintStream的实例。

PrintStream

    public static void main(String[] args) throws IOException {
        //创建流，绑定输出的目的地
        PrintStream ps=new PrintStream("a.txt");
        //使用write方法写数据，保持内容不变
        ps.write(97);
        ps.println();
        //使用print方法，会根据平台编码，进行转码工作
        ps.println(97);//97->a
        ps.println("HelloWorld");//HelloWorld
       //释放资源
        ps.close();
    }

PrintWriter

 public static void main(String[] args) throws IOException {
        //创建流
        //PrintWriter out = new PrintWriter(new FileWriter("printFile.txt"));
        PrintWriter out = new PrintWriter("a.txt");
        //2，写数据
        for (int i=0; i<5; i++) {
            out.println("helloWorld");
        }
        //3,关闭流
        out.close();
    }

5.10 Properties类

Properties 类表示了一个持久的属性集。Properties 可保存在流中或从流中加载。属性列表中每个键及其对应值都是一个字符串。

特点：

Hashtable的子类，map集合中的方法都可以用。
该集合没有泛型。键值都是字符串。
它是一个可以持久化的属性集。
唯一一个能与IO流交互的集合
有和流技术相结合的方法。
load(InputStream) 把指定流所对应的文件中的数据，读取出来，保存到Propertie集合中
load(Reader)
store(OutputStream,commonts)把集合中的数据，保存到指定的流所对应的文件中，参数commonts代表对描述信息
store(Writer,comments);
常用方法

public Object setProperty(String key, String value)调用 Hashtable 的方法 put。
public Set stringPropertyNames()返回此属性列表中的键集，
public String getProperty(String key)用指定的键在此属性列表中搜索属性

//Properties的使用
public class PropertiesDemo01 {
    public static void main(String[] args) {
        //创建集合对象
        Properties prop = new Properties();
        //添加元素到集合
        //prop.put(key, value);
        prop.setProperty("小丽", "大学生");
        prop.setProperty("小美", "研究生");
        prop.setProperty("小芳", "博士生");
        //遍历集合
        Set<String> keys = prop.stringPropertyNames();
        for (String key : keys) {
            //通过键 找值
            String value = prop.getProperty(key);
            System.out.println(key+"==" +value);
        }
    }
}

使用Properties集合，完成把集合内容存储到IO流所对应文件中的操作

public class PropertiesDemo02 {
    public static void main(String[] args) throws IOException {
        //1，创建Properties集合
        Properties prop = new Properties();
        //2，添加元素到集合
        prop.setProperty("小丽", "大学生");
        prop.setProperty("小美", "研究生");
        prop.setProperty("小芳", "博士生");
        //3，创建流
        FileWriter out = new FileWriter("prop.properties");
        //4，把集合中的数据存储到流所对应的文件中
        prop.store(out, "save data");
        //5，关闭流
        out.close();
    }
}

需求：从属性集文件prop.properties 中取出数据，保存到集合中

public class PropertiesDemo03 {
    public static void main(String[] args) throws IOException {
        //1，创建集合
        Properties prop = new Properties();
        //2，创建流对象
    FileReader in = new FileReader("prop.properties");
        //3,把流所对应文件中的数据 读取到集合中
        prop.load(in);
        //4,关闭流
        in.close();
        //5,显示集合中的数据
        System.out.println(prop);
    }
}

5.11 NIO和NIO.2

NIO（New IO）：

从 JDK 1.4 开始引入的一个用来替代传统IO的API。NIO与传统的IO具有相同的作用，但是使用的方式是不一样的。NIO是面向缓冲区（Buffe）的、基于通道（Channel）。

从 JDK 1.7 开始加入了一些新的元素。被称作 NIO.2

NIO 和 IO 有什么区别：

IO是面向流（Stream）的，NIO是面向缓冲区（Buffer）的。
IO是阻塞型的，NIO是非阻塞型的。

缓冲区Buffer：是一个用来存储基本数据类型的容器。

按照其存储的数据类型不同，缓冲区有着不同的分类：（没有boolean）

ByteBuffer、ShortBuffer、IntBuffer、LongBuffer、FloatBuffer、DoubleBuffer、CharBuffer

以上，这些缓冲区有着相同的方法来进行获取和数据的管理。因为所有以上的缓冲区都是继承自Buffer类的。

常用属性和方法：

1，获取缓冲区：不是通过new的方式，而是通过静态方法 allocate(int capacity) 来获取缓冲区。

2，属性：

capacity: 容量。表示缓冲区最多可以存储多少数据。一旦设置后，将不能改变。
limit: 界限。表示缓冲区可以操作的数据数量。（实际上存储了多少数据）。
position: 位置。缓冲区中正在进行操作的数据的位置。
mark: 使用mark()方法标记的位置。
mark <= position <= limit <= capacity

3，常用方法：

put()：将数据放入缓冲区

get()：从缓冲区中获取数据

flip()：切换成读模式

rewind()：重新读取（position重置为0）

clear()：清空缓冲区。将缓冲区中limit和position重置为allocate之后的状态。

clear方法只是重置了一下标记，缓冲区中的数据还在。

mark()：在指定的position做一个标记

public class FileDemo{
    public static void main(String[] args) throws IOException {
        // 设置输入源 & 输出目的 = 文件
        String infile = "a.txt";
        String outfile = "b.txt";
        // 1. 获取数据源 和 目标传输地的输入输出流（此处以数据源 = 文件为例）
        FileInputStream fin = new FileInputStream(infile);
        FileOutputStream fout = new FileOutputStream(outfile);
        // 2. 获取数据源的输入输出通道
        FileChannel fcin = fin.getChannel();
        FileChannel fcout = fout.getChannel();
        // 3. 创建缓冲区对象
        ByteBuffer buff = ByteBuffer.allocate(1024);
        while (true) {
            // 4. 从通道读取数据 & 写入到缓冲区
            // 注：若 以读取到该通道数据的末尾，则返回-1
            int r = fcin.read(buff);
            if (r == -1) {
                break;
            }
            // 5. 传出数据准备：调用flip()方法
            buff.flip();
            // 6. 从 Buffer 中读取数据 & 传出数据到通道
            fcout.write(buff);
            // 7. 重置缓冲区
            buff.clear();
        }
    }
}