IO流
- IO流- File
  - File类概述和构造方法:
  - 递归:

IO流

IO流- File

File类概述和构造方法:

     1. File类在io包下需要导包使用
     1. 继承了两个接口**Serializable**和**Comaparble**<File>(自然排序接口)

File类概述:

File类是文件和目录路径名的抽象表示

     1. 文件和目录是可以通过File封装成对象的
     1. 对于File而言,琪封装的并不是一个真正存在的文件,仅仅是一个路径名而已. 它可以是存在的, 也可以是不存在的.将来是要通过具体的操作把这个路径的内容转换为具体存在的

File类的构造方法:

File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
File(String parent,String child) 从父路径名字符串和子路径名字符串创建新的File实例
File(File parent,String child) 从父抽象路径名和子路径名字符串创建新的File实例
代码实现：
// File(String pathname) 通过将给定的路径名字符串转换为抽象路径名来创建新的File实例
// 给的路径不存在,但是可以执行方法,并且输出了String内容,说明重写了该方法,路径不存在但是可以运行.所以表示File仅仅抽象了路径,并没有具体存在
File file = new File(“D:\PgProject\test1\java.txt”);
System.out.println(_file)_; // 输出 D:\PgProject\test1\java.txt

// File(String parent,String child) 从父路径名字符串和子路径名字符串创建新的File实例
File file1 = new File(“D:\PgProject”,”test”);
System.out.println(_file1)_; // 输出 D:\PgProject\test1

// File(File parent,String child) 从父抽象路径名和子路径名字符串创建新的File实例
File file2 = new File(“D:\PgProject”);
File file3 = new File(_file2,”test”);
System._out.println(_file3)_;// 输出 D:\PgProject\test1

File类的创建功能方法:

public boolean createNewFile() 当具有该文件名不存在时，创建一个由该抽象路径名命名的新空文件
public boolean mkdir() 创建由此抽象路径名命名的目录
public boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
使用File类方法需要先实现构造方法的抽象路径，在使用添加文件方法
使用添加文件方法抛出异常，使用alt+enter一键抛出异常
如果文件或者目录不存在，就执行方法创建文件，并返回true
如果文件或者目录存在就不创建文件，并返回false
// public boolean createNewFile() 当具有该文件名不存在时，创建一个由该抽象路径名命名的新空文件
// 使用File类方法需要先实现构造方法的抽象路径，在使用添加文件方法
File file = new File(“D:\Test\java.txt”);
// 使用添加文件方法抛出异常，使用alt+enter一键抛出异常
boolean newFile = file.createNewFile();
System.out.println(_newFile)_; // true

//public boolean mkdir() 创建由此抽象路径名命名的目录
File file1 = new File(“D:\Test\java”);
boolean mkdir = file1.mkdir();
System.out.println(_mkdir)_; // true

//public boolean mkdirs() 创建由此抽象路径名命名的目录，包括任何必需但不存在的父目录
File file2 = new File(“D:\Test\javaSe\HTML”);
boolean mkdirs = file2.mkdirs();
System.out.println(_mkdirs)_; // true

// 在test创建一个目录并添加一个文件
File file3 = new File(“D:\Test\Java01”);
boolean b = file3.mkdir();
File file4 = new File(“D:\Test\Java01\java.txt”);
boolean newFile1 = file4.createNewFile();
System.out.println(_newFile1)_;

File类判断和获取功能方法:

