我有一个字符串形式的文件路径。在 Java 中，我需要确定该文件是否存在于文件系统中（并且我们的代码需要跨平台，因为它在 Windows、Linux 和 OS X 上运行）。
问题是文件路径和文件本身的大小写可能不匹配，即使它们确实代表同一个文件（大概这是因为它们起源于 Windows 并且没有注意到差异）。
例如，我有一个“ABC.txt”的文件路径。文件系统上存在一个名为“abc.txt”的文件。以下代码将在 Windows上返回true ，但在 Linux上返回false ：
new File("ABC.txt").exists();
确定文件是否存在以及是否存在以返回文件系统上文件的句柄的最佳方法是什么？
从目录 ( File.list()) 中获取文件列表并使用 比较名称equalsIgnoreCase()。
此方法将告诉您是否存在具有确切名称的文件（路径部分不区分大小写）。
public static boolean caseSensitiveFileExists(String pathInQuestion) {
File f = new File(pathInQuestion);
return f.exists() && f.getCanonicalPath().endsWith(f.getName());
}
正如 jwaddell 所说，看起来非常慢的递归路径检查是（显然）执行此操作的唯一方法。这是我用java编写的函数，它接受一个作为文件路径的字符串。如果文件路径的字符串表示存在并且与 windows 报告的具有相同的大小写敏感性，则返回 true，否则返回 false。
public boolean file_exists_and_matches_case(
String full_file_path) {
//Returns true only if:
//A. The file exists as reported by .exists() and
//B. Your path string passed in matches (case-sensitivity) the entire
// file path stored on disk.
//This java method was built for a windows file system only,
//no guarantees for mac/linux/other.
//It takes a String parameter like this:
//"C:\\projects\\eric\\snalu\\filename.txt"
//The double backslashes are needed to escape the one backslash.
//This method has partial support for the following path:
//"\\\\yourservername\\foo\\bar\\eleschinski\\baz.txt".
//The problem is it stops recusing at directory 'foo'.
//It ignores case at 'foo' and above. So this function
//only detects case insensitivity after 'foo'.
if (full_file_path == null) {
return false;
}
//You are going to have to define these chars for your OS. Backslash
//is not specified here becuase if one is seen, it denotes a
//directory delimiter: C:\filename\fil\ename
char[] ILLEGAL_CHARACTERS = {'/', '*', '?', '"', '<', '>', '>', '|'};
for (char c : ILLEGAL_CHARACTERS) {
if (full_file_path.contains(c + "")) {
throw new RuntimeException("Invalid char passed in: "
+ c + " in " + full_file_path);
}
}
//If you don't trim, then spaces before a path will
//cause this: 'C:\default\ C:\mydirectory'
full_file_path = full_file_path.trim();
if (!full_file_path.equals(new File(full_file_path).getAbsolutePath()))
{
//If converting your string to a file changes the directory in any
//way, then you didn't precisely convert your file to a string.
//Programmer error, fix the input.
throw new RuntimeException("Converting your string to a file has " +
"caused a presumptous change in the the path. " + full_file_path +
" to " + new File(full_file_path).getAbsolutePath());
}
//If the file doesn't even exist then we care nothing about
//uppercase lowercase.
File f = new File(full_file_path);
if (f.exists() == false) {
return false;
}
return check_parent_directory_case_sensitivity(full_file_path);
}
public boolean check_parent_directory_case_sensitivity(
String full_file_path) {
//recursively checks if this directory name string passed in is
//case-identical to the directory name reported by the system.
//we don't check if the file exists because we've already done
//that above.
File f = new File(full_file_path);
if (f.getParent() == null) {
//This is the recursion base case.
//If the filename passed in does not have a parent, then we have
//reached the root directory. We can't visit its parent like we
//did the other directories and query its children so we have to
//get a list of drive letters and make sure your passed in root
//directory drive letter case matches the case reported
//by the system.
File[] roots = File.listRoots();
for (File root : roots) {
if (root.getAbsoluteFile().toString().equals(
full_file_path)) {
return true;
}
}
//If we got here, then it was because everything in the path is
//case sensitive-identical except for the root drive letter:
//"D:\" does not equal "d:\"
return false;
}
//Visit the parent directory and list all the files underneath it.
File[] list = new File(f.getParent()).listFiles();
//It is possible you passed in an empty directory and it has no
//children. This is fine.
if (list == null) {
return true;
}
//Visit each one of the files and folders to get the filename which
//informs us of the TRUE case of the file or folder.
for (File file : list) {
//if our specified case is in the list of child directories then
//everything is good, our case matches what the system reports
//as the correct case.
if (full_file_path.trim().equals(file.getAbsolutePath().trim())) {
//recursion that visits the parent directory
//if this one is found.
return check_parent_directory_case_sensitivity(
f.getParent().toString());
}
}
return false;
}
如果差异是随机的，那么对我来说 Shimi 的解决方案包括递归路径段检查是最好的解决方案。乍一看这听起来很难看，但您可以将魔术隐藏在一个单独的类中并实现一个简单的 API 来返回给定文件名的文件句柄，因此您只会看到类似Translator.translate(file)调用的内容。
也许，这些差异是静态的、可预测的。那么我更喜欢一个字典，它可以用来将给定的文件名翻译成 Windows/Linux 文件名。与其他方法相比，这具有很大的优势：获取错误文件句柄的风险较小。
如果字典真的是静态的，您可以创建和维护一个属性文件。如果它是静态的但更复杂，比如给定的文件名可以转换为多个可能的目标文件名，我会用数据结构备份字典类Map<String, Set<String>>（Set首选，List因为没有重复的替代项）。
这是我的 Java 7 解决方案，适用于已知父路径且相对子路径可能与磁盘上的路径不同的情况。
例如，给定文件/tmp/foo/biscuits，该方法将Path使用以下输入正确地将 a 返回到文件：
/tmp和foo/biscuits/tmp和foo/BISCUITS/tmp和FOO/BISCUITS/tmp和FOO/biscuits请注意，此解决方案尚未经过可靠测试，因此应将其视为起点，而不是可用于生产的片段。
/**
* Returns an absolute path with a known parent path in a case-insensitive manner.
*
* <p>
* If the underlying filesystem is not case-sensitive or <code>relativeChild</code> has the same
* case as the path on disk, this method is equivalent to returning
* <code>parent.resolve(relativeChild)</code>
* </p>
*
* @param parent parent to search for child in
* @param relativeChild relative child path of potentially mixed-case
* @return resolved absolute path to file, or null if none found
* @throws IOException
*/
public static Path getCaseInsensitivePath(Path parent, Path relativeChild) throws IOException {
// If the path can be resolved, return it directly
if (isReadable(parent.resolve(relativeChild))) {
return parent.resolve(relativeChild);
}
// Recursively construct path
return buildPath(parent, relativeChild);
}
private static Path buildPath(Path parent, Path relativeChild) throws IOException {
return buildPath(parent, relativeChild, 0);
}
/**
* Recursively searches for and constructs a case-insensitive path
*
* @param parent path to search for child
* @param relativeChild relative child path to search for
* @param offset child name component
* @return target path on disk, or null if none found
* @throws IOException
*/
private static Path buildPath(Path parent, Path relativeChild, int offset) throws IOException {
try (DirectoryStream<Path> stream = Files.newDirectoryStream(parent)) {
for (Path entry : stream) {
String entryFilename = entry.getFileName().toString();
String childComponent = relativeChild.getName(offset).toString();
/*
* If the directory contains a file or folder corresponding to the current component of the
* path, either return the full path (if the directory entry is a file and we have iterated
* over all child path components), or recurse into the next child path component if the
* match is on a directory.
*/
if (entryFilename.equalsIgnoreCase(childComponent)) {
if (offset == relativeChild.getNameCount() - 1 && Files.isRegularFile(entry)) {
return entry;
}
else if (Files.isDirectory(entry)) {
return buildPath(entry, relativeChild, offset + 1);
}
}
}
}
// No matches found; path can't exist
return null;
}
至于问题的第一部分：使用Path.toRealPath。它不仅处理区分大小写，还处理符号链接（取决于您作为参数提供的选项）等。这需要 Java 7 或更高版本。
至于问题的第二部分：不确定“句柄”是什么意思。
您可以使用此代码执行所需的操作。由于规范文件名返回文件的名称，区分大小写，如果您得到不等于的内容，则该文件以相同的名称存在但大小写不同。
在 Windows 上，如果文件存在，无论如何，它都会返回 true。如果文件不存在，则规范名称将相同，因此将返回 false。
在 Linux 上，如果文件以不同的大小写存在，它将返回这个不同的名称，并且该方法将返回 true。如果存在相同的情况，则第一个测试返回 true。
在这两种情况下，如果文件不存在并且名称和规范名称相同，则该文件确实不存在。
public static boolean fileExistsCaseInsensitive(String path) {
try {
File file = new File(path);
return file.exists() || !file.getCanonicalFile().getName().equals(file.getName());
} catch (IOException e) {
return false;
}
}
File file = newCaseInsensitiveFile("ABC.txt");
执行：
private static File newCaseInsensitiveFile(String ignoreCaseFilename) {
try {
return Files.list(new File(".").getAbsoluteFile().toPath().getParent())
.filter(file -> file.getFileName().toString().equalsIgnoreCase(ignoreCaseFilename))
.map(Path::toFile)
.findFirst()
.orElse(new File(ignoreCaseFilename));
} catch (IOException e) {
return new File(ignoreCaseFilename);
}
}
注意：这仅适用于当前目录（“.”）。