黑马程序员-File类文件操作，知识梳理与简单应用

------------------------------------- Android培训                       java培训  期待与您的交流！------------------------------------------

/*
    文件类的初始化，此时并不是真实存在于物理地址-----抽象的

1.创建
    boolean creatrNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false。
                            和输出流不一样，输出流对象已建立创建文件。如果文件已经存在，会覆盖。
    
    boolean mkdir()：创建文件夹，最多创建一个子目录
    boolean mkdir():可以创建多级一个文件夹
2.删除
    boolean delete():删除失败返回false;如果因异常而结束的程序可能会报错
    void deleteOnExit();在程序退出时删除指定文件。（包括异常退出程序）

3.判断
    boolean exists():文件是否存在，首要判断
    boolean isFile():是否文件                
    boolean isDirectory()：是否是目录。
    boolean isHidden();是否是隐藏文件
    boolean isAbsolute():是否是绝对路径

4.获取信息
    getName();
    getPath();    封装什么就获取什么路径
    getParent();该方法返回的是绝对路径中的文件父目录。如果获取的是相对
                路径的话，返回null;
                如果相对路径中有上一层目录，该目录就是其返回结果。

    getAbsolutePath() 获取绝对路径
    long lastNodified()    返回最后一次修改文件的时间
    long length()    返回long的文件大小

*/

import java.io.*;
class FileDemo20_1 
{
    public static void main(String[] args) throws IOException
    {
        
        method_1();
    }
    public static void Method_1() throws IOException
    {
        File file =new File("dwa.txt");
        sop("创建"+file.createNewFile());
        sop("删除"+file.delete());
    }
    //File封装的物理上事实上并不存在的
    public static void consMethod()
    {
        File f1=new File("dwa.txt");            //将文件作为参数封装成对象

        File f2=new File("f:\\se","dwa.txt");    //当目录和文件分别对应两个参数封装成参数
        
        File dir=new File("f:\\se");            //将目录封装为File对象

        File f3=new File(dir,"dwa.txt");        //将File对象作为参数


        sop("f1="+f1);
        sop("f2="+f2);
        sop("f3="+f3);
    }
    public static void sop(Object o)
    {
        System.out.println(o);
    }
}

/*
    list() //调用list方法的file对象必须是封装了一个目录。该目录还必须存在。
            返回当前目录的所有文件夹，所有文件（包括隐藏文件）

    listRoots() //返回系统所有的磁盘。

    需求：
        根据list()的重载方法返回当前目录下的所有后缀为.java的文件
        
*/
import java.io.*;
class FileDemo20_5 
{
    public static void main(String[] args) 
    {
        listDemo();
    }
    //返回你所需要的文件类型
    public static void listDemo()
    {
        File dir=new File("f:\\");

        String [] names=dir.list(new FilenameFilter()
        {
            public boolean accept(File dir,String name)    //内部接口类
            {
                return name.endsWith(".java");            //在指定搜索后缀名为java的文件
            }
        });
        System.out.println(names.length);
        for (String name:names)
        {
            System.out.println("name="+name);
        }
    }
}

/*
    利用递归遍历
        列出指定目录下文件或者文件夹，包含子目录中的内容，最后全部都是文件为止
        
        并将其改进成类似文件系统的搜索功能的类
    
    递归的注意事项：
        1.限定递归的结束条件

        2.要主要递归的次数，尽量避免内存溢出

    思路：
        1.利用转换流从键盘输出要搜索的文件名，
        2.利用递归判断
            2.1如果还是文件夹，就继续递归。
            2.2如果是文件，就返回上一级目录，与该文件同一目录下的过滤。
            2.3如果启动了判断程序，则结果当前的一次循环，因为当前目录已经被遍历了，避免其他文件返回上一级又遍历一次
*/

import java.io.*;
class FileDemo20_7 
{
    public static void main(String[] args) throws IOException
    {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        String fileName=br.readLine();                //输入你要查找的文件名字
        
        File dir=new File("F:\\");                    //搜索的盘
        dirList(dir,fileName);

    }
    public static void dirList(File dir,String s)
    {
        File [] llist=dir.listFiles();                //将dir目录下的所有文件放入数组llist中
        for (File i: llist)                            //
        {
                if (i.isDirectory())                //判断是否是目录
                {
                    dirList(i,s);                    //如果是则回归
                }else
                {
                    File [] suosou=i.getParentFile().listFiles(new FilenameFilter()    
                                                        {
                                                            public boolean accept(File dir,String name)    
                                                        {
                                                                return name.endsWith(s);    
                                                        }
                                                        });//内部接口类过滤方法
                    for (File j:suosou)
                        System.out.println(j);
                    break;                                   //因为当前目录已经被遍历了，避免其他文件返回上一级又遍历一次
                }
        }
    }
}

/*
    删除一个带内容的目录。

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

    java删除是不走回收站的！，删除需要谨慎
*/
import java.io.*;
class  RemoveDir
{
    public static void main(String[] args) 
    {
        File dir=new File("f:\\Testdir");
        removeDir(dir);    
    }
    public static void removeDir(File dir)
    {
        File[] files=dir.listFiles();
        for (File file:files )
        {
            if (!file.isHidden()&&file.isDirectory())                //不能删除具有隐藏文件的文件夹
            {
                removeDir(file);
            }else
            {
                System.out.println(file.toString()+"--"+file.delete());
            }
        }
        System.out.println(dir.toString()+"||"+dir.delete());        //当文件夹里面的所有文件都删除后，则可以删除这个文件夹

    }
}

/*
    练习
    将一个指定目录下相同文件的绝对路径，存储到一个文本文件中。
    建立一个java文件列表文件。

    思路：
        1.对指定的目录进行递归。
        2.获取递归过程所有后缀.java文件的对象。
        3.将这些文件对象存储到集合中。
        4.将集合中数据的绝对路径写到一个文件中
*/
import java.io.*;
import java.util.*;
class JavaFileList 
{
    public static void main(String[] args) 
    {
        File dir=new File("F:\\SE");
        List<File> list=new ArrayList();                    //创建ArrayList集合对象
        javaList(dir,list);
        File file=new File(dir,"java.txt");
        writeToTxt(list,file.toString());
    }

    public static void javaList(File dir,List<File> list)
    {
        File[] files=dir.listFiles();
        for (File file:files)    
        {                                                    //仍然有遍历目录的影子
            if(file.isDirectory()){
                javaList(file,list);
            }else{
                if(file.getName().endsWith(".java"))        //如果是java文件就添加到集合去
                    list.add(file);
            }
        }
    }
    public static void writeToTxt(List<File> list,String Filename)
    {
        BufferedWriter bfw=null;                            //通过字符流对集合进行操作并将结果写入文本中
        try
        {
            bfw=new BufferedWriter(new FileWriter(Filename));
            for (File file:list )
            {
                bfw.write(file.getAbsolutePath());            //获取绝对路径
                bfw.newLine();
                bfw.flush();
            }
        }
        catch (IOException e)
        {
            throw new RuntimeException("失败");                //出错则结束当前程序
        }finally{
            try
            {
                if(bfw!=null)
                    bfw.close();                            //写入成功后，要关闭流对象
            }
            catch (IOException e)
            {
                System.out.println(e);
            }
        }
    }
}