写在前面

今天继续讲JavaIO流的知识！

Java 文件与流操作

File 类

File 类用于表示文件和文件夹的抽象。

构造方法

• public File(String pathname): 使用路径名创建 File 对象。
• public File(String parent, String child): 使用父目录和子目录名称创建 File 对象。
• public File(File parent, String child): 使用父 File 对象和子目录名称创建 File 对象。

成员方法

创建功能

• public boolean createNewFile(): 创建一个新文件。
• public boolean mkdir(): 创建单个目录。
• public boolean mkdirs(): 创建目录，包括必要但不存在的父目录。

删除功能

• public boolean delete(): 删除文件或目录。

重命名功能

• public boolean renameTo(File dest): 重命名文件或目录。

判断功能

• public boolean isDirectory(): 判断是否为目录。
• public boolean isFile(): 判断是否为文件。
• public boolean exists(): 判断文件或目录是否存在。
• public boolean canRead(): 判断是否可读。
• public boolean canWrite(): 判断是否可写。
• public boolean isHidden(): 判断是否为隐藏文件。

基本获取功能

• public String getAbsolutePath(): 获取绝对路径。
• public String getPath(): 获取路径。
• public String getName(): 获取文件名。
• public long length(): 获取文件长度。
• public long lastModified(): 获取最后修改时间。

高级获取功能

• public String[] list(): 获取目录中的文件和目录名称。
• public File[] listFiles(): 获取目录中的 File 对象数组。

文件名称过滤器

• public String[] list(FilenameFilter filter): 使用文件名过滤器获取文件和目录名称。
• public File[] listFiles(FilenameFilter filter): 使用文件名过滤器获取 File 对象数组。

字节流

字节输入流

• 抽象父类: InputStream
  • 实现子类:
    • FileInputStream
      • 创建对象的方式：

        FileInputStream fis = new FileInputStream("路径");
        

      • 读取数据的方式：
        • 一次读取一个字节：

          int i = 0;
          while ((i = fis.read()) != -1) {
              System.out.print((char) i);
          }
          

        • 一次读取一个字节数组：

          byte[] bytes = new byte[1024];
          int length = 0;
          while ((length = fis.read(bytes)) != -1) {
              String s = new String(bytes, 0, length）;
              System.out.print(s);
          }
          

        • 一次读取一个字节数组的一部分。

          byte[] bytes = new byte[1024];
          int length = 0;
          while ((length = fis.read(bytes)) != -1) {
              String s = new String(bytes, 这里写从哪个索引开始截取, 这里写自己想要截取的长度);
              System.out.print(s);
          }
          

    • BufferedInputStream
      • 创建对象的方式：

        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("路径"));
        

      • 读取数据的方式：
        • 一次读取一个字节：

          int i = 0;
          while ((i = bis.read()) != -1) {
              System.out.print((char) i);
          }
          

        • 一次读取一个字节数组：

          byte[] bytes = new byte[1024];
          int length = 0;
          while ((length = bis.read(bytes)) != -1) {
              String s = new String(bytes, 0, length);
              System.out.print(s);
          }
          

        • 一次读取一个字节数组的一部分。

          byte[] bytes = new byte[1024];
          int length = 0;
          while ((length = bis.read(bytes)) != -1) {
              String s = new String(bytes, 这里写从哪个索引开始截取, 这里写自己想要截取的长度);
              System.out.print(s);
          }
          

字节输出流

• 抽象父类: OutputStream
  • 实现子类:

    • FileOutputStream

      • 创建对象的方式：

      #创建文件输出流以写入由指定的 File对象表示的文件。
      FileOutputStream(File file) 
      
      
      #创建文件输出流以写入由指定的 File对象表示的文件。  
      FileOutputStream(File file, boolean append) 
      
      
      #创建文件输出流以指定的名称写入文件。  
      FileOutputStream(String name) 
      
      
      #创建文件输出流以指定的名称写入文件。 
      FileOutputStream(String name, boolean append) 
      

      • 写数据的方式：
        • 写一个字节：

          fos.write(i);
          

        • 写一个字节数组：

          byte[] bytes = {97, 98, 99};
          fos.write(bytes);
          

        • 写字节数组的一部分：

          byte[] bytes = {97, 98, 99};
          fos.write(bytes, 1, 2);
          

    • BufferedOutputStream

      • 创建对象的方式：

        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("路径"));
        

      • 写数据的方式（注：这种方式写文件在写完之后需要flush一下，不然不会成功写入，后面说的以file对象进行传入参数的输入流基本上都要写完刷一下才有内容写入）：
        • 写一个字节：

          bos.write(i);
          

        • 写一个字节数组：

          byte[] bytes = {97, 98, 99};
          bos.write(bytes);
          

        • 写字节数组的一部分：

          byte[] bytes = {97, 98, 99};
          bos.write(bytes, 1, 2);
          

