Java：文件类File的详解

File类的常用方法：

1、创建

boolean createNewFile():在指定位置创建文件，如果该文件已经存在，则不创建，返回false.和输出流不一样，输出流对象一建立创建文件，而且文件已经存在会覆盖。

boolean mkdir()：创建一级目录

boolean mkdirs():创建多级目录

2、删除

boolean delete():删除失败，返回false

void deleteOnExit():在程序退出时删除指定文件

3、判断

boolean canExecute()：文件是否可执行

boolean exists():文件是否存在

boolean isDirectory():是否是目录

boolean isFile():是否是文件

boolean isHidden():文件是否隐藏

boolean isAbsolute():是否为绝对路径

4、获取信息

String getName():获取名称

String getParent():获取父目录

String getPath():获取路径

String getAbsolutePath():获取绝对路径

long lastModified():最后一次修改的时间

long length():文件的大小

5、修改

boolean renameTo(File dest):修改文件名

//例子1：

import java.io.*;
class FileDemo
{
    public static<T> void sop(T t)
    {
        System.out.println(t);
    }
    public static void main(String[] args)throws IOException
    {
        //Consmethod();
        //method_1();
        //method_2();
        //method_3();
        method_4();
    }
    
    public static void method_1()throws IOException
    {
        //创建文件
        File f = new File("F:\\myfile\\file.txt");
        //f.deleteOnExit();
        //sop("create:"+f.createNewFile());
        sop("delete:"+f.delete());
        
        //创建文件夹
        File dir = new File("F:\\File\\dir");
        sop("create:"+dir.mkdir());
        // File dir = new File("F:\\File\\dir\\aaa\\bb\\cc");
        // sop("create:"+dir.mkdirs());        
    }
    public static void method_2()throws IOException
    {
        File f = new File("E:\\java0217\\Java IO\\File\\FileDemo.java");
        sop("canExecute():"+f.canExecute());
        sop("exists()):"+f.exists());
        //在判断文件目录是否是目录或文件时，必须先判断该文件对象封装的内容是否存在，通过上面的exists()判断。
        sop("isdir:"+f.isDirectory());
        sop("isfile:"+f.isFile());
        sop("isHidden:"+f.isHidden());
        sop("isAbsolute:"+f.isAbsolute());
    }
    public static void method_3()throws IOException
    {
        File f = new File("F:\\myfile\\file.txt");
        sop("getName:"+f.getName());
        sop("getParent:"+f.getParent());
        sop("getPath:"+f.getPath());
        sop("getAbsolutePath:"+f.getAbsolutePath());
        sop("lastModified:"+f.lastModified());
        sop("length:"+f.length());
    }
    public static void method_4()throws IOException
    {
       File f1 = new File("F:\\myfile\\file.txt");
       File f2 = new File("F:\\myfile\\fileDemo.txt");
       sop("renameTo:"+f1.renameTo(f2));
    }    
    
    //创建文件对象
    public static void Consmethod()
    {
        //将file.txt封装成File对象，可以将已有的和未出现的文件或者文件夹封装成对象。
        
        //构造方法一File(String pathname) 
        File f1 = new File("F:\\myfile2\\file1.txt");
        
        //构造方法二File(String parent, String child) 
        File f2 = new File("F:\\myfile2","file2.txt");
        
        //构造方法三File(File parent, String child) 
        File d = new File("F:\\myfile2");
        File f3 = new File(d,"file3.txt");
        
        //static String separator  
        String s = File.separator;//默认当前系统下的分隔符。具有跨平台性
        File f4 = new File("F:"+s+"myfile2"+s+"file4.txt");



        sop("f1:"+f1);//f1:F:\myfile2\file1.txt
        sop("f2:"+f2);//f2:F:\myfile2\file2.txt
        sop("f3:"+f3);//f3:F:\myfile2\file3.txt
        sop("f4:"+f4);//f4:F:\myfile2\file4.txt
    }
}

获取文件目录数组：

String[] list()

返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中的文件和目录。

String[] list(FilenameFilter filter)

返回一个字符串数组，这些字符串指定此抽象路径名表示的目录中满足指定过滤器的文件和目录。

File[] listFiles()

返回一个抽象路径名数组，这些路径名表示此抽象路径名表示的目录中的文件。

File[] listFiles(FileFilter filter)

返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

File[] listFiles(FilenameFilter filter)

返回抽象路径名数组，这些路径名表示此抽象路径名表示的目录中满足指定过滤器的文件和目录。

static File[] listRoots()

列出可用的文件系统根。

//例子2：

import java.io.*;
class FileDemo2
{
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
    public static void main(String[] args)
    {
        //listRoots();
        //list();
        listFiles();        
    }
    public static void listRoots()
    {
        File[] files = File.listRoots();
        for(File file: files)
        {
            sop(file);
        }
    }

    public static void list()
    {
        File f = new File("F:\\");
        String[] str = f.list();//调用list方法的file对象必须是一个封装的目录,而且还必须存在,否则返回空指针异常
        for(String s: str)
        {
            sop(s);
        }
    }
        
}

递归文件目录：

列出指定目录下的文件或文件夹，包含子目录中的内容，也就是列出指定目录下的所有内容。

因为目录中还有目录，只要使用使用同一个列出目录的功能函数即可。

在此过程中出现的还是目录的话，还可以再次调用本功能。

也就是函数自身调用自身。

这种变现形式或者编程手法，称为递归。

递归要注意的：

1.必须有条件限制

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

//例子2：

