IO流__【File类常见操作】【文件列表】【递归】

File类

文件和目录路径名的抽象表示形式。

用来将文件或者文件夹封装成对象；方便对文件与文件夹的属性信息进行操作。
File对象可以作为参数传递给流的构造函数。
了解File类中的常用方法。

File类常用方法
1，创建 boolean createNewFile();
当且仅当不存在具有此抽象路径名指定名称的文件时，不可分地创建一个新的空文件。
在指定位置创建文件，如果文件已经存在，则不创建返回false 
与输出流不同：输出流对象创建文件时，如果文件已经存在，会覆盖原有文件
boolean mkdir();//创建文件夹
boolean mkdirs();//创建多级文件夹
2，删除 boolean delete();删除成功返回true ;失败返回false
void deleteOnExit();在程序退出时删除指定文件
3，判断 boolean canExecute(); 测试应用程序是否可以执行此文件。可以和Runtime类配合使用
exists();文件或目录是否存在。
在判断文件对象是否是文件或者目的时，必须要先判断该对象封装的内容是否存在
isFile();  判断是否是文件，
isDirectory();是否是目录
isHidden();  是否隐藏
isAbsolute();是否绝对路径
4，获取信息
getName();
getPath();获取相对路径字符串
getParent();返回绝对路径的父目录，相对路径没有父目录，则返回null，如果有上层目录，那么该目录就是返回结果
getAbsolutePath();//抽象路径名的绝对路径名字符串
lastModified();//返回文件最后一次被修改的时间
length();  文件大小
5,修改信息
renameTo(File f);修改文件名称及路径，成功则返回true

示例：

