6.1（java学习笔记）File类

1.路径分隔符，文件分隔符。

路径分隔符（“；”）

文件名称分隔符（“\”windows，“/”Linux等）。

不同平台使用的文件分隔符是不一样的，所以File类中提供了分隔符常量，它会根据平台的不同自行选择对应的分隔符。

这样便于跨平台，假如我们写死的话，就具有一定的局限性。

路径分割符：File.PathSeparator

文件名称分割符：File.separator

import java.io.File;

public class Test {
    public static void main(String[] args) {
        System.out.println(File.pathSeparator);//路径分隔符
        System.out.println(File.separator);//文件名称分隔符
    }
}

运行结果：
;
\     //由于这是在windows平台上，所有打印出来的是“\”，如果是Linux上打印的就是“/”

import java.io.File;

public class Test {
    public static void main(String[] args) {
        System.out.println(File.pathSeparator);
        System.out.println(File.separator);
        String path1 = "E:\\test\\a.txt";//路径表示方法1，
        String path2 = "E:" + File.separator + "test" + File.separator +"a.txt";//路径表示方法2
        System.out.println(path1);
        System.out.println(path2);
    }
}

运行结果：
;
\
E:\test\a.txt
E:\test\a.txt

上列代码中的路径表示方法1，方法2都可以用于表示路径，但是建议使用第二种，无论是从动态的更改路径，还是从跨平台角度考虑，第二组都要好一些。

2.File构造方法

创建一个文件实例用于对该文件进行操作。构造参数是被操作文件的路路径。

简单的说就是和需要进行操作的文件之间建立一个联系，而这个联系的关键就是文件的路径。

File(String parent, String child)

File(File parent, String child)

File(String pathname)

String getPath()

将抽象路径名转换为路径字符串

String getAbsolutePath()

将抽象路径名转换为绝对路径字符串

import java.io.File;

public class Test {
    public static void main(String[] args) {
    //    System.out.println(File.pathSeparator); // ';'
    //    System.out.println(File.separator);     // '\'
        String parent = "E:" + File.separator;
        String childTestTxt = "test.txt";
        String childTestWord = "text.docx";
        File f1 = new File(parent,childTestTxt);//文件路径parent + chideTestTxt，绝对路径创建
        File f2 = new File(new File(parent),childTestWord);//文件路径parent+childTestDoc，绝对路径创建
        File f3 = new File(parent+"text.xls");//绝对路径创建
        System.out.println(f1.getPath());//获取路径地址
        System.out.println(f2.getPath());
        System.out.println(f3.getPath());
    }
}

运行结果：
E:\test.txt
E:\text.docx
E:\text.xls

就像上列代码中parent是E：\，后面添加的child都是相对于parent而言的，就是说child在parent后面。

建立路径简单的说就是parent+child。

我们来看下面这样一个例子

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String parent = "ft";
        String child ="t.txt";
        File f1 = new File(parent,child);
        File f2 = new File(new File(parent),child);
        File f3 = new File("ft\\t.txt");
        System.out.println(f1.getPath());
        System.out.println(f1.getAbsolutePath());
        System.out.println(f2.getPath());
        System.out.println(f2.getAbsolutePath());
        System.out.println(f3.getPath());
        System.out.println(f3.getAbsolutePath());
    }
}

运行结果：
ft\t.txt                 //getPaht()
E:\eclipse\IO\ft\t.txt   //getAbsolutePaht()
ft\t.txt
E:\eclipse\IO\ft\t.txt
ft\t.txt
E:\eclipse\IO\ft\t.txt

没有加盘符创建的就是相对路径，这个相对路径是相对于我们目前这个工程保存的位置而言的。

我这里的工程是E:\eclipse\IO\，相对路径前面会自动加上当前工程地址(E:\eclipse\IO\)，然后才是我们输入的的地址（ft\t.txt）。

相对地址，绝对地址的区别就是加不加盘符的区别。我们也可以发现使用getPath获取相对路径时获取的不是完整的绝对地址。

使用getPath()获取只会获取传递进去那部分路径的地址，传递进去的是绝对路径返回的就是绝对路径，传递进去的是相对地址就返回相对路径，

不会加上相对路径前面一部分的地址。而要获取绝对地址则需要用getAbsolutePath().

3.File常用方法

