揭秘IO流绝技，内存、打印、压缩流一手掌控！

1

内存操作流

字节数组输入流的操作与文件输入操作流的操作一样

2

打印流

@Test
  public void test() throws IOException {
    System.out.println("打印流");
     System.out本身就是PrintStream的实例，所以可以直接赋值
    PrintStream ps = System.out; 
    ps.println(100);  默认输出到控制台


     用PrintStream输出到文件
    File file = new File("D:/file/txt/print.txt");
    ps = new PrintStream(new BufferedOutputStream(new FileOutputStream(file)));
    ps.println("print io test ...");
    ps.flush();
    ps.close();
  }

打印流
100

@Test
  public void test1() throws IOException {
     System的三个常量：
    System.out.println("test");
    System.err.println("error");  输出的字体是红色的


    InputStream is = System.in; // 键盘输入
    Scanner scanner = new Scanner(is);
    System.out.println("Scanner 请输入：");
    System.out.println(scanner.nextLine());


    // 封装字节输入流似Scanner
    BufferedReader br = new BufferedReader(new InputStreamReader(is)); // 字节流转字符流
    System.out.println("封装字节输入流似Scanner 请输入：");
    System.out.println(br.readLine());


    // 键盘输入改为文件输入
    InputStream is1 = new BufferedInputStream(new FileInputStream(new File("D:/file/txt/print.txt")));
    Scanner scanner1 = new Scanner(is1);
    System.out.println(scanner1.nextLine());


    close(scanner1, is1, scanner, is);
  }


  /**
   * 关闭资源，用可变参数实现，可变参数：用三个点表示，只能放在形参的最后一个位置
   */
  public static void close(Closeable... io) {
    if (io != null) {
      for (Closeable closeable : io) {
        try {
          if (closeable != null) {
            closeable.close();
          }
        } catch (IOException e) {
          e.printStackTrace();
        }
      }
    }
  }

test
error
Scanner 请输入：
可多看点
可多看点
封装字节输入流似Scanner 请输入：
你好
你好
print io test ...

3

压缩流

@Test
  public void test() throws IOException {
    // 指定要压缩的文件夹
    File srcFile = new File("D:/file/txt/print.txt");
    // 指定压缩后的文件
    File zipFile = new File("D:/file/txt/print.zip");
    // 定义输入文件流
    InputStream is = new BufferedInputStream(new FileInputStream(srcFile));
    // 定义压缩输出流
    OutputStream out = new BufferedOutputStream(new FileOutputStream(zipFile));
    ZipOutputStream zipOut = new ZipOutputStream(out);
    // 压缩文件的每一个子文件都是一个ZipEntry，需要为ZipEntry设置名称
    System.out.println(srcFile.getName());
    ZipEntry entry = new ZipEntry(srcFile.getName());
    // 设置entry对象
    zipOut.putNextEntry(entry);
    // 关闭当前entry对象
    zipOut.closeEntry();
    // 压缩操作
    byte[] b = new byte[1024];
    int len = 0;
    while ((len = is.read(b)) != -1) {
      zipOut.write(b, 0, len); // 压缩内容
    }
    zipOut.flush();
    zipOut.close();
    is.close();
  }

