JAVA 22、23 测试方法(Junit的使用)，文件类，递归，IO流（字节流，字符流，缓冲流，对象流，随机访问文件流，打印流）

一、测试方法

1. Debug：断点测试
2. System.out.println()：打桩测试
3. Junit：单元测试

单元测试：需要导jar包，里面的方法可以取代主方法，用来测试程序。

二、文件类（File）

java.io.File 类是⽂件和⽬录路径名的抽象表示，主要⽤于⽂件和⽬录的创建、查找和删除等操作。

1.构造方法

public File(String pathname) ：通过将给定的路径名字符串转换为抽象路径名来创建新 的 File 实例。  

public File(String parent, String child) ：从⽗路径名字符串和⼦路径名字符串创建 新的 File 实例。 public File(File parent, String child) ：从⽗抽象路径名和⼦路径名字符串创建新的 File 实例。

2.常用API

public String getAbsolutePath() ：返回此File的绝对路径名字符串。

public String getPath() ：将此File转换为路径名字符串。

public String getName() ：返回由此File表示的⽂件或⽬录的名称。

public long length() ：返回由此File表示的⽂件的⻓度。

public boolean exists() ：此File表示的⽂件或⽬录是否实际存在。

public boolean isDirectory() ：此File表示的是否为⽬录。

public boolean isFile() ：此File表示的是否为⽂件。

删除功能

public boolean createNewFile() ：当且仅当具有该名称的⽂件尚不存在时，创建⼀个新 的空⽂件。

public boolean delete() ：删除由此File表示的⽂件或⽬录。

public boolean mkdir() ：创建由此File表示的⽬录。

public boolean mkdirs() ：创建由此File表示的⽬录，包括任何必需但不存在的⽗⽬录。

目录的遍历

public String[] list() ：返回⼀个String数组，表示该File⽬录中的所有⼦⽂件或⽬录。

public File[] listFiles() ：返回⼀个File数组，表示该File⽬录中的所有的⼦⽂件或⽬ 录。

tips：

绝对路径：从盘符开始的路径，这是⼀个完整的路径。

相对路径：相对于项⽬⽬录的路径，这是⼀个便捷的路径，开发中经常使⽤。

//方法测试01
import org.junit.Test;
import java.io.File;

public class Demo01 {

    @Test
    public void m1(){
/*
public File(String pathname) ：
通过将给定的路径名字符串转换为抽象路径名来创建新 的 File 实例。*/
        File f = new File("a.txt");

/*public String getAbsolutePath() ：返回此File的绝对路径名字符串。*/
        System.out.println(f.getAbsolutePath());//G:\JAVA733\idea node\JavaSe\a

    // File getAbsoluteFile()
        //          返回此抽象路径名的绝对路径名形式。
        System.out.println(f.getAbsoluteFile());//G:\JAVA733\idea node\JavaSe\a



    }

    @Test
    public void m2(){
/*File(String parent, String child)
          根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。*/
        File f1 = new File("b","b.txt");
        System.out.println(f1.getAbsoluteFile());//G:\JAVA733\idea node\JavaSe\b\b.txt

        File f2 = new File("a/b","c/a.txt"); //多层目录
        System.out.println(f2.getAbsoluteFile());//G:\JAVA733\idea node\JavaSe\a\b\c\a.txt
    }



    //主方法里
    public static void main(String[] args) {
        File f2 = new File("b","b.txt");
        System.out.println(f2.getAbsoluteFile());
        //G:\JAVA733\idea node\b\b.txt 这里的路径跟上面test测试的就不一样了

    }



}

//File类API测试
import org.junit.Test;
import java.io.File;
import java.io.IOException;

