2021年2月24日 File类 IO流

输入输出操作的区别：
输出操作：从内存到硬盘（写入）
输入操作：从硬盘到内存（读取）

File类中，封装的是：文件和文件夹、路径,系统中除了文件和文件夹，没别的了。

流的分类：

	输入	输出
字节	InputStream	OutputStream
字符	Reader	Writer

 

路径分隔符:
System.out.println("与系统有关的路径分隔符："+File.pathSeparator);
System.out.println("与系统有关的默认名称分隔符："+File.separator);
//与系统有关的路径分隔符：;
//与系统有关的默认名称分隔符：\

分号指的是window系统的多个路径之间的分隔符（如果是linux是冒号：）
反斜杠指的是路径里面的分隔符，linux是/，windows是\

File类构造方法:
File类的构造方法不校验文件是否真实存在
File(String parent, String child) ，是为了灵活传输不同的子路径
File(File parent, String child) ,是为了能调父路径的方法
根据需要选择构造方法

目录：
Directory 文件夹的学名

相对路径：

..\为返回上一层
.\为本文件夹 默认为项目文件夹的路径

创建文件的步骤：
1：明确创建文件的位置
2：创建文件、处理异常
createNewFile不指定扩展名，创建的还是没有扩展名的文件，而不是文件夹

删除文件的步骤：
1：明确要删除的文件的位置
2：调用File类的delete方法
public static void method03() throws IOException{
File file = new File("d:\\io1127\\a");

file.delete();
}

如果文件或文件夹本身就不存在，那么isFile、isDirectory返回一定是false

还需要注意如果删除的是文件夹，文件夹必须是空的才能被删除

创建文件夹的步骤：
使用mkdir、mkdirs方法
mkdir指定扩展名，创建的还是是文件夹，如果创建多级文件夹，需用mkdirs

获取文件夹下的所有文件和文件夹：
list返回String数组
fileList返回File数组
注意只能获取一级，不包含子目录里的

文件过滤器：
FilenameFilter：按文件名过滤
FileFilter：按文件对象特点过滤

要注意考虑的：
window下文件名不区分大小写：
File[] files = file.listFiles((File typef) -> typef.getName().toLowerCase().endsWith(".txt") && typef.isFile());

递归:
方法自己调用自己
一定要设置出口
迭代次数不能太多
循环已知次数，递归不知道

文件过滤器的简化写法：

（找出该目录下的txt文件，不包含子目录）

原代码（实现FileFilter接口，创建实现类对象）：

class MyFilter implements FileFilter{
    public boolean accept(File pathname) {
        if(pathname.isFile()&&pathname.getName().toLowerCase().endsWith(".txt")) {
            return true;
        }else {
            return false;
        }
    }
}

public class Main {
    public static void main(String[] args) throws IOException{
        File f = new File("D:\\Recursion");
        for(File ff:f.listFiles(new MyFilter())) {
            System.out.println(ff);
        }
    }
}

简化（匿名内部类）

public class Main {
    public static void main(String[] args) throws IOException{
        File f = new File("D:\\Recursion");
        for(File ff:f.listFiles(new FileFilter() {
            public boolean accept(File pathname) {
                if(pathname.isFile()&&pathname.getName().toLowerCase().endsWith(".txt")) {
                    return true;
                }else {
                    return false;
                }
            }
            
        })) {
            System.out.println(ff);
        }
    }
}

继续简化（Lambada表达式）

public class Main {
    public static void main(String[] args) throws IOException{
        File f = new File("D:\\Recursion");
        for(File ff:f.listFiles((File pathname) -> {
                if(pathname.isFile()&&pathname.getName().toLowerCase().endsWith(".txt")) {
                    return true;
                }else {
                    return false;
                }
            }
        )) {
            System.out.println(ff);
        }
    }
}

测试缓冲数组大小对文件复制速度的影响：

(Video文件大为100M)

public static void main(String[] args) throws IOException{
        File f1 = new File("D:\\Recursion\\Video.wmv");
        File f2 = new File("D:\\Recursion\\Video2.wmv");
        
        FileInputStream fis = new FileInputStream(f1);
        FileOutputStream fos = new FileOutputStream(f2);
        
        byte[] buffer = new byte[64];
        int length = 0;
        
        System.out.println("开始复制");
        long st = System.currentTimeMillis();
        while((length = fis.read(buffer))!=-1) {
            fos.write(buffer,0,length);
        }
        long et = System.currentTimeMillis();
        System.out.println("复制完成，用时："+(et-st)/1000.0+"秒");
        fis.close();
        fos.close();
                
    }

buffer数组长度	复制用时(秒)
64	7.168
128	4.336
256	2.108

由此可见buffer数组长度越大，复制越快。

 

对比使用缓冲流和不使用缓冲流复制的速度：

FileInputStream fis = new FileInputStream("d:\\Recursion\\Video.wmv");
        FileOutputStream fos = new FileOutputStream("d:\\Recursion\\Video2.wmv");
        
        FileInputStream fis2 = new FileInputStream("d:\\Recursion\\Video.wmv");
        BufferedInputStream bis = new BufferedInputStream(fis2);
        
        FileOutputStream fos2 = new FileOutputStream("d:\\Recursion\\Video3.wmv");
        BufferedOutputStream bos = new BufferedOutputStream(fos2);
        
        long st1 = System.currentTimeMillis();
        byte[] buffer = new byte[256];
        int length = 0;
        while((length = fis.read(buffer))!=-1) {
            fos.write(buffer,0,length);
        }
        long et1 = System.currentTimeMillis();
        
        System.out.println("不用缓冲流复制时间："+(et1-st1)/1000.0+"秒");
        
        long st2 = System.currentTimeMillis();

        while((length = bis.read(buffer))!=-1) {
            bos.write(buffer,0,length);
        }
        long et2 = System.currentTimeMillis();
        bos.flush();
        System.out.println("使用缓冲流复制时间："+(et2-st2)/1000.0+"秒");