import java.io.*;
class FileDemo
{
    public static void main(String[] args)  throws IOException
    {
//      consMethod();
        method_5();
    }
    public static void method_5()
    {
        File f1 = new File("c:\\Demo.java");
        File f2 = new File("G:\\haha.java");
        sop("renameTo: "+f1.renameTo(f2));//改文件名及路径
    }
    public static void method_4()
    {
        File f = new File("G:\\a.txt");
        sop("path: "+ f.getPath());//获取相对路径
        sop("absolutePath: "+f.getAbsolutePath());//获取绝对路径
        sop("parent: "+f.getParent());//返回绝对路径的父目录，相对路径没有父目录，则返回null
    }                               //如果相对路径中有上层目录，那么该目录就是返回结果
    public static void method_3() throws IOException
    {
        File f = new File("file.txt");
        f.createNewFile();//创建文件
        f.mkdir();      //创建目录，名称为file.txt的文件夹
        sop("dir: "+ f.isDirectory());//在判断文件对象是否是文件或者目的时，必须要先判断该对象封装的内容是否存在
        sop("file: "+ f.isFile());      //通过exist()判断
    }
    public static void method_2()
    {
        File f = new File("file.txt");
//      sop("execute: "+f.canExecute());//判断是否能执行
//      sop("exists: "+f.exists());     //判断是否存在
        File dir = new File("abc\\fd\\df\\df");     //创建抽象路径对象
        sop("mkdirs: "+dir.mkdirs());               //根据该对象创建文件夹
    }
    public static void method_1() throws IOException
    {
        File f = new File("file.txt");
        f.deleteOnExit();   //在程序退出时删除指定文件
//      sop("creat: "+ f.createNewFile());//1，创建成功返回true,如果文件已存在返回false
        sop("delete:"+f.delete());      //2,删除，成功删除返回true,失败返回false
    }
    public static void consMethod() //构造方法演示
    {                   //file可以将已有的和未出现的文件或者文件夹封装成对象
        File f1 = new File("a.txt");//将a.txt封装成file对象，
        File f2 = new File("G:\\haha","b.txt");
        File d  = new File("c:\\haha");//将目录和文件拆分，可以更加自由的定义
        File f3 = new File(d,"c.txt");
        sop("f3: "+f3);
        File f4 = new File("c:"+File.separator+"haha"+File.separator+"abc"+"a.txt");
    }                   //使用跨平台的分隔符seprator，增强代码健壮性
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

文件列表

获取文件列表的方法：

listRoots()列出可用的文件系统根
list()  返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。
该file对象必须封装了一个目录，而且该目录必须存在，否则方法返回null
listFiles()返回File对象，该目录下的文件和文件名File对象，能够操作对象，所以更加常用
list(FilenameFilter filter);过滤流； FilenameFilter接口，仅有的accept()方法

import java.io.*;
class  FilesDemo2
{
    public static void main(String[] args)
    {
//      listRootsDemo();
//      listDemo_2();
        listFilesDemo();
    }
    public static void listFilesDemo()//
    {
        File dir = new File("G:\\");
        File[] files = dir.listFiles();//由File对象组成的数组
        for (File f:files )
        {
            sop(f.getName()+" : "+f.length());//打印该对象名称及字节数（大小）
        }
    }
    public static void listDemo_2()//过滤流
    {
        File dir = new File("f:\\JAVA\\test");
        String[] arr = dir.list(new FilenameFilter(){//匿名内部类实现FilenameFilter接口
            public boolean accept(File dir,String name)
            {
                return name.endsWith(".txt");
            }
        });
        sop("len: "+arr.length);
        for (String name: arr )
        {
            sop(name);
        }
    }
    public static void listDemo_1()
    {
        File dir = new File("f:\\JAVA\\test");//该对象必须是存在的目录
        String[] names = dir.list();
        for (String name :names )//遍历列出该目录下所有文件和目录
        {
            sop(name);
        }
    }
    public static void listRootsDemo()//根目录
    {
        File[] files = File.listRoots();//列出文件系统根目录（盘符）
        for (File f : files )//增强for循环，遍历
        {
            sop(f);
        }
    }
    public static void sop(Object obj)
    {
        System.out.println(obj);    }
}

递归

需求：
列出指定目录下文件或文件夹，及其子目录中内容

分析目录中还有目录。只需执行同一个列出目录功能的函数完成即可；在列出过程中判定出现的对象还是目录的话，就再次调用本功能

即函数自身调用自身，这种编程形式称为递归

递归示例：

public static int recursion_2(int n){//递归演示2求累加和
    if(n==1)
        return 1;
    else
        return n+recursion_2(n-1);
}
public static void recursion(int num){//递归演示求二进制
    if (num>0){
        recursion(num/2);
        sop(num%2);
    }
}

内存图解：传入一个值6来求其二进制表现

递归注意事项：
1，限定条件
2，要注意控制次数，避免内存溢出

递归获取目录下所有文件

import java.io.*;
class FileDemo3
{
    public static void main(String[] args)
    {
        File dir = new File("f:\\java\\test");
        showDir(dir);
    }
    public static void showDir(File dir)
    {
        sop(dir);
        File[] files = dir.listFiles();//返回dir对象下的File对象
        for(int x=0; x
        {
            if(files[x].isDirectory())
                showDir(files[x]);  //如果是目录，递归
            else
                sop(files[x]);      //如果是文件，打印名称
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

删除一个带内容的目录

原理：
在windows中删除目录是从里面往外删的，就需要用到递归

import java.io.*;
class RemoveDir
{
    public static void main(String[] args)
    {
        File dir = new File("G:\\delete");
        removeDir(dir);
    }
    public static void removeDir(File dir)
    {
        File[] files = dir.listFiles(); //获取该目录下所有文件对象
        for (File f:files )
        {
            if (!f.isHidden() && f.isDirectory())//非隐藏并且是目录
                removeDir(f);
            else
            sop(f.toString()+" file "+f.delete());//删除文件
        }
        sop(dir+"  dir  "+dir.delete());    //删除目录
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

需求：文件列表

建立一个java文件列表文件，将制定目录下java文件的绝对路径，存储到一个文本文件中
思路：
1，对指定目录进行递归
2，获取递归中java文件的路径
3，将这些路径存储到集合中
4，将集合中数据写入到列表文件中

操作：

import java.io.*;
import java.util.*; //集合
class JavaFileList
{
    public static void main(String[] args) throws IOException
    {
        File dir = new File("f:\\java\\test");
        List list = new ArrayList();
        fileToList(dir,list);
//      System.out.println(list.size());
        File file = new File(dir,"javalist.txt");
        writeToFile(list,file); //写入文本

    }
    public static void fileToList(File dir,List list)
    {
        File[] files = dir.listFiles();//获取File对象数组
        for (File f : files )
        {
            if(f.isDirectory())
                fileToList(f,list); //如果是目录，递归
            else if (f.getName().endsWith(".java"))
                list.add(f);        //将满足条件的File对象存入list集合
        }
    }
    public static void writeToFile(List list,File file)
    {
        BufferedWriter bufw = null;
        try{
                bufw = new BufferedWriter(new FileWriter(file));//FileWriter可以接收String，也可以接收File
                for (File f: list )
                {
                    String path = f.getAbsolutePath();//绝对路径
                    bufw.write(path);   //写入
                    bufw.newLine();
                    bufw.flush();
                }
        }
        catch (IOException e){
            throw new RuntimeException("");
        }
        finally{
            try{
                if(bufw!=null)
                    bufw.close();
            }
            catch (IOException e){
                throw new RuntimeException("");
            }
        }
    }
}