Fichiers insensibles à la casse.est égale à la casse du système de fichiers

Obtenir la liste des fichiers du répertoire (Fichier.liste()) et comparer les noms à l'aide de equalsIgnoreCase().

OriginalL'auteur Shimi Bandiel

Comme jwaddell dit, il semble que la TRÈS LENTE récursive chemin de vérification de l'est (apparemment) la seule façon de le faire. Voici ma fonction écrite en java qui accepte une Chaîne de caractères qui est un chemin d'accès. Si la chaîne représentant le chemin d'accès du fichier existe et est identique à la casse de celui rapporté par windows, puis elle retourne true, sinon 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;
}

OriginalL'auteur Eric Leschinski

Voici mon Java 7 solution, pour les situations où un parent chemin est connu et l'un par rapport à l'enfant le chemin d'accès peuvent avoir différents cas pour le chemin d'accès sur le disque.

Par exemple, le fichier /tmp/foo/biscuits, la méthode renvoie correctement un Path pour le fichier de la manière suivante:

• /tmp et foo/biscuits
• /tmp et foo/BISCUITS
• /tmp et FOO/BISCUITS
• /tmp et FOO/biscuits

Noter que cette solution a pas été robuste testé et doit donc être considéré comme un point de départ plutôt qu'un prêt à la production de l'extrait de code.

/**
* 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;
}

OriginalL'auteur nullPainter

Vous pouvez faire ce que vous cherchez avec ce code.
Depuis l'Canonique de nom de Fichier renvoie le nom du fichier, sensible à la casse, si vous obtenez quelque chose de pas égal à égal, le fichier existe avec le même nom mais un cas différent.

Sur Windows, si le fichier existe, avec tous les cas, il retournera true. Si le fichier n'existe pas, le nom canonique sera la même, de sorte qu'il sera de retour faux.

Sur Linux, si le fichier existe avec un autre cas, il sera de retour ce nom différent, et la méthode renvoie true. Si il existe avec la même affaire, le premier test renvoie la valeur true.

Dans les deux cas, si le fichier n'existe pas et le nom et le nom canonique sont les mêmes, le fichier n'existe pas.

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;
}
}

OriginalL'auteur Julien Feniou