import java.io.*;
class FileDemo3
{
    public static void main(String[] args)
    {
      showdir(new File("E:\\java0217"));
      // ToBin(6);    
      // getsum(10);
      // int x = getsum(10);
      // System.out.println(x);      
    }
    public static void showdir(File dir)
    {
        System.out.println(dir);
        File[] files = dir.listFiles();
        for(int i=0; i<files.length; i++)
        {
          if(files[i].isDirectory()==true)
              showdir(files[i]);//递归调用showdir()
          else
              System.out.println(files[i]);
        }
    }
    
    
    
    
    
    public static void ToBin(int num)
    {
        if(num>0)
        {
            ToBin(num/2);//递归调用ToBin()
            System.out.println(num%2);
        }
    }
    public static int getsum(int x)
    {
        if(x==1)
            return 1;
        else
            return x+getsum(x-1);//递归调用getsum()    
    }
}

针对文件的应用举例如下：

练习一：将一个指定目录下的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("E:\\java0217"); 
        ArrayList<File> al = new ArrayList<File>();
        filetolist(dir,al); 
        System.out.println(al.size());
    }
    public static void filetolist(File dir,List<File> list)throws IOException
    {
        //System.out.println(dir);
        File[] files = dir.listFiles();
        for(int i=0; i<files.length; i++)
        {
          if(files[i].isDirectory())
              filetolist(files[i],list);
          else
          {
              files[i].getName().endsWith(".java");
              list.add(files[i]);
          }
        }
        BufferedWriter buf = new BufferedWriter(new FileWriter("F:\\myfile\\listjava.txt"));
        for(File f: list)
        {
            String str = f.getAbsolutePath();
            buf.write(str);
            buf.newLine();
            buf.flush();
        }
        buf.close();
    }
}

练习二：删除一个带内容的目录

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

import java.io.*;
class RemoveDir
{
    public static void main(String[] args)
    {
        Removedir(new File("F:\\aaa"));
    }
    public static void Removedir(File dir)
    {
        File[] files  = dir.listFiles();
        for(int i=0; i<files.length; i++)
        {
          if(files[i].isDirectory()==true)
              Removedir(files[i]);//递归调用Removedir()
          else
              System.out.println(files[i].toString()+"-file-"+files[i].delete());
        }
        System.out.println(dir+"::dir::"+dir.delete());
    }
}
/*
F:\aaa\bbb\bb::dir::true
F:\aaa\bbb\ccc\a.txt.txt-file-true
F:\aaa\bbb\ccc::dir::true
F:\aaa\bbb::dir::true
F:\aaa::dir::true
*/

练习三：先切割文件(流),在合并文件(流)

import java.io.*;
import java.util.*;
class SplitFileDemo
{
    public static void main(String[] args)throws IOException
    {
        SplitFile();        
        SequenceFile();
    }
    public static void SplitFile()throws IOException
    {
        FileInputStream fis = new FileInputStream("F:\\myfile\\b03.mp3");
        
        byte[] buf = new byte[1024*1024];
        
        int len = 0;
        int count=1;
        FileOutputStream fos = null;
        while((len=fis.read(buf))!=-1)
        {
            fos = new FileOutputStream("F:\\myfile\\splitfiles\\part"+(count++)+".suipian");//以1M为单位进行切割
                        
            fos.write(buf,0,len);
            
            fos.close();
        }
        fis.close();

    }
    public static void SequenceFile()throws IOException
    {
        Vector<FileInputStream> v = new Vector<FileInputStream>();
        for(int i=1;i<=3;i++)
        {
            v.add(new FileInputStream("F:\\myfile\\splitfiles\\part"+i+".suipian"));
        }

        Enumeration<FileInputStream> enu = v.elements(); 
        SequenceInputStream sis = new SequenceInputStream(enu);//将多个流整合为一个流对象    
       
        FileOutputStream fos = new FileOutputStream("F:\\myfile\\splitfiles\\part123.mp3");
        byte[] buf = new byte[1024];
        int num = 0;
        while((num = sis.read(buf))!=-1)
        {
            fos.write(buf,0,num);
        }
        fos.close();        
        sis.close();
    }
}

练习四：用于记录应用程序运行次数，如果使用次数已到，那么给出注册提示。

很容易想到是：计数器。

可是该计数器定义在程序中，随着程序的运行而在内存中存在，并进行自增。

可是，随着该应用程序的退出，该计数器也在内存中消失。

下次启动程序，计数器重新从0计数，这不是我们想要的。

想要的是，即使程序结束，该计数器仍存在。

下次程序启动会先加载计数器的值并加1后重新存储起来。

所以，要建立一个配置文件，用于记录该软件的使用次数。

该配置文件使用键值对的形式，这样便于阅读和操作数据。

键值对数据是Map集合，数据是以文件形式存储，使用IO技术，那么Map+io----------->Properties

配置文件可以实现应用程序的共享。

import java.io.*;
import java.util.*;
class RunCount
{
    public static void main(String[] args)throws IOException
    {
        Properties prop = new Properties();
        File f = new File("F:\\myfile\\count.ini");//"count.properties"
        if(!f.exists())
            f.createNewFile();
        
        FileInputStream fis = new FileInputStream(f);
        
        prop.load(fis);
        
        int count=0;
        String value = prop.getProperty("time");
        if(value!=null)
        {
            count = Integer.parseInt(value);
            if(count>=5)
            {
                System.out.println("你好，使用次数已到,再用需要收费!");
                return ;
            }
        }   
        count++;
        prop.setProperty("time",count+"");
        
        FileOutputStream fos = new FileOutputStream(f);
        
        prop.store(fos,"");
        
        fis.close();
        fos.close();
    }
}

本文转自当天真遇到现实博客园博客，原文链接：http://www.cnblogs.com/XYQ-208910/p/4918754.html，如需转载请自行联系原作者

相关文章：