@Test
  public void test1() throws Exception {
    // 指定要压缩的文件夹
    File srcFile = new File("D:/file/txt");
    // 指定压缩后的文件
    File zipFile = new File("D:/file/txt.zip");
    // 定义压缩输出流
    OutputStream out = new BufferedOutputStream(new FileOutputStream(zipFile));
    ZipOutputStream zipOut = new ZipOutputStream(out);
    // 压缩文件夹
    zipFile(zipOut, srcFile, srcFile.getName());
    zipOut.flush();
    zipOut.close();
  }
  
  /**
   * @Description: 递归压缩文件夹<br>
   * @param zipOut  压缩输出流，必须在外部关闭
   * @param src     要压缩的目标文件夹
   * @param zipPath 压缩后的目标文件路径
   */
  public void zipFile(ZipOutputStream zipOut, File src, String zipPath) throws FileNotFoundException, IOException {
    if (src.isDirectory()) {
      File[] files = src.listFiles();
      if (files != null && files.length > 0) {
        for (File file : files) {
          // 压缩包中如果要保留原来的文件结构，必须带上父文件夹的名字加一斜杠，否则所有文件都写到压缩包目录下了
          zipFile(zipOut, file, zipPath + "/" + file.getName());
        }
      } else { // 对空文件夹也进行压缩
        zipOut.putNextEntry(new ZipEntry(zipPath + "/"));
        zipOut.closeEntry();
      }
    } else {
      InputStream is = new BufferedInputStream(new FileInputStream(src));
      zipOut.putNextEntry(new ZipEntry(zipPath));
      byte[] b = new byte[1024];
      int len = 0;
      while ((len = is.read(b)) != -1) {
        zipOut.write(b, 0, len);
      }
      zipOut.closeEntry();
      is.close();
    }
  }

@Test
  public void test2() throws ZipException, IOException {
    // 找到压缩文件
    File srcFile = new File("D:/file/txt/print.zip");
    // 定义解压缩的文件名称
    File destFile = new File("D:/file/txt/print_unzip.txt");
    // 创建ZipFile对象
    ZipFile zipFile = new ZipFile(srcFile);
    // 根据压缩文件里的名称获取ZipEntry对象，名称必须能找到，否则获取输入流时空指针异常
    ZipEntry entry = zipFile.getEntry("print.txt");
    if (entry != null) {
      // 根据ZipEntry对象获取ZipEntry输入流
      InputStream is = zipFile.getInputStream(entry);
      // 创建输出流
      OutputStream os = new BufferedOutputStream(new FileOutputStream(destFile));
      // 读取并输出
      byte[] b = new byte[1024];
      int len = 0;
      while ((len = is.read(b)) != -1) {
        os.write(b, 0, len);
      }
      os.flush();
      os.close();
      is.close();
    }
    zipFile.close();
  }

@Test
  public void testUnZip() throws IOException {
    // 指定要解压缩的文件夹
    File srcFile = new File("D:/file/txt.zip");
    // 指定解压缩后的目录
    String destPath = "D:/file/txt_unzip/";
    unZipFile(srcFile, destPath);
  }


  /**
   * @Description: 文件夹解压方法<br>
   * @param srcFile  要解压缩的文件夹
   * @param destPath 指定解压缩后的目录
   */
  public void unZipFile(File srcFile, String destPath) throws FileNotFoundException, IOException {
    // 创建zip输入流
    ZipInputStream zis = new ZipInputStream(new BufferedInputStream(new FileInputStream(srcFile)));
    ZipEntry entry = null;
    OutputStream os = null;
    // 指定解压缩后的文件
    File destFile = null;
    while ((entry = zis.getNextEntry()) != null) {
      destFile = new File(destPath + entry.getName());
      // entry有两种情况，要么是文件夹，要么是文件
      if (entry.isDirectory()) { // 如果是文件夹，可以先创建，这样空文件夹也能解压缩
        destFile.mkdirs();
      } else {
        if (!destFile.getParentFile().exists()) { // 创建文件的父目录，否则找不到路径
          destFile.getParentFile().mkdirs();
        }
        os = new BufferedOutputStream(new FileOutputStream(destFile));
        byte[] b = new byte[1024];
        int len = 0;
        while ((len = zis.read(b)) != -1) {
          os.write(b, 0, len);
        }
        os.flush();
        os.close();
      }
    }
    zis.close();
  }

在文章的最后用一张图来总结一下 Java IO 的重点流，大家掌握了字节流和缓存流就足够使用了，IO 操作是有套路的，通过 Java IO 四篇文章的学习，相信 IO 操作对你来说已经不是问题了。