IO流

IO流

File类（java.io）

一个文件和目录路径的抽象表示。

构造方法

File(File parent,String child) :parent表示上一级路径的对象，child表示文件的路径

File(String pathname):pathname表示文件或目录的路径。

File(String parent,String child) :parent表示上一级目录的路径，child表示子文件的路径

File(URI uri):uri 统一资源标识符

File类的成员方法

pathSeparator 文件分割符 ;

Separator 路径分割符 \

		//创建一个File对象
		File file = new File("D:\\aa\\d.txt");
        //删除文件,返回boolean值
        file.delete();
        //判断是否存在,返回boolean值
        file.exists();
        //获取file对象的绝对路径(从盘符开始)
        file.getAbsolutePath();
        //获取file对象的绝对路径的file对象
        file.getAbsoluteFile();
        //获取路径(类型与file对象中路径的类型相同)
        file.getPath();
        //判断是否为目录
        file.isDirectory();
        //判断是否为文件
        file.isFile();
        //返回文件的实际大小,单位为字节
        file.length();
        //返回文件中子文件和目录的list数组
        file.list();

绝对路径和相对路径

​ 绝对路径：windows：是从系统盘符开始的路径

​ Linux：是从根路径（\）开始的路径

​ 相对路径：相对于工程的根目录，也就是工程（工作空间）那个文件夹

遍历文件夹

		//创建一个File对象
        File file = new File("E:\\mydirectory");
        //得到这个目录下的列表
        String[] list = file.list();
        //遍历数组
        for (String s:list){
            System.out.println(s);
        }

递归

在方法中自己调用自己，必须有一个出口（终止条件）。

把复杂的功能逐层向下分解，然后由最简单的功能逐层向上回归计算，得到结果

递归的分类

​ 1.直接递归

​ 2.间接递归

public static void main(String[] args) {
        getNum(5);

    }
    //定义递归的方法
    public static int getNum(int n){
        //n=1为程序的出口（终止条件）
        if (n==1){
            return 1;
        }
        //递归调用
        return n+getNum(n-1);
    }

递归遍历文件夹

 public static void main(String[] args) {
        printDir(new File("D:\\software\\python"));

    }
    public static void printDir(File file){
        //如果file是一个目录，就得到该目录下的列表
        File[] files = file.listFiles();
        //遍历
        for (File f:files){
            if(file.isFile()){
                System.out.println("文件"+f.getPath());
            }else{
                System.out.println("目录"+f.getPath());
                printDir(f);
            }
        }
    }

字节流

文件存储的原理

任何格式的文件在计算机底层中都是以字节的形式存储

FileOutputStream流

		//创建FileOutputStream流,如果是true表示追加，flase表示覆盖
        //不存在文件则新建一个
        FileOutputStream fos = new FileOutputStream("a.txt",true);
        //写入字节数据
        fos.write("hello".getBytes());
		//使用完之后关流
		fos.close();

输入流InputStream和FileInputStream

InputStream是一个抽象类，为子类提供了读写数据的基本方法。

FileInputStream是它的子类，是专门读取文件中的数据的。

		//创建一个字节输入流对象
        FileInputStream fis = new FileInputStream("E:\\a.txt");
        //一次读取一个字节，返回字节的ASCII码
        int num = fis.read();
        //一次读取多个字节
        //1.方式一,返回的是字节读到的个数
        byte[] b = new byte[5];
        fis.read(b);
        //将字节数组转换为字符串
        String str = new String(b,0,num);
        //2.方式二
        fis.read(b,0,3);
        String str2 = new String(b,0,num);

复制文件

 public static void wAndR(FileInputStream fis,FileOutputStream fos,File f,File fileDest) throws IOException {
        fis = new FileInputStream(f);
        fos = new FileOutputStream(fileDest);
        byte[] b = new byte[1024];
        int len = -1;
        while((len=fis.read(b))!=-1){
            fos.write(b，0，len);
        }
     fos.close;
     fis.close; 

编码

一种把字符转成字节的规则

从文件读取的编码和向文件写入的编码不一致，会导致乱码。

解决方式：保持两个编码类型一致。

解码

把字节转成字符

缓冲流

可以提高程序读写数据的效率

BufferedOutputStream流

		//创建一个缓冲输出流
        FileOutputStream fis = new FileOutputStream("a.txt");
        //创建一个字节缓冲流
        BufferedOutputStream bos = new BufferedOutputStream(fis);
        //传入一个字符对应的数字，写入字符对应的字节数字
        bos.write(97);
        //将字节数组中的一部分数据写入文件中
        bos.write("hello".getBytes(),0,4);
        //关流
        bos.close();

BufferedInputStream流

		//创建字节输入流
        FileInputStream fis = new FileInputStream("a.txt");
        //创建缓冲字节输入流
        BufferedInputStream bis = new BufferedInputStream(fis);
        //读取文件，返回读取的字节个数
        bis.read();
        byte[] b = new byte[5];
        //读取多个字节，存到字节数组中,并返回读取的字节个数
        int len = bis.read(b);
        String s = new String(b);
        System.out.println(s);

转换流OutPutStreamWriter和InPutStreamWriter

是位于字节流和字符流之间的流，充当了桥梁。可以按照指定的字符集编码从文件中读取数据，转成字符数据，

可以把字符数据按照指定的编码写入文件中。