3.1String getName()  //获取文件名

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t.txt";
        File f1 = new File(parent,child);
        File f3 = new File("ft\\t.txt");
        System.out.println(f1.getName());
        System.out.println(f3.getName());
    }
}

运行结果：
t.txt
t.txt

3.2 String getParent()//返回上一级目录，相对返回null

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t.txt";
        File f1 = new File(parent,child);
        File f3 = new File("t.txt");
        System.out.println(f1.getAbsolutePath());
        System.out.println(f1.getParent());
        System.out.println(f3.getAbsolutePath());
        System.out.println(f3.getParent());
    }
}

运行结果：
E:\t.txt
E:\
E:\eclipse\IO\t.txt
null

3.2

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t.txt";
        File f1 = new File(parent,child);
     //   File f3 = new File("t.txt");
        System.out.println(f1.getAbsolutePath());
        System.out.println(f1.exists());//判断文件（t.txt）是否存在，存在返回true，反之false
        
    }
}

运行结果：
E:\t.txt
false

3.3

boolean canRead()
boolean canWrite()

判断文件，文件夹是否可读、可写。

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t.txt";
        File f1 = new File(parent,child);
        File f3 = new File("E:\\");
        System.out.println(f1.getAbsolutePath());
        System.out.println("文件是否存在:"+f1.exists());
        System.out.println("文件是否可写:"+f1.canWrite());
        System.out.println(f3.getAbsolutePath());
        System.out.println("文件是否存在:"+f3.exists());
        System.out.println("文件是否可写:"+f3.canWrite()); 
    }
}

运行结果：
E:\t.txt
文件是否存在:false
文件是否可写:false
E:\
文件是否存在:true
文件是否可写:true

上列代码中t.txt文件并不存在只是构建了路径，但文件本身不存在，文件不存在的话自然不可读。

如果文件存在，也要考虑其是否可读、可写。因为可能有些文件进行了读写权限的设置。

3.4

boolean isFile()//判断是否是文件，是文件返回true反之返回false。若文件不存在返回false。
boolean isDirectory()//判断是否是文件夹，是文件夹返回true反之返回false。若文件夹不存在返回false。

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t";
        File f1 = new File(parent,child);
        File f2 = new File(parent,"t.txt");
        File f3 = new File("E:\\ssm\\pom.xml");
        System.out.println(f1.getAbsolutePath());
        System.out.println("文件是否存在:"+f1.exists());
        System.out.println("是不是文件？"+f1.isFile());
        System.out.println("是不是文件夹？"+f1.isDirectory());
        System.out.println(f2.getAbsolutePath());
        System.out.println("文件是否存在:"+f2.exists());
        System.out.println("是不是文件？"+f2.isFile());
        System.out.println("是不是文件夹？"+f2.isDirectory());
        System.out.println(f3.getAbsolutePath());
        System.out.println("文件是否存在:"+f3.exists());
        System.out.println("是不是文件？"+f3.isFile());
        System.out.println("是不是文件夹？"+f1.isDirectory());
    }
}

E:\t                 //创建的一个文件夹实例，但实际的路径是不存在的
文件是否存在:false
是不是文件？false
是不是文件夹？false
E:\t.txt            //创建一个文件实例，但实际的路径是不存在的
文件是否存在:false
是不是文件？false
是不是文件夹？false
E:\ssm\pom.xml      //创建一个文件实例，该路径存在。
文件是否存在:true
是不是文件？true
是不是文件夹？false

上列代码E:\t,E:\t.txt都不存在，E:\ssm\pom.xml存在，

可以看出如果构造的文件就不会被作为文件，同样构造的文件夹不存在也不会作为文件夹。

3.5

boolean isAbsolute()；//判断是否为绝对路径

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t";
        File f1 = new File(parent,child);
        File f2 = new File("t.txt");
        
        System.out.println(f1.getPath());
        System.out.println(f1.isAbsolute());
        System.out.println(f2.getPath());
        System.out.println(f2.isAbsolute());
    }
}

运行结果：
E:\t
true
t.txt
false

3.6

long length()//返回文件的字节数

import java.io.File;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="ssm";
        File f1 = new File(parent,child);
        File f2 = new File("E:\\ssm\\pom.xml");
        
        System.out.println(f1.getPath());
        System.out.println(f1.length());
        System.out.println(f2.getPath());
        System.out.println(f2.length());
    }
}

运行结果：
E:\ssm
4096
E:\ssm\pom.xml
4644

  

