File，IO流，递归详解

File类

介绍

java.io.File类是Java语言提供了用来描述文件和目录(文件夹)的

构造

方法

注意：

• 构造方法中通常用的是第一个方法
• 文件和目录可以通过File封装成对象
• File封装的对象仅仅是一个路径名，它是可以存在的，也可以不存在
  

绝对路径和相对路径

绝对路径带盘符，相对路径对于当前工程中写模块名+文件即可

常用方法

创建

删除

注意：

• delete方法直接删除不走回收站(平时电脑上的shift+delete一样)
• 如果删除的是一个文件，可以直接删除
• 如果删除的是一个文件夹，需要先删除文件夹中的内容，最后才能删除文件夹
  

判断和获取

注意：
如果创建File对象时输入的是相对录井，同getAbsolutePath()方法还是获取绝对路径

高级获取

注意：

• 当调用者不存在时，返回null
• 当调用者是一个文件时，返回null
• 当调用者是一个空文件夹时，返回一个长度为0的数组
• 当调用者是一个有内容的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回
• 当调用者是一个有隐藏文件的文件夹时，将里面所有文件和文件夹的路径放在File数组中返回，包含隐藏内容
  

IO流

概述

I流：将在磁盘文件中的存储的数据读取到内存中(读数据)
O流：将在内存中的数据写入到磁盘文件(写数据)

解决问题

以前存储数据的做法：通过变量，数组，集合存储数据，都不能永久化存储，因为数据是存储在内存中，只要代码运行结束，所有数据就会丢失

1. 将程序中存储的数据写入到文件中，实现永久化存储
2. 将文件中的数据读取到内存中(Java程序)

内存在读，内存在写

分类

InputStream：输入流

• 字节输入流
• 字符输入流

OutputStream：输出流

• 字节输出流
• 字符输出流

字节流：万能流(所有类型的文件都可以读写)
字符流：通常用于针对文本文件进行读写操作

• 纯文本文件：使用计算机的记事本软件打开能看得懂的文件
  

书写IO流的套路

1. 创建
   1. 实例化不同的IO流
2. 进行操作(读，写)
   1. 读：read()
   2. 写：write()
3. 关闭
   1. close()
      

字节输出流

遵循上面的套路

1. 创建

OutputStream是一个抽象类，得用它的子类来实例化(FileOutputStream)
创建字节输出流的对象的时候，如果文件不存在，就创建；如果文件存在，将该文件中的内容清空

2. 写数据

要想换行：加换行符

os.write("\r\n".getBytes());

不同的操作系统，换行符各不相同

3.关流
os.close();
注意：
要不想在写入时让文件中数据清空，可以在创建时，在文件名后面加true

字节输入流

1. 创建

InputStream也是抽象类，用其子类进行实例化(FileInputStream)
这里和输出流不同的是，如果文件不存在，就会报错

2. 读取

读取出来的是文件中数据的码表值；当读取到的值为-1时，说明当前读取到文件末尾
int read();
提高读取效率，可以用int read(byte[] buf);
从输入流读取最多buf.length个字节的数据，返回的是真实读到的数据个数
byte buf = new byte[1024];
int len = is.read(buf);

3. 关流(释放资源)

is.close();

练习(文件复制)

1. 创建字节输入流(与源文件关联)
2. 创建字节输出流(与目标文件关联)
3. 使用字节输入流，读取源文件中的字节数据
4. 把读取到的字节数据写入到目标文件
5. 循环3，4，直到读取到的值为-1时结束循环
6. 释放资源

 public static void main(String[] args) throws IOException {
        //1.字节输入流
        InputStream is = new FileInputStream("源文件");

        //2.字节输出流
        OutputStream os = new FileOutputStream("目标文件", true);

        //3.读，写
        int data = 0;
        while (data != -1){
            data = is.read();
            os.write(data);
        }

        //释放资源
        is.close();
        os.close();

    }
}

IO资源的处理

在创建和操作的过程中我们都会有编译时异常，在平常练习中进行抛出，而在实际开发中要进行try…catch处理，但是我们释放资源这一步必须要执行，所有，
JDK7之前，增加了个try…catch…finally块，在finally代码块的代码一定会执行，所以可以将释放资源的代码放到finally代码块中
而在JDK7时，对流的释放做了优化，使用try-with-resource语句，确保每个资源在语句结束时自动关闭(不需要写os.close()😉
但是这个有个前提是资源对象有实现AutoCloseable接口

    try ( FileInputStream fis1 = new FileInputStream("day11_demo\\a.txt") ; 
	FileInputStream fis2 = new FileInputStream("day11_demo\\b.txt") ) 
    {
        // 读写数据
    } catch (IOException e) {
        处理异常的代码...
    }

字节流缓冲流(高效流)

剩下的读写和关流与上面的基础流(字节流、字符流)用法一样

//构造方法： public  BufferedInputStream( InputStream  is )

BufferedInputStream bis = new BufferedInputStream( new FileInputStream("关联文件") );

//构造方法： public  BufferedOutputStream( OutputStream  os )

//覆盖写入
BufferedOutputStream bos = new BufferedOutputStream( new FileOutputStream("关联文件") );


//追加写入 （构造方法的第二个参数为true）
FileOutputStream fos = new FileOutputStream("关联文件" , true); //追加写入
BufferedOutputStream bos = new BufferedOutputStream(  fos );//当前流有具有追加写入能力

Properties类

介绍

1. 作为Map集合的子类存在(存储的数据：key，value)
2. 可以结合IO流使用(读，写)

不需要加泛型，默认存储的是Object类型

构造方法

Properties prop = new Properties();

常用方法

作用

读取开发中使用到的.properties配置文件

ResourceBundle工具类

递归

介绍

递归就是方法自己调用自己的结果，是应用是方法上的解决方案
递归=递进+回归

组成

递归前进段，边界条件，递归返回段
当边界条件不满足是，递归前进
当边界条件满足时，递归返回

执行过程

隐患

每次递归方法都会入栈，从而占用栈内存资源，当递归次数太多，栈内存用完时会造成内存溢出错误

案例

查看某个文件中的所有Java文件

    public static void main(String[] args) {
        File file = new File("要查看的文件");

        getJavaFile(file);
    }
    public static void getJavaFile(File file){
        if (file == null){
            throw new RuntimeException("文件不能为空");
        }

        File[] files = file.listFiles();

        for (File f : files) {
            if (f.isFile()){
                if(f.getName().endsWith(".java")){
                    System.out.println(f.getAbsolutePath());
                }
            } else if (f.isDirectory()) {
                getJavaFile(f);
            }

        }
    }