public class Demo02 {
    @Test
    public void test01(){
        File file = new File("a.txt");
        //查看a.txt文件的路径

        File ab = file.getAbsoluteFile();
        System.out.println(ab);
        /*
        *  boolean exists()
          测试此抽象路径名表示的文件或目录是否存在。 */
        boolean exists = file.exists();
        System.out.println(exists);
        /*
        * G:\JAVA733\idea node\JavaSe\a.txt
        * true
        * */
    }
    @Test
    public void test02(){
        File file = new File("a.txt");
        File file1 = new File("src");
        File file2 = new File("c.txt");
        /*
        *  boolean isDirectory()
          测试此抽象路径名表示的文件是否是一个目录。
          *  boolean isFile()
          测试此抽象路径名表示的文件是否是一个标准文件。
*/
        System.out.println(file.isFile());
        System.out.println(file.isDirectory());
        System.out.println(file1.isFile());
        System.out.println(file1.isDirectory());
        System.out.println(file2.isFile());
        System.out.println(file2.isDirectory());
        /*
true
false
false
true
false
false*/
    }
    @Test
    public void test03() throws IOException {
        File file = new File("c.txt");
        File ab = file.getAbsoluteFile();
        System.out.println(ab);
        /*
            如果模块下没有此文件,则会自动创建一个文件
            如果模块下有文件,则不再重复创建
             boolean createNewFile()
          当且仅当不存在具有此抽象路径名指定名称的文件时，
          不可分地创建一个新的空文件
         */
        boolean newFile = file.createNewFile();
        System.out.println(newFile);
    }

    @Test
    public void test04(){
        //创建文件夹
        File file = new File("dir");
        /*boolean mkdir()
          创建此抽象路径名指定的目录。 */
        boolean mkdir = file.mkdir();
        System.out.println(mkdir);
    }
    @Test
    public void test05(){
        /*
            mkdir,只能创建单层目录
         */
        File file = new File("dir/a");
        boolean mkdir = file.mkdir();
        System.out.println(mkdir);
    }

    @Test
    public void test06(){
        /*
            mkdirs:创建多层目录
             boolean mkdirs()
          创建此抽象路径名指定的目录，包括所有必需但不存在的父目录。
         */
        File file = new File("test/a");
        boolean mkdir = file.mkdirs();
        System.out.println(mkdir);
    }

    @Test
    public void test07(){
        // . 表示当前目录
        File file = new File(".");
        String[] list = file.list();
        for ( String s: list) {
            System.out.println(s);
            /*file.isFile();
            file.isDirectory();*/
        }
    }

    @Test
    public void test08(){
        File file = new File(".");
        File[] files = file.listFiles();
        for (File f:files) {
            System.out.println(f);
            f.isFile();
            f.isDirectory();
        }
    }


}

import org.junit.Test;

import java.io.File;

//关于file类的删除方法

/*
    删除文件/文件夹/非空文件夹
 */
public class Demo03 {
    @Test//删除文件
    public void test01(){
        File file = new File("c.txt");
        boolean delete = file.delete();
        System.out.println(delete);
    }
    @Test//删除文件夹(目录)
    public void test02(){
        File file = new File("dir/a");
        boolean delete = file.delete();
        System.out.println(delete);
    }

    @Test//删除非空文件夹(目录)
    public void test03(){
        File file = new File("test");
        //1.获取test文件夹下所有的文件或者目录
        File[] files = file.listFiles();
        //2.遍历File[],获取所有的文件或者目录
        for (File f: files) {
            //3.判断f是文件夹还是文件
            if(f.isDirectory()){
                //4.再判断文件夹中是否存在文件
            }else {
                //5.如果是文件就直接删除
                f.delete();
            }
        }
    }

}

调⽤listFiles⽅法的File对象，表示的必须是实际存在的⽬录，否则返回null，⽆法进⾏遍历。

三、递归

递归：指在当前⽅法内调⽤⾃⼰的这种现象。

递归的分类： 递归分为两种，直接递归和间接递归。