可以看到文件的字节数正常读取了，而文件夹读取的确是有问题的，这是因为length只能读取文件，读取文件夹的数值并不准确。

如果文件夹不存在或为空文件夹可能读取的字节数是0，这个可以自行实验。

3.7

boolean createNewFile()/如果文件不存在且创建成功返回true，文件已存在返回false

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t.txt";
        File f1 = new File(parent,child);      //该文件不存在
        File f2 = new File("E:\\ssm\\pom.xml");//该文件已存在
        
        try {
            System.out.println(f1.createNewFile());
            System.out.println(f2.createNewFile());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

运行结果；
true
false

可以看到E盘多了一个我们指定创建的文件。

3.8

boolean delete()//删除文件或文件夹，

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="t.txt";
        File f1 = new File(parent,child);
        File f2 = new File("E:\\ssm\\pom.xml");
        f1.delete();
    }
}

运行结果：
true

这样就将我们之前创建的t.txt删除了。

3.9

public static File createTempFile(String prefix, String suffix, File directory)

//prefix前缀，suffix后缀，directory创建文件所在文件夹.suffix可以为null，此时将使用.tmp。

如果需要文件自动删除，需配合deleteOnExit（）方法。该方法为静态方法，可通过类名调用，

调用完会返回一个File对象，对临时文件进行操作。

void deleteOnExit()//虚拟机终止时，删除该文件。

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="";
        File f1 = new File(parent,child);
        try {
            File temp = File.createTempFile("temp",".txt",f1);
            Thread.sleep(5000);
            temp.deleteOnExit();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

程序运行后会在E盘下创建一个已temp开头，后缀为.txt的文件。

5s后程序自动删除。注意这里删除文件是在程序运行结束后才删除，

例如我们在temp.deleteOnExit();后面加上Thread.sleep（50000）；

会发现过了五十秒后文件才会自动删除。

3.10

boolean mkdir()//创建文件夹，所有上一级目录必须存在
boolean mkdirs()//创建文件夹，如果上一级目录不存在，则自动创建

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="parent\\child";//E盘下parent文件夹不存在
        File f1 = new File(parent,child);//E:\parent目录下创建child文件夹
        System.out.println(f1.mkdir());
        System.out.println(f1.mkdirs());
    }
}

运行结果：
false
true

使用mkdir创建文件夹时，最后一级目录之前的目录必须全部存在，否则就会创建失败。

而mkdirs创建时，如果有目录不存在就会直接创建。

3.11

String[] list()//返回一个字符串数组该抽象路径名所表示的目录中的文件和目录,
由这个抽象路径名表示的目录中的文件和目录的字符串数组。如果目录为空，则数组将为空。
如果此抽象路径名不表示目录，或发生I/O错误，则返回NULL。

File[] listFiles()
返回一个抽象路径名数组，表示由该抽象路径名表示的目录中的文件。

如果此抽象路径名不表示目录，则此方法返回null。否则返回一个文件对象数组，一个目录中的每个文件或目录。

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="java";
        File f1 = new File(parent,child);
        String[] fString = f1.list();
        File[] fFile = f1.listFiles();
        for(String temp:fString){
            System.out.println(temp);
        }
        System.out.println("------------------------------------");
        for(File temp:fFile){
            System.out.println(temp.getAbsolutePath());
        }
    }
}

bin
COPYRIGHT
db
include
javafx-src.zip
jre
lib
LICENSE
README.html
release
src.zip
THIRDPARTYLICENSEREADME-JAVAFX.txt
THIRDPARTYLICENSEREADME.txt
------------------------------------
E:\java\bin
E:\java\COPYRIGHT
E:\java\db
E:\java\include
E:\java\javafx-src.zip
E:\java\jre
E:\java\lib
E:\java\LICENSE
E:\java\README.html
E:\java\release
E:\java\src.zip
E:\java\THIRDPARTYLICENSEREADME-JAVAFX.txt
E:\java\THIRDPARTYLICENSEREADME.txt

我们要首先要注意调用list和listFiles方法的抽象路径是文件夹，

其次list返回的是该文件夹下所有文件夹和文件的名称，是以字符数组的形式返回的。

而listFiles返回的是该文件夹下所有文件夹和文件的抽象路径对象，拥有这个对象我们可以对这些文件夹及文件进行操作。

利用listFiles我们就可以打印出指定文件夹下所有文件了。