public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
public boolean isFile() 测试此抽象路径名表示的File是否为文件
public boolean exists() 测试此抽象路径名表示的File是否存在
public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
public String getPath() 将此抽象路径名转换为路径名字符串
public String getName() 返回由此抽象路径名表示的文件或目录的名称
public String[] list() 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的File对象数组
// 先创建一个File的抽象路径对象
File file = new File(“D:\Test\java.txt”);
// public boolean isDirectory() 测试此抽象路径名表示的File是否为目录
boolean directory = file.isDirectory();
System.out.println(_directory); // false
// public boolean isFile() 测试此抽象路径名表示的File是否为文件
boolean isfile = file.isFile();
System._out.println(_isfile);// true
// public boolean exists() 测试此抽象路径名表示的File是否存在
boolean exists = file.exists();
System._out.println(_exists);// true
// public String getAbsolutePath() 返回此抽象路径名的绝对路径名字符串
File absoluteFile = file.getAbsoluteFile();
System._out.println(_absoluteFile); // D:\Test\java.txt
// public String getPath() 将此抽象路径名转换为路径名字符串
String path = file.getPath();
System._out.println(_path);// D:\Test\java.txt
// public String getName() 返回由此抽象路径名表示的文件或目录的名称
String name = file.getName();
System._out.println(_name); // java.txt
// public String[] list() 返回此抽象路径名表示的目录中的文件和目录的名称字符串数组
File file1 = new File(“D:\Test”);
String[] list = file1.list();
for (String s: list){
System._out.println(_s);
} // girl java java.txt Java01 Java02
// public File[] listFiles() 返回此抽象路径名表示的目录中的文件和目录的File对象数组
File[] files = file1.listFiles();
for (File f: files){
if (f.exists()){ System._out.println(_f.getName()); } // girl java java.txt Java01 Java02
// System.out.println(f); D:\Test\girl D:\Test\java D:\Test\java.txt D:\Test\Java01 D:\Test\Java02 } _

File类删除功能方法:

public boolean delete() 删除由此抽象类路径名表示的文件或目录
绝对路径和相对路径的区别：
绝对路径：完整的路径名，不需要任何其他信息就可以定位它所表示的文件。例如：D:\Test\java.txt
相对路径：必须使用取自其他路径名的信息进行解释。例如：Test\java.txt
删除目录时的注意事项:
如果有一个目录有内容(目录,文件)就不能直接删除, 需要先删除目录中的内容, 最后才能删除目录
// 先创建一个File的抽象路径对象,不添加路径,则默认在当前模块目录下创建文件
File file = new File(“java.txt”);
boolean newFile = file.createNewFile();
System.out.println(_newFile); // false
// 匿名对象删除当前模块下的文件
boolean delete = new File(“java.txt”).delete();
System._out.println(_delete); // true
// 当前模块目录下创建目录
File file1 = new File(“Test”);
boolean mkdir = file1.mkdir();
System._out.println(_mkdir); // true
// 删除当前模块目录下创建目录
boolean delete1 = new File(“Test”).delete();
System._out.println(_delete1); // true
// 在当前模块目录下创建目录,然后创建一个文件
// 创建目录
File file2 = new File(“Test”);
boolean mkdir1 = file2.mkdir();
System._out.println(_mkdir1);
// 创建一个文件,如果创建文件没有指定目录,则会报错
File file3 = new File(“Test\java.txt”);
boolean newFile1 = file3.createNewFile();
System._out.println(_newFile1);
// 删除当前模块目录下创建目录,然后创建一个文件
// 不能直接删除目录,需要先删除目录下的文件
System._out.println(_file3.delete()); // true
System._out.println(_file2.delete())_;// true

匿名对象和匿名类:

创建对象的语法：
①类名称 ②对象名称 = ③new ④类名称()

     1. ①：规定了对象的类型
     1. ②：对象的名字，唯一标识对象
     1. ③：开辟新的堆内存空间,存储对象的内容
     1. ④：调用构造方法初始化对象

上面的这条语句在内存中开辟了两个空间，一个栈空间存储引用变量对象名称，一个使用new开辟的堆空间用于存储对象内容。
Java 学习笔记XXVIII -- IO流- File - 图1

什么是匿名对象？

若是我们只有”new 类名称();”这部分的话，那就是只是在堆中开辟了一个空间来保存对象信息，没有栈去指向它。也就是这个空间是没有名字的— 就是没有名字的对象。所以简单来说，没有栈中引用指向的对象就叫做匿名对象。

匿名对象的使用

new Student(123456,”Sakura”,20).getName();
由此就创建了一个匿名对象，可以向操作具名对象一样操作它。
由于没有引用变量指向匿名对象，所以只能使用一次，然后就会成为垃圾对象等待被回收

递归:

递归概述:

以编程的角度来看, 递归指的是方法定义中调用方法本身的现象(自己调用自己)
原来不死神兔代码：
逻辑理解: 定义一二月为1 ,从第三月开始n = n-1 + n-2
// 不死神兔，求第20个月兔子的对数
// 每个月的兔子对数: 1,1,2,3,5,8…
int[] _arr = new int[20];
// 前两个月没有规律直接定义为1
arr[0] = 1;
arr[1] = 1;
// 数组集合是length, 集合是size
// 从第三个月开始规律为，第三个数字是前两个数字之和
for (int i = 2; i < arr.length; i++) {
arr[i] = arr[i - 1] + arr[i - 2]; }
System._out.println(_arr[19])_;

使用递归：

递归解决问题，首先就是要定义一个方法:

     1. 定义一个方法f(n) :表示第ｎ个月的兔子对数
     1. 返回该方法需要有出口, 否则会报栈溢出错误

那么第n-1个月对数的兔子该如何表示呢?f(n-1)
同理,第n -2个月的兔子对数该如何表示呢?f(n-2)
public static void main(_String[] args) {
// 编译器报错:StackOverflowError 堆栈溢出,递归太深
System._out.println(f(_20)); }
/定义一个方法f(n) :表示第ｎ个月的兔子对数
那么第n-1个月对数的兔子该如何表示呢?f(n-1)
同理,第n -2个月的兔子对数该如何表示呢?f(n-2)/
public static int f(int n) {
// 使用void为返回值类型报错,不能使用+ - = 等符号
// 应该使用int返回类型,定义一个方法为f() 参数为 n
// 返回这个方法就是递归,但是递归解决问题需要有设置出口
// 对n进行判断,如果值n为1或者n为2返回1 因为n是月份前两个月都是1
if (n == 1 || n==2) {
return 1; }else {
return _f(_n - 1) + _f(_n - 2); } }_

递归解决问题的思路:

     1. 把一个复杂的问题蹭蹭转换为一个与原问题相似的规模较小的问题来求解
     1. 递归策略只需少量的程序就可以描述出解题过程所需要的多次重复计算

递归解决方法注意两个内容:

     1. 递归出口: 否则会出现内存溢出
     1. 递归规则: 与原问题相似的规模较小的问题

案例: 递归求阶乘

需求: 用递归求5的阶乘, 并输出结果
阶乘: 一个正整数的阶乘是所有小于以及等于该数的正整数的积,自然数n的阶乘写作n!
例如: 5! = 54321

递归求阶乘分析:

     1. 递归出口: 1!=1 到1自然结束方法
     1. 递归规则 n! = n*(n-1)!   解释n!的阶乘等 n!* n-1!的阶乘 
     1. 5! = 5!*4!

思路：

     1. 定义一个阶乘方法，用于递归求阶乘，参数为一个int类型的变量、
     1. 在方法内部判断变量的值是否为1
        1. 是：返回1
        1. 不是：返回n*（n-1）！
     3. 调用阶乘方法
     3. 输出结果

代码实现：
public static void main(_String[] args) { System._out.println(jc(_5));}
// 同一包下方法调用静态调用静态用static修饰
// 定义一个阶乘方法并调用
public static int jc(int n) {
// 0的阶乘为1所以对0也做判断
if (n == 1 || n == 0) {
return 1;
} else {
// 返回n(n-1) jc表示n的阶乘 n n（n-1）
return n * _jc(_n - 1); } }_

案例: 遍历目录

需求:给定一个路径(D:\Test),通过递归方法完成遍历该目录下的所有内容, 并把所有文件的绝对路径输出在控制台
思路:

     1. 根据给定的路径创建一个File对象
     1. 定义一个方法,用于获取给定目录下的所有内容,参数为第一步创建的File对象
     1. 获取给定的File目录下所有的文件或者目录的File数组
     1. 遍历该File数组,得到每一个File对象
     1. 判断该File对象是否是目录
        1. 是: 调用递归
        1. 不是:获取该目录的绝对路径输出在控制台(该判断为递归出口)
     6. 调用递归方法

public static void main(_String[] args) {
// 根据给定的路径创建一个File对象
File file = new File(“D:\PgProject\test11”);
_getFile(_file); }
// 定义一个方法,用于获取给定目录下的所有内容,参数为第一步创建的File对象
public static void getFile(File file){
// 通过File类的listFiles()方法获取给定的File目录下所有的文件或者目录的File数组
File[] filesArray = file.listFiles();
// 提高程序的健壮性,先做一个对目录的判断再遍历该File数组,得到每一个File对象
if (filesArray != null){
for (File f: filesArray){
// 使用isDirectory()方法判断该File对象是否是目录
if (f.isDirectory()){
// 是: 调用递归方法参数是遍历的每一个路径
_getFile(_f);
}else {
// 该判断为递归出口__ // 不是:使用getAbsoluteFile()方法获取该目录的绝对路径输出在控制台
System.out.println(_f.getAbsoluteFile()); } } } }_