Java IO File类

2019-10-18 08:38:56来源:博客园 阅读 ()

新老客户大回馈,云服务器低至5折

Java IO File类

File类

构造方法

??作为IO操作中的最基本的类,File类可以封装文件夹和文件,其构造方法如下:

1、通过给定的父抽象路径名和子路径名字符串创建一个新的File实例。

File(File parent, String child);

2、通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。

File(String pathname) 

3、根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。

File(String parent, String child) 

4、通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。

File(URI uri) 

下面是对构造方法的演示:

public static void main(String[] args)
    {
        /**
            File类的构造函数
            如何创建文件对象
        **/
        String pathname = "D:\\forio";
        String pathname2 = "D:\\forio\\3.txt";  //封装的是3.txt这个文件
        File f1 = new File(pathname);   //将forio文件夹封装成对象,注意也可以封装不存在的文件或者文件夹,变成对象,可以再创建嘛
        System.out.println(f1);


        File f2 = new File("D:\\forio","3.txt");//分开之后可以将后面的变成一个变量
        System.out.println(f2);

        File dir = new File("D:\\forio");
        File f3 = new File(dir,"3.txt");
        System.out.println(f3);

        //也可以像下面这样,File.separator表示系统分隔符,可以适应所有系统,不止Windows
        File f4 = new File("D:"+File.separator+"forio"+File.separator+"3.txt");
        System.out.println(f4);
    }

操作文件的方法

成功创建对象后就可以调用类的方法来操作文件或文件夹,这些方法比较多,就不罗列了,可以去文档查,下面介绍几个比较常用的方法。
1、获取基本信息

public static void main(String[] args)
{
    /*
      File类的方法演示
      获取文件的信息,名称,大小,时间
    */
    File file = new File("D://forio//3.txt");

    String absPath = file.getAbsolutePath();    //绝对路径
    String pathString= file.getPath();   //File中封装的路径是什么获取的就是什么
    String filename = file.getName();
    long size = file.length();          //字节数
    long time = file.lastModified();    //毫秒值

    System.out.println("absPath="+absPath);
    System.out.println("Path="+pathString);
    System.out.println("filename="+filename);
    System.out.println("size="+size);
    System.out.println("time="+time);

    //毫秒值--Date--格式化--字符串文本
    String str_date = DateFormat.getDateTimeInstance(DateFormat.LONG,DateFormat.LONG).format(new Date(time));
    System.out.println(str_date);
}

2、创建、删除、存在
对文件夹和文件还有创建和删除操作,以及判断目录是否存在。

对文件夹的: File dir = new File("D:\\demo");??File dirs = new File("D:\\haha\\hehe\\xixi");

  • 创建单层文件夹:dir.mkdir();
  • 创建多层文件夹:dirs.mkdirs();
  • 删除文件夹:dir.delete();??dirs.delete();如果文件夹中有内容,需要先删除其中内容,再对文件夹进行删除
  • 判断是否存在: dir.exists();

对文件的:File file = new File("D:\\forio\\3.txt");

  • 创建文件:file.createNewFile();
  • 删除文件:file.delete();
  • 判断存在:file.exists();

?以上方法的返回值都是boolean类型,成功或存在返回True,否则返回False

  • 创建文件,如果文件不存在,创建,返回true
  • 如果存在,不创建,返回false
  • 如果路径错误,IOException
  • 删除时返回false的两种情况:1、不存在,2、正在使用

3、ListFile方法,列举目录下的全部内容

ListFile方法返回值是一个File对象的数组,存放着目录中所有文件以及文件夹对象

import java.io.File;

public class ListFiles {
    public static void main(String[] args)
    {
        //需求:对给定的目录获取内部的内容
        File dir = new File("D:\\forio");
        //判断:1、必须是存在的   2、必须是目录,否则容易引发空指针异常NullPointerException

        String[] names = dir.list();    //获取的是目录下的当前的文件以及文件夹名称
        for (String name : names) {
            //  System.out.println(name);
        }


        File[]files = dir.listFiles();  //获取目录下的当前文件以及文件夹对象
        for (File file : files) {
            System.out.println(file.getName());
        }
    }
}

4、过滤器

过滤文件名的过滤器,实现FilenameFilter接口,并重写accept方法,如果文件名按照预先设定的规则,就返回True,否则返回False

public class FilenameFilterByTxt implements FilenameFilter {
    private String suffix;

    //构造函数
    public FilenameFilterByTxt(String s){
        suffix = s;
    }

    //重写accept函数
    @Override
    public boolean accept(File file, String name) {
        return name.endsWith(suffix);   //也可以直接endwith(".txt"); 但这样可以减少耦合性,更灵活的选择以哪种结束
    }
}
public class FileDemo {
    public static void main(String[] args)
    {
        //需求:获取目录中的文件,只要.txt文件

        File dir = new File("D:\\forio");

        File[] files = dir.listFiles(new FilenameFilterByTxt(".txt"));      //传入过滤器,如果懵逼了可以查看listFiles的API

        /*  listFiles方法的源码:
         *
         * public File[] listFiles(FilenameFilter filter)
         * {
                String ss[] = list();       //调用File类中的list方法,先获取所有的名称
                if (ss == null) return null;    //判断,如果数组为空,返回
                ArrayList<File> files = new ArrayList<>();  //创建了一个集合,元素是File类型
                for (String s : ss)             //遍历数组名称

                //调用accept方法,对遍历的名称进行过滤器判断,将当前目录this,遍历到名称s传递给accept方法,如果过滤器为空,即没有过滤条件。则全部为真
                    if ((filter == null) || filter.accept(this, s))
                        files.add(new File(s, this));   //将满足过滤条件的添加到集合中,将名称和当前目录封装成File对象。new File(dir,name);
                return files.toArray(new File[files.size()]);   //将集合转成数组返回,因为不需要增删操作
            }
         * */


        for (File file : files) {
            System.out.println(file);
        }
    }
}