import java.io.File;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="java";
        File f1 = new File(parent,child);
        String[] fString = f1.list();
        File[] fFile = f1.listFiles();//获取指定目录下所有文件及目录的抽象路径对象
        printAllFileName(fFile);
    }
    public static void printAllFileName(File[] fileArray){//打印所有文件名
        for(File temp:fileArray){
            if(temp.isDirectory()){//如果当前对象为文件夹，则继续获取该文件夹下所有对象。
                File[] fFile = temp.listFiles();
                printAllFileName(fFile);//递归
            }
            System.out.println(temp.getAbsolutePath());//输出所有对象的绝对地址
        }
    }
}

运行结果：//文件很多只截取了一部分。
E:\java\lib\missioncontrol\features\org.eclipse.equinox.p2.rcp.feature_1.2.0.v20140523-0116\epl-v10.html
.
.
.
E:\java\THIRDPARTYLICENSEREADME-JAVAFX.txt
E:\java\THIRDPARTYLICENSEREADME.txt

3.12

File[] listFiles(FileFilter filter)//返回一个抽象路径名数组，该数组中的元素必须满足文件过滤器的筛选条件。

 我们来看下过滤器是如何起作用的，我们先来看下listFiles（FileFilter filter）的源码

主要看if（filter == null || filater.accept(f)）这一句，accept是FileFilter接口中的方法，

是用于指导筛选条件的，满足条件返回ture反之返回false。我们接着看后面

满足筛选条件就会返回true，则该文件对象会被加入到一个文件对象数组中，

最后会返回这个文件数组对。

可见指定accept方法中的条件才是关键。

我们接着来看下accept方法的定义。

传递进去的是一个文件的地址名，也可以理解为是一个文件对象，

在该方法中对pathname文件对象指定规则返回true，则该文件就通过了筛选，反之亦然。

我们接下里看一个实际的例子，例如我要输出某一个文件夹下所有后缀为.xml的文件。

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="java";
        File f1 = new File(parent,child);
        String[] fString = f1.list();
        File[] fFile = f1.listFiles(new FileFilter(){
            @Override
            public boolean accept(File pathname) {
                // TODO Auto-generated method stub
                return pathname.isDirectory() || pathname.getName().endsWith(".xml");
            }    
        });
        printAllFileName(fFile);
    }
    public static void printAllFileName(File[] fileArray){
        if(fileArray == null)
            return;
        for(File temp:fileArray){
            if(temp.isDirectory()){
                File[] fFile = temp.listFiles(new FileFilter(){//由于fileFilter是接口，所以需要构造匿名内部类。
                    @Override                                  //这里也可以定义一个类实现FileFileter接口，然后new一个对象
                    public boolean accept(File pathname) {
                        // TODO Auto-generated method stub
                        return pathname.isDirectory() || pathname.getName().endsWith(".xml");
                    }//指定规则，当前文件是以.xml结尾或者是文件夹则通过筛选。虽然文件夹不用输出，但是后续需要通过文件夹去寻找下一级中是否有.xml文件。
                    
                });
                printAllFileName(fFile);
            }
            if(!temp.isDirectory())//当前对象为文件夹则不输出。
                System.out.println(temp.getAbsolutePath());
        }
    }
}

运行结果：
略

3.12

public static File[] listRoots()//返回所有根目录对象

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;

public class Test {
    public static void main(String[] args) {
        String parent = "E:\\";
        String child ="java";
        File f1 = new File(parent,child);
        String[] fString = f1.list();
        File[] fFile = f1.listRoots();//获取根目录文件对象
        for(File temp:fFile){
            System.out.println(temp.getAbsolutePath());
        }
    //    printAllFileName(fFile);
    }
    public static void printAllFileName(File[] fileArray){
        if(fileArray == null)
            return;
        for(File temp:fileArray){
            if(temp.isDirectory()){
                File[] fFile = temp.listFiles(new OutXmlFile());
                printAllFileName(fFile);
            }
            if(!temp.isDirectory())
                System.out.println(temp.getAbsolutePath());
        }
    }
}

class OutXmlFile implements FileFilter{//创建类实现接口方法添加过滤器
    public boolean accept(File pathname) {
        // TODO Auto-generated method stub
        return pathname.isDirectory() || pathname.getName().endsWith(".xml");
    }
}

运行结果；
C:\
D:\
E:\
F:\

这里的根目录是指最顶端的根目录。