Java进阶 -- IO流(字节输入输出流)

File类和递归思想

• 概念：File表示文件或者文件夹在硬盘中的路径。不能保证表示的文件或者文件夹一定存在。
• 构造方法：
  File(String pathname)：通过将给定的路径名字符串创建File对象。
File(String parent, String child)：从父路径名字符串和子路径名字符串创建新的 File对象，一般parent表示父目录，child表示子文件或者目录。
File(File parent, String child)：从父抽象路径名和子路径名字符串创建新的 File实例。
• 成员方法：
  1. 创建的方法
     public boolean createNewFile()：创建一个新文件，返回值为是否创建成功。如果文件已经存在，则不创建，返回值false。
public boolean mkdir()：创建单级目录，返回值为是否创建成功。如果目录已经存在，则不创建，返回值false。
public boolean mkdirs()：创建多级目录，返回值为是否创建成功。如果目录已经存在，则不创建，返回值false。
     提示：mkdirs()也可以创建单级目录。
  2. 判断的方法
     public boolean isDirectory()：测试此抽象路径名表示的File是否为目录
public boolean isFile()：测试此抽象路径名表示的File是否为文件
public boolean exists()：测试此抽象路径名表示的File是否存在
  3. 获取的方法
     public String getAbsolutePath()：返回此抽象路径名的绝对路径名字符串
public String getName()：返回由此抽象路径名表示的文件或目录的名称
public File[] listFiles()：返回此抽象路径名表示的目录中的文件和目录的File对象数组
  4. 删除的方法
     public boolean delete()：删除由此抽象路径名表示的文件或目录
     注意：
     1 如果是删除目录，那么只能删除空目录，如果目录中有内容，应该要先删除其中的内容。
     2 调用delete()方法删除的内容不进回收站，是彻底的删除。
• 补充：路径的写法：
  1. 绝对路径：以盘符开头的路径就是绝对路径 例如：C:/aaa/bbb/abc.txt d:/aaa/bbb/abc.txt
  2. 相对路径(常用)：路径不带盘符。相对的是project，module在project中。也就是说默认从project中根据相对路径查找。
     相对路径是以./或者…/开头，但是./可以省略不写。./表示当前目录, …/表示上一级目录
     例如：
     ./day08/abc.txt 也可以简写成 day08/abc.txt
     …/abc.txt 表示project的上一级目录下有个abc.txt

package com.jxufe_ldl.class01;

import java.io.File;
import java.io.IOException;

/*
    相对路径：相对project目录的，"./":表示当前目录，"../":表示上一级目录
 */
public class FileDemo03 {
    public static void main(String[] args) throws IOException {
        // 创建一个File对象
        File f1 = new File("./day08");
//        File f1 = new File("./day08//JAVA");

//        f1.createNewFile();
//        f1.mkdir();
        /*System.out.println(f1.isFile());
        System.out.println(f1.isDirectory());
        System.out.println(f1.exists());

        System.out.println(f1.getAbsoluteFile().isFile());
        System.out.println(f1.getAbsolutePath());
        System.out.println(f1.getPath());
        System.out.println(f1.getName());*/

        String[] strArr = f1.list();
        for (String str : strArr) {
            System.out.println(str);
        }

        System.out.println("-----------");

        File[] filesArr = f1.listFiles();
        for (File file : filesArr) {
            if (file.isFile()) {
                System.out.println(file.getName());
            }
        }

        System.out.println("-------------------");

        getAllFillPath(new File("day08"));
    }

    public static void getAllFillPath(File srcFile) {
//        System.out.println("目录："+srcFile.getAbsolutePath());
        File[] files = srcFile.listFiles();

        if (files != null) {
            for (File f : files) {
                if (f.isFile()) {
                    System.out.println("文件："+f.getAbsolutePath());
                } else {
                    getAllFillPath(f);
                }
            }
        }
    }
}

• 递归思想：
  概念：方法自己调自己。
  使用场景：如果一段操作需要重复执行，并且有一定的规律。
  思想：将一个复杂的问题拆成一个个简单的问题，每个简单的问题都解决了，那么大的问题也就解决。
  注意事项：
  1、递归一定要有出口
  2、递归的次数不能过多。

字节输出流