直接递归称为⽅法⾃身调⽤⾃⼰。 间接递归可以A⽅法调⽤B⽅法，B⽅法调⽤C⽅法，C⽅法调⽤A⽅法。

注意事项：

• 递归⼀定要有条件限定，保证递归能够停⽌下来，否则会发⽣栈内存溢出。
• 在递归中虽然有限定条件，但是递归次数不能太多。否则也会发⽣栈内存溢出。
• 构造⽅法,禁⽌递归

//递归方法
//搜索 D:\aaa 目录中的 .java 文件。
/*1. 目录搜索，无法判断多少级目录，所以使用递归，遍历所有目录。
2. 遍历目录时，获取的子文件，通过文件名称，判断是否符合条件。*/

import java.io.File;

public class Demo04 {
    public static void main(String[] args) {
       File f =  new File("D:\\aaa");
       m1(f);//调用m1方法
    }
    //判断方法
    public static void m1(File f){
        //获取子文件和目录
        File[] files = f.listFiles();

        //文件遍历
        for (File file:files) {
            //判断是文件还是目录
            if (file.isFile()){
                //是文件的话，就判断该文件结尾是不是以.java结尾的
                if (file.getName().endsWith(".java")){
                    //是就打印输出
                    System.out.println("文件名："+file.getAbsolutePath());
                }
            }else{
                //不是文件而是目录的话，继续遍历
                m1(file);//在自己的方法内调用自己这个方法 就形成递归
            }
        }
    }
}

四、IO流

根据数据的流向分为：输入流和输出流。

输入流 ：把数据从 其他设备 上读取到 内存 中的流。

输出流 ：把数据从 内存 中写出到 其他设备 上的流。

根据数据的类型分为：字节流和字符流。

字节流 ：以字节为单位，读写数据的流。

字符流 ：以字符为单位，读写数据的流。

根据层次分为：底层流和缓冲流（高级流）。

字节流字符流的父类：

1.字节流

⼀切⽂件数据（⽂本、图⽚、视频等）在存储时，都是以⼆进制数字的形式保存，都⼀个⼀个的 字节，那么传输时⼀样如此。所以，字节流可以传输任意⽂件数据。在操作流的时候，我们要时 刻明确，⽆论使⽤什么样的流对象，底层传输的始终为⼆进制数据。

1.字节输出流【OutputStream】底层流

java.io.OutputStream 抽象类是表示字节输出流的所有类的超类，将指定的字节信息写出到⽬的地。它定义了字节输出流的基本共性功能⽅法。

API

public void close() ：关闭此输出流并释放与此流相关联的任何系统资源。

public void flush() ：刷新此输出流并强制任何缓冲的输出字节被写出。

public void write(byte[] b) ：将 b.length 字节从指定的字节数组写⼊此输出流。

public void write(byte[] b, int off, int len) ：从指定的字节数组写⼊ len 字节，

从偏移量 off 开始输出到此输出流。

public abstract void write(int b) ：将指定的字节输出流。

close ⽅法，当完成流的操作时，必须调⽤此⽅法，释放系统资源。

子类： FileOutputStream 类 

java.io.FileOutputStream 类是⽂件输出流，⽤于将数据写出到⽂件。

构造方法：

public FileOutputStream(File file) ：创建⽂件输出流以写⼊由指定的 File 对象表示的⽂件。

public FileOutputStream(String name) ：创建⽂件输出流以指定的名称写⼊⽂件。

当你创建⼀个流对象时，必须传⼊⼀个⽂件路径。该路径下，如果没有这个⽂件，会创建该⽂

件。如果有这个⽂件，会清空这个⽂件的数据。

数据是否追加

上面的构造方法每次 每次程序运⾏，创建输出流对象，都会清空⽬标⽂件中的数据，那怎么保留文件中的数据呢，就可以使用下面的构造方法。

public FileOutputStream(File file, boolean append) ： 创建⽂件输出流以写⼊由指定的 File 对象表示的⽂件。