字符流

字符流是基于字节流的，并加上了编码表的支持。

字符输入流

• 抽象父类: Reader
  • 实现子类:
    • InputStreamReader
      • 创建对象的方式：

        InputStreamReader isr = new InputStreamReader(new FileInputStream("路径"));
        

      • 读取数据的方式：
        • 一次读取一个字符：

          int i = 0;
          while ((i = isr.read()) != -1) {
              System.out.print((char) i);
          }
          

        • 一次读取一个字符数组：

          char[] chars = new char[1024];
          int length = 0;
          while ((length = isr.read(chars)) != -1) {
              String s = new String(chars, 0, length);
              System.out.print(s);
          }
          

        • 一次读取一个字符数组的一部分。

          char[] chars = new char[1024];
          int length = 0;
          while ((length = isr.read(chars)) != -1) {
              String s = new String(chars, 开始索引, 要读的具体长度);
              System.out.print(s);
          }
          

    • FileReader
      • 创建对象的方式：

        FileReader fr = new FileReader("路径");
        

      • 读取数据的方式：
        • 一次读取一个字符：

          int i = 0;
          while ((i = fr.read()) != -1) {
              System.out.print((char) i);
          }
          

        • 一次读取一个字符数组：

          char[] chars = new char[1024];
          int length = 0;
          while ((length = fr.read(chars)) != -1) {
              String s = new String(chars, 0, length);
              System.out.print(s);
          }
          

        • 一次读取一个字符数组的一部分。

          char[] chars = new char[1024];
          int length = 0;
          while ((length = fr.read(chars)) != -1) {
              String s = new String(chars, 开始索引, 要读的具体长度);
              System.out.print(s);
          }
          

    • BufferedReader
      • 创建对象的方式：
        • 方式1：

          BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("路径")));
          

        • 方式2（简化版）：

          BufferedReader br = new BufferedReader(new FileReader("路径"));
          

      • 读取数据的方式：
        • 一次读取一个字符：

          int i = 0;
          while ((i = br.read()) != -1) {
              System.out.print((char) i);
          }
          

        • 一次读取一个字符数组：

          char[] chars = new char[1024];
          int length = 0;
          while ((length = br.read(chars)) != -1) {
              String s = new String(chars, 0, length);
              System.out.print(s);
          }
          

        • 一次读取一个字符数组的一部分。

          char[] chars = new char[1024];
          int length = 0;
          while ((length = br.read(chars)) != -1) {
              String s = new String(chars, 开始索引, 具体长度);
              System.out.print(s);
          }
          

        • 一次读取一行数据（不包括换行符）：

          String line = null;
          while ((line = br.readLine()) != null) {
              System.out.print(line);
          }
          

字符输出流

• 抽象父类: Writer
  • 实现子类:

    • OutputStreamWriter

      • 创建对象的方式：

        OutputStreamWriter osw = new OutputStreamWriter(new FileOutputStream("路径"));
        

      • 写数据的方式：
        • 一次写一个字符。

          osw.write(i);
          

        • 一次写一个字符数组。

          char[] chars = {'a', 'b', 'c'};
          osw.write(chars);
          

        • 一次写一个字符数组的一部分。

          char[] chars = {'a', 'b', 'c'};
          osw.write(chars, 1, 2);
          

        • 一次写一个字符串。

          osw.write("example");
          

        • 一次写一个字符串的一部分。

          osw.write("example", 1, 4);
          

    • FileWriter

      • 创建对象的方式：

        FileWriter fw = new FileWriter("路径");
        

      • 写数据的方式：
        • 一次写一个字符。

          fw.write(i);
          

        • 一次写一个字符数组。

          char[] chars = {'a', 'b', 'c'};
          fw.write(chars);
          

        • 一次写一个字符数组的一部分。

          char[] chars = {'a', 'b', 'c'};
          fw.write(chars, 1, 2);
          

        • 一次写一个字符串。

          fw.write("example");
          

        • 一次写一个字符串的一部分。

          fw.write("example", 1, 4);
          

    • BufferedWriter

      • 创建对象的方式：
        • 方式1：

          BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("路径")));
          

        • 方式2（简化版）：

          BufferedWriter bw = new BufferedWriter(new FileWriter("路径"));
          

      • 写数据的方式：
        • 一次写一个字符：

          bw.write(i);
          

        • 一次写一个字符数组：

          char[] chars = {'a', 'b', 'c'};
          bw.write(chars);
          

        • 一次写一个字符数组的一部分：

          char[] chars = {'a', 'b', 'c'};
          bw.write(chars, 1, 2);
          

        • 一次写一个字符串：

          bw.write("example");
          

        • 一次写一个字符串的一部分：

          bw.write("example", 1, 4);
          

        • 特殊功能：自动生成换行符：

          bw.newLine();
          