• IO流：input和output流，也叫做输入输出流。
  IO流分类：
  输入流：读数据，将硬盘中的文件内容加载到内存中。
  字节输入流：InputStream抽象类
  字符输入流：Reader抽象类
  输出流：写数据，将内存中的数据写到硬盘中。
  字节输出流：OutputStream抽象类
  字符输出流：Writer抽象类
  如果是读写文本文件(自带的记事本能打开的文件),使用字符流。如果是读写非文本文件，使用字节流。

• 字节输出流写数据的基本思路：
  1、创建字节输出流对象
  2、调用write方法写数据
  3、调用close方法释放资源

• 构造方法：
  FileOutputStream​(String name):根据字符串路径创建字节输出流对象
  1、不管文件是否存在都创建一个新文件2、创建流对象3、流对象指向新文件
  FileOutputStream​(String name, boolean append)：根据字符串路径创建字节输出流对象，参数2如果是true表示向文件中追加内容，不会创建新文件。
  创建文件输出流以指定的名称写入文件。

• 成员方法：
  void write​(byte[] b):将整个字节数组写到文件中
void write​(byte[] b, int off, int len)：将字节数组从索引off开始往后的len个字节写到文件中，只写字节数组的一部分。

• 写数据的两个小问题
  问题1：写数据换行，向文件中写一个换行符
  mac：\r
  linux: \n
  windows: \r\n
  现在都不区分系统了，随便使用哪个都可以

  问题2：文件数据追加
  FileOutputStream​(String name, boolean append)构造方法的第二个参数传递true，表示文件追加

public class DiguiDemo {
    public static void main(String[] args) {
        System.out.println(f(20));
    }
    // 定义一个方法：来计算第n个月的兔子对数
    public static int f(int n) {
        if (n == 1 || n == 2) {
            return 1;
        }
        return f(n-1) + f(n-2);
    }
}

字节输入流

• 功能：将硬盘中文件的内容读取到内存中
• 字节输入流读数据的基本思路：
  1、创建流对象
  2、调用read()方法读数据

 			/*
   在开发中byte数组的长度一般为1024或者1024的整数倍。1024个字节=1kb；
             */
    byte[] bytes=new byte[1024];//这个字节数组可以看成是一个容器，每次往这个容器中存数据。
    int len=0;//保存每次读写的个数，如果为-1，表示读完了
    while ((len=fis.read(bytes))!=-1){
        System.out.print(new String(bytes,0,len));
    }

package com.jxufe_ldl.class04;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class CopyFile {
    public static void main(String[] args) {
        // 1. 创建输入、输出流对象
        FileOutputStream fos = null; // 输出流，写数据
        FileInputStream fis = null;   // 输入流，读数据
        try {
            fos = new FileOutputStream("day08//src//com//jxufe_ldl//class04//fos.txt");
            fis = new FileInputStream("day08//fis.txt");

            // 2. 文件操作，读文件数据和写文件数据
            // 规则：一边读，一边写，一次读写一个字节
            int buffe = 0;
            while ((buffe = fis.read()) != -1) {
                System.out.println(buffe);
                fos.write(buffe);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fos != null) {
                try {
                    // 3. 释放资源
                    fis.close();
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3、调用close​()释放资源

• 构造方法：
  FileInputStream​(String name)：根据字符串路径创建字节输入流对象
FileInputStream​(File file)：根据file路径创建字节输入流对象
  • 成员方法：
    int read​() ：一次读一个字节
int read​(byte[] b) ：一次读一个字节数组(常用),方法的返回值为实际读到的字节个数，读到文件末尾返回-1；
int read​(byte[] b, int off, int len)：一次读一个字节数组的一部分,方法的返回值为实际读到的字节个数，读到文件末尾返回-1；

/*
    图片复制
 */
public class CopyFile03 {
    public static void main(String[] args) throws IOException {
        // 1. 创建输入输出流
        FileInputStream fis = new FileInputStream("day08//src//com//jxufe_ldl//class04//day01_02.png"); // 读
        FileOutputStream fos = new FileOutputStream("day08//day01_02.png");//写

        // 2. 复制图片
        byte[] bytes = new byte[1024]; // 用来存放每一次存放的数据
        int len = 0; // 读取数据的长度

        while ((len = fis.read(bytes)) != -1) {
            fos.write(bytes, 0, len);
        }

        // 3. 释放资源
        fis.close();
        fos.close();
    }
}

• IO总结：
  输入流：FileInputStream
  输出流：FileOutputStream

  需要掌握文件复制-一次读写一个字节数组的方法。