过滤文件夹的过滤器,和上面迭代器的不同,少了一个私有成员,accept函数也少了一个参数,实际上是对accept函数的重载

public class FileFilterByDir implements FileFilter {

    @Override
    public boolean accept(File pathname) {
        // TODO Auto-generated method stub
        return pathname.isDirectory();
    }
}
import java.io.File;
import java.io.FileFilter;

public class Demo 
{
    public static void main(String[] args) 
    {
        File dir = new File("D:\\forio");
        /*
    public File[] listFiles(FileFilter filter) {
        String[] ss = this.list();
        if (ss == null) {
            return null;
        } else {
            ArrayList<File> files = new ArrayList();
            String[] var4 = ss;
            int var5 = ss.length;

            for(int var6 = 0; var6 < var5; ++var6) {
                String s = var4[var6];
                File f = new File(s, this);
                if (filter == null || filter.accept(f)) {
                    files.add(f);
                }
            }
        */
        File[] files = dir.listFiles(new FileFilterByDir());//传入过滤器,如果懵逼了可以查看listFiles的API
        for (File file : files) {
            System.out.println(file);
        }
    }
}

练习

1、获取目录中的所有内容,因为一个文件夹内可能包含文件也可能还包含文件夹,所以需要使用递归,用一个全局变量统计数目。

public class exercise1 {

    static int acount=0;    //统计数目
    public static void main(String[] args)
    {
        /***
         * File类的listFiles()列出当前目录下的文件以及文件夹内容
         *
         * 需求:能不能列出当前目录下的子目录中的所有内容
         * 思路:
         *  1、在遍历当前目录时,会获取到当前的所有文件及文件夹
         *  2、要遍历子目录需要对获取的当前的file对象进行判断,只有是目录时才可以作为子目录进行继续遍历
         */

        File dirFile = new File("D:\\VS 2019");
        ListAll(dirFile);
        System.out.println("一共有"+acount+"个文件和文件夹");
    }

    public static void ListAll(File dir)    //dir用来接收待遍历的目录
    {
        File[] files = dir.listFiles();

        for (File file2 : files) {
            if(file2.isDirectory())     //如果遍历到当前的file对象是个目录,继续遍历,递归调用
            {
                ListAll(file2);
            }
            acount++;
            System.out.println(file2.getName());
        }
    }
}

2、不使用递归获取一个目录下的所有子目录,既然不使用递归,那就需要考虑广度优先搜索,将目录加入一个队列,然后将文件直接输出文件名,然后出队第一个子目录,继续对其进行遍历,重复上述操作,即可获取全部内容。

public class exercise2 {

    static int acount=0;
    public static void main(String[] args)
    {
        /*
         * 遍历文件夹,且不使用递归:
         * 思路:
         *  1、遍历test目录,将子目录存储到容器内
         *  2、遍历容器。从容器中取出子目录,进行遍历
         *  3、子目录中还有目录,继续存储,让遍历过的容器中的目录出队,释放容器空间
         *  4、容器大小不确定,所以用集合
         *  5、目录名有可能重复,所以用队列
         */


        File dir = new File("D:\\C++");

        Queue<File> queue = new Queue<File>();
        //1、对dir进行当前目录的遍历
        File[]files = dir.listFiles();
        for (File file : files)
        {
            //2、如果有子目录,存储到队列中
            if(file.isDirectory())
            {
                acount++;
                queue.myAdd(file);
            }
            else
            {
                acount++;
                System.out.println(file.getName());
            }
        }
        //3、遍历队列容器。因为子目录都在队列中
        while(!queue.IsEmpty())
        {
            File[] files2 = queue.myRemove().listFiles();
            for (File file : files2) {
                if(file.isDirectory())
                {
                    acount++;
                    queue.myAdd(file);
                }
                else {
                    System.out.println(file.getName());
                    acount++;
                }
            }
        }
        System.out.println("一共有"+acount+"个文件");
    }
}

class Queue<E>
{
    private LinkedList<E> link;
    public Queue()
    {
        link = new LinkedList<E>();
    }
    public void myAdd(E obj)
    {
        link.addFirst(obj);
    }
    public E myRemove()
    {
        return  link.removeLast();
    }
    public boolean IsEmpty()
    {
        return link.isEmpty();
    }
}

原文链接:https://www.cnblogs.com/vfdxvffd/p/11694086.html
如有疑问请与原作者联系

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:六、显式锁和AQS

下一篇:运算符的基本概念以及常用Scanner、随机数Random、选择结构的初