文件和目录操作
文件和目录操作最终是与操作系统和文件系统相关的，不同系统的实现是不一样的，但Java中的java.io.File类提供了同一的接口，底层会通过本地方法调用操作系统和文件系统的具体实现，这里我们介绍File类。File类中的操作大概可以分为三类：文件元数据、文件操作、目录操作，在介绍这些操作之前，我们先看下File的构造方法。
构造方法
File既可以表示文件，也可以表示目录，它的主要构造方法有：
//pathname表示完整路径，该路径可以是相对路径，也可以是绝对路径
public File(String pathname)
//parent表示父目录，child表示孩子
public File(String parent, String child)
public File(File parent, String child)
File中的路径可以是已经存在的，也可以是不存在的。通过new新建一个File对象，不会实际创建一个文件，只是创意一个表示文件或目录的对象，new之后，File对象中的路径是不可变的。
文件元数据
文件元数据主要包括文件名和路径、文件基本信息以及一些安全和权限相关的信息。文件名和路径相关的主要方法有：
public String getName() //返回文件或目录名称，不含路径名
public boolean isAbsolute() //判断File中的路径是否是绝对路径
public String getPath() //返回构造File对象时的完整路径名，包括路径和文件名称
public String getAbsolutePath() //返回完整的绝对路径名
//返回标准的完整路径名，它会去掉路径中的冗余名称如".", ".."，跟踪软链接(Unix系统概念)等
public String getCanonicalPath() throws IOException
public String getParent() //返回父目录路径
public File getParentFile() //返回父目录的File对象
//返回一个新的File对象，新的File对象使用getAbsolutePath()的返回值作为参数构造
public File getAbsoluteFile()
//返回一个新的File对象，新的File对象使用getCanonicalPath()的返回值作为参数构造
public File getCanonicalFile() throws IOException
这些方法比较直观，我们就不解释了。File类中有4个静态变量，表示路径分隔符，他们是：
public static final String separator
public static final char separatorChar
public static final String pathSeparator
public static final char pathSeparatorChar
separator和separatorChar表示文件路径分隔符，在Windows系统中，一般为’’, Linux系统中一般为’/’。pathSeparator和pathSeparatorChar表示多个文件路径中的分隔符，比如，环境变量PATH中的分隔符，Java类路径变量classpath中的分隔符，在执行命令时，操作系统会从PATH指定的目录中寻找命令，Java运行时加载class文件时，会从classpath指定的路径中寻找类文件。在Windows系统中，这个分隔符一般为’; ‘，在Linux系统中，这个分隔符一般为’:’。
除了文件名和路径，File对象还有如下方法，以获取文件或目录的基本信息：
public boolean exists() //文件或目录是否存在
public boolean isDirectory() //是否为目录
public boolean isFile() //是否为文件
public long length() //文件长度，字节数，对目录没有意义
public long lastModified() //最后修改时间，从纪元时开始的毫秒数
public boolean setLastModified(long time) //设置最后修改时间，返回是否修改成功
需要说明的是，File对象没有返回创建时间的方法，因为创建时间不是一个公共概念，Linux/Unix就没有创建时间的概念。
File类中与安全和权限相关的主要方法有：
public boolean isHidden() //是否为隐藏文件
public boolean canExecute() //是否可执行
public boolean canRead() //是否可读
public boolean canWrite() //是否可写
public boolean setReadOnly() //设置文件为只读文件
//修改文件读权限
public boolean setReadable(boolean readable, boolean ownerOnly)
public boolean setReadable(boolean readable)
//修改文件写权限
public boolean setWritable(boolean writable, boolean ownerOnly)
public boolean setWritable(boolean writable)
//修改文件可执行权限
public boolean setExecutable(boolean executable, boolean ownerOnly)
public boolean setExecutable(boolean executable)
在修改方法中，如果修改成功，返回true，否则返回false。在设置权限方法中，owner-Only为true表示只针对owner，为false表示针对所有用户，没有指定ownerOnly的方法中，ownerOnly相当于是true。
文件操作
文件操作主要有创建、删除、重命名。
新建一个File对象不会实际创建文件，但如下方法可以：
public boolean createNewFile() throws IOException
创建成功返回true，否则返回false，新创建的文件内容为空。如果文件已存在，不会创建。
File对象还有两个静态方法，可以创建临时文件：
public static File createTempFile(String prefix, String suffix) throws IOException
public static File createTempFile(String prefix, String suffix,File directory) throws IOException
临时文件的完整路径名是系统指定的、唯一的，但可以通过参数指定前缀（prefix）、后缀（suffix）和目录（directory）。prefix是必需的，且至少要三个字符；suffix如果为null，则默认为．tmp; directory如果不指定或指定为null，则使用系统默认目录。
File类的删除方法为：
public boolean delete()
public void deleteOnExit()
delete删除文件或目录，删除成功返回true，否则返回false。如果File是目录且不为空，则delete不会成功，返回false，换句话说，要删除目录，先要删除目录下的所有子目录和文件。deleteOnExit将File对象加入到待删列表，在Java虚拟机正常退出的时候进行实际删除。
File类的重命名方法为：
public boolean renameTo(File dest)
参数dest代表重命名后的文件，重命名能否成功与系统有关，返回值代表是否成功。
目录操作
当File对象代表目录时，可以执行目录相关的操作，如创建、遍历。有两个方法用于创建目录：
public boolean mkdir()
public boolean mkdirs()
它们都是创建目录，创建成功返回true，失败返回false。需要注意的是，如果目录已存在，返回值是false。这两个方法的区别在于：如果某一个中间父类目录不存在，则mkdir会失败，返回false，而mkdirs则会创建必须的中间父目录。
有如下方法访问一个目录下的子目录和文件：
public String[] list()
public String[] list(FilenameFilter filter)
public File[] listFiles()
public File[] listFiles(FileFilter filter)
public File[] listFiles(FilenameFilter filter)
它们返回的都是直接子目录或文件，不会返回子目录下的文件。list返回的是文件名数组，而listFiles返回的是File对象数组。FilenameFilter和FIleFilter都是借口，用于过滤，FileFilter定义为：
public interface FileFilter {
boolean accept(File pathname);
}
FilenameFilter的定义为:
public interface FilenameFilter {
boolean accept(File dir, String name);
}
在遍历子目录和文件时，针对每个文件，会调用FilenameFilter或FileFilter的accept方法，只有accept方法返回true时，才将该子目录或文件包含到返回结果中。Filename-Filter和FileFilter的区别在于：FileFilter的accept方法参数只有一个File对象，而File-nameFilter的accept方法参数有两个，dir表示父目录，name表示子目录或文件名。我们来看个例子，列出当前目录下的所有扩展名为．txt的文件，代码可以为：
File f = new File(".");
File[] files = f.listFiles(new FilenameFilter(){
@Override
public boolean accept(File dir, String name) {
if(name.endsWith(".txt")){
return true;
}
return false;
}
});
我们创建了个FilenameFilter的匿名内部类对象并传递给了listFiles。
使用遍历方法，可以方便地进行递归遍历，完成一些更为高级的功能。比如，计算一个目录下的所有文件的大小（包括子目录），代码可以为：
public static long sizeOfDirectory(final File directory) {
long size = 0;
if(directory.isFile()) {
return directory.length();
} else {
for(File file : directory.listFiles()) {
if(file.isFile()) {
size += file.length();
} else {
size += sizeOfDirectory(file);
}
}
}
return size;
}
再如，在一个目录下，查找所有给定文件名的文件，代码可以为:
public static Collection<File> findFile(final File directory, final String fileName) {
List<File> files = new ArrayList<>();
for(File f : directory.listFiles()) {
if(f.isFile() && f.getName().equals(fileName)) {
files.add(f);
} else if(f.isDirectory()) {
files.addAll(findFile(f, fileName));
}
}
return files;
}
前面介绍了File类的delete方法，我们提到，如果要删除目录而目录不为空，需要先清空目录，利用遍历方法，我们可以写一个删除非空目录的方法，代码可以为：
public static void deleteRecursively(final File file) throws IOException {
if(file.isFile()) {
if(! file.delete()) {
throw new IOException("Failed to delete "
+ file.getCanonicalPath());
}
} else if(file.isDirectory()) {
for(File child : file.listFiles()) {
deleteRecursively(child);
}
if(! file.delete()) {
throw new IOException("Failed to delete "
+ file.getCanonicalPath());
}
}
}
Java实例练习
按顺序写入文件
BufferWriter类将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。本例我们将使用BufferWriter类进行文件的顺序创建。
1.
新建项目OrderWriteFiles，并在其中创建一个OrderWriteFiles.java文件。在该类的主方法中使用BufferedWriter实现字符串的顺序写入：
package OrderWriteFiles;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class OrderWriteFiles {
public static void main(String[] args) {
FileWriter fw;
try {
fw = new FileWriter("D:/test1.txt");
BufferedWriter bf = new BufferedWriter(fw);
for (int i = 0; i < 10; i++) {
bf.write("Java" + i + "\n");
}
bf.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
BufferWriter类将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够了。
块速查找指定类型的文件
在文件夹中存在很多文件夹和文件，为了快速地冲一个文件结构中找出指定类型的所有文件，我们可以使用文件类型的过滤器——FileFilter，以方便快速地实现对指定类型文件进行过滤和筛选。
1.
新建项目SearchFile，并在其中创建一个SearchFile.java文件。在该类的主方法中使用FileFilter类实现文件的查找功能：
package SearchFile;
import java.io.File;
import java.io.FileFilter;
import java.util.ArrayList;
import java.util.List;
public class SearchFile {
static int countFiles = 0;
static int countFolders = 0;
public static File[] searchFile(File folder, final String keyword) {
File[] subFolders = folder.listFiles(new FileFilter() {
@Override
public boolean accept(File pathname) {
if (pathname.isFile())
countFiles++;
else
countFolders++;
if (pathname.isDirectory() || (pathname.isFile() && pathname.getName().contains(keyword)))
return true;
return false;
}
});
List result = new ArrayList();
for (int i = 0; i < subFolders.length; i++) {
if (subFolders[i].isFile()) {
result.add(subFolders[i]);
} else { //如果是文件夹，则递归调用本方法，然后把所有的文件加到结果列表中
File[] foldResult = searchFile(subFolders[i], keyword);
for (int j = 0; j < foldResult.length; j++) {
result.add(foldResult[j]); //文件保存到结合中
}
}
}
File files[] = new File[result.size()]; //证明文件数组，长度为集合的长度
result.toArray(files); //集合数组化
return files;
}
public static void main(String[] args) {
File folder = new File("D:/test"); //默认目录
String keyword = "txt";
if (!folder.exists()) { //如果文件不存在
System.out.println("目录不存在：" + folder.getAbsolutePath());
return;
}
File[] result = searchFile(folder, keyword); //调用方法获得文件数组
System.out.println("在" + folder + "以及所有子文件时查找对象" + keyword);
System.out.println("查找了"+countFiles+"个文件，"+countFolders+" 个文件夹，共找到"+result.length+"个符合条件的文件：");
for (int i = 0; i < result.length; i++) {
File file = result[i];
System.out.println(file.getAbsolutePath()+""); //显示文件绝对路径
}
}
}
过滤流提供了在读/写数据的同时可以对数据进行处理的功能，同时还提供了同步机制，使得某一时刻只有一个线程可以访问一个数据流，以防止多个线程同时对一个数据流进行操作所带来的意想不到的结果。
为了使用一个过滤流，必须首先把过滤流连接到某个输入输出流上，通常通过在构造方法的参数中指定所要连接的输入输出流来实现。
以遍历方式显示文件中的字符
除了OutputStream类和Reader类方法来读取文件之外，我们还可以使用简单的while或者for循环来以遍历的方式显示文件内容。本例将使用while循环遍历输出文件中的字符。
1.
新建项目TraversalCycle，并在其中创建一个TraversalCycle.java文件。在该类的主方法中通过FileInputStream()方法提取文件，然后使用while循环便利输出文件的内容：
package TraversalCycle;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
public class TraversalCycle {
public static void main(String[] args) {
int i = 0;
FileInputStream fis = null;
try {
fis = new FileInputStream("D:/test/test1.txt"); //指定一个文件
} catch (FileNotFoundException e) {
System.out.println("没有找到指定的文件。");
System.exit(-1);
} catch (ArrayIndexOutOfBoundsException e) {
System.exit(-2);
}
try {
while ((i = fis.read()) != -1)
System.out.print((char) i);
fis.close();
} catch (IOException e) {
System.out.println("显示文件名");
}
}
}
字节输入流（InputStream）是所有字节输入流的类的超类，它是一个抽象类。它的派生类必须重新定义字节输入流中声明抽象方法。Read()方法是从输入流中读取一个字节的内容并以整型返回。如果遇到流的结束符则返回-1，如果流没有结束，但暂时又没有数据可读，那么该方法就会处于阻塞状况，直到流中有了新的可读数据。