文件的读写复制

字节流

• 普通字节输入输出流：一次读写一个字节。

    FileInputStream inputPath = new FileInputStream("inputpath");
    FileOutputStream outputPath = new FileOutputStream("outpath");

    int i = 0;
    while ((i = inputPath.read()) != -1) {
        outputPath.write((char) i);
     }
    inputPath.close();
    outputPath.close();

• 带缓冲的字节输入输出流：一次读写一个字节。

    BufferedInputStream inputpath = new BufferedInputStream(new FileInputStream("inputpath"));
    BufferedOutputStream outputpath = new BufferedOutputStream(new FileOutputStream("outpath"));

    int i = 0;

    while ((i = inputpath.read()) != -1) {
        outputpath.write((char) i);
        outputpath.flush;
     }

    inputpath.close();
    outputpath.close();
        

• 普通字节输入输出流：一次读写一个字节数组。

    FileInputStream inputPath = new FileInputStream("inputpath");
    FileOutputStream outputPath = new FileOutputStream("outpath");

    byte[] bytes = new byte[1024];
    int length = 0;
    while ((length = inputPath.read(bytes)) != -1) {
        outputPath.write(bytes, 0, length);
        outputPath.flush();
     }
    inputPath.close();
    outputPath.close();

• 带缓冲的字节输入输出流：一次读写一个字节数组（此方式的效率最高）。

    BufferedInputStream inputpath = new BufferedInputStream(new FileInputStream("inputpath"));
    BufferedOutputStream outputpath = new BufferedOutputStream(new FileOutputStream("outpath"));

    byte[] bytes = new byte[1024];
    int length = 0;
    while ((length = inputpath.read(bytes)) != -1) {
        outputpath.write(bytes, 0, length);
        outputpath.flush();
    }

    inputpath.close();
    outputpath.close();

字符流

• 普通字符输入输出流：一次读写一个字符。

    InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("inputpath"));
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("outputpath"));

    int i = 0;
    while ((i = inputStreamReader.read()) != -1) {
        outputStreamWriter.write(i);
        outputStreamWriter.flush();
    }

    inputStreamReader.close();
    outputStreamWriter.close();

• 普通字符输入输出流：一次读写一个字符数组。

    InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream("inputpath"));
    OutputStreamWriter outputStreamWriter = new OutputStreamWriter(new FileOutputStream("outputpath"));

    char[] chars = new char[1024];
    int length = 0;
    while ((length = inputStreamReader.read(chars)) != -1) {
        outputStreamWriter.write(chars,0,length);
        outputStreamWriter.flush();
    }

    inputStreamReader.close();
    outputStreamWriter.close();

• 简化写法字符输入输出流：一次读写一个字符。

    FileReader fileReader = new FileReader("inputpath");
    FileWriter fileWriter = new FileWriter("outputpath");

    int i = 0;
    while ((i = fileReader.read()) != -1) {
        fileWriter.write(i);
        fileWriter.flush();
    }

    fileWriter.close();
    fileReader.close();

• 简化写法字符输入输出流：一次读写一个字符数组。

    FileReader fileReader = new FileReader("inputpath");
    FileWriter fileWriter = new FileWriter("src/com/shujia/data/b.txt");

    char[] chars = new char[1024];
    int length = 0;
    while ((length = fileReader.read(chars)) != -1) {
        fileWriter.write(chars,0,length);
        fileWriter.flush();
    }

    fileWriter.close();
    fileReader.close();

• 字符缓冲输入输出流：一次读写一个字符。

    BufferedReader bufferedReader = new BufferedReader(new FileReader("inputpath"));
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("outpath"));

    int i = 0;
    while ((i = bufferedReader.read()) != -1) {
         bufferedWriter.write(i);
         bufferedWriter.flush();
    }

    bufferedWriter.close();
    bufferedReader.close();

• 字符缓冲输入输出流：一次读写一个字符数组。

    BufferedReader bufferedReader = new BufferedReader(new FileReader("inputpath"));
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("outpath"));

    char[] chars = new char[1024];
    int length = 0;
    while ((length = bufferedReader.read(chars)) != -1) {
    bufferedWriter.write(chars,0,length);
    bufferedWriter.flush();
    }

    bufferedWriter.close();
    bufferedReader.close();

• 字符缓冲输入输出流：一次读写一行数据。

    BufferedReader bufferedReader = new BufferedReader(new FileReader("inputpath"));
    BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter("outpath"));

    String i = null;
    while ((i = bufferedReader.readLine()) != null) {
        bufferedWriter.write(i);
        bufferedWriter.newLine();
        bufferedWriter.flush();
     }

    bufferedWriter.close();
    bufferedReader.close();