¿Cómo verificar si una ruta dada es posible que sea hija de otra ruta?

Estoy tratando de encontrar si la ruta dada es posible que sea hija de otra ruta usando Java. Ambas rutas pueden no existir.

Decir c:\Program Files\My Company\test\My App es un posible hijo de c:\Program Files.

Actualmente estoy haciendo esto con

boolean myCheck(File maybeChild, File possibleParent)
{
    return maybeChild.getAbsolutePath().startsWith( possibleParent.getAbsolutePath());
}

También puedes usar java.nio.file.Path para hacer esto mucho más fácilmente. El java.nio.file.Path.startsWith método parece manejar todos los casos posibles.

Ejemplo:

private static void isChild(Path child, String parentText) {
    Path parent = Paths.get(parentText).toAbsolutePath();
    System.out.println(parentText + " = " + child.startsWith(parent));
}

public static void main(String[] args) {
    Path child = Paths.get("/FolderA/FolderB/File").toAbsolutePath();
    isChild(child, "/FolderA/FolderB/File");
    isChild(child, "/FolderA/FolderB/F");
    isChild(child, "/FolderA/FolderB");
    isChild(child, "/FolderA/Folder");
    isChild(child, "/FolderA");
    isChild(child, "/Folder");
    isChild(child, "/");
    isChild(child, "");
}

Producción:

/FolderA/FolderB/File = true
/FolderA/FolderB/F = false
/FolderA/FolderB = true
/FolderA/Folder = false
/FolderA = true
/Folder = false
/ = true
 = false

Si necesita más confiabilidad, puede usar toRealPath en lugar de toAbsolutePath.

File parent = maybeChild.getParentFile();
while ( parent != null ) {
  if ( parent.equals( possibleParent ) )
    return true;
  parent = parent.getParentFile();
}
return false;

Aparte del hecho de que las rutas pueden no existir (y la canonicalización puede no tener éxito), este parece un enfoque razonable que debería funcionar en el caso sencillo.

Es posible que desee considerar llamar getParentFile() en el “tal vez niño” en un bucle, probando si coincide con el padre en cada paso. También puede cortocircuitar la comparación si el padre no es un directorio (real).

Tal vez algo como lo siguiente:

boolean myCheck(File maybeChild, File possibleParent) throws IOException
{
    final File parent = possibleParent.getCanonicalFile();
    if (!parent.exists() || !parent.isDirectory()) {
        // this cannot possibly be the parent
        return false;
    }

    File child = maybeChild.getCanonicalFile();
    while (child != null) {
        if (child.equals(parent)) {
            return true;
        }
        child = child.getParentFile();
    }
    // No match found, and we've hit the root directory
    return false;
}

Tenga en cuenta que si desea que la relación secundaria sea estricto (es decir, un directorio no es un hijo de sí mismo) puede cambiar la inicial child asignación en la línea 9 para ser child.getParentFile() entonces la primera verificación ocurre en el directorio contenedor del niño.

Esto funcionará para su ejemplo. también volverá true si el niño es una ruta relativa (que a menudo es deseable).

boolean myCheck(File maybeChild, File possibleParent)
{
    URI parentURI = possibleParent.toURI();
    URI childURI = maybeChild.toURI();
    return !parentURI.relativize(childURI).isAbsolute();
}

Eso probablemente funcionará bien tal como está, aunque yo usaría getCanonicalPath() en vez de getAbsolutePath(). Esto debería normalizar cualquier ruta extraña como x/../y/z que de otro modo estropearía la coincidencia.

maybeChild.getCanonicalPath().startsWith( possibleParent.getCanonicalPath() );

¡Tenga en cuenta las rutas relativas! Creo que la solución más simple es algo como esto:

public boolean myCheck(File maybeChild, File possibleParent) {
  if (requestedFile.isAbsolute) {
    return possibleParent.resolve(maybeChild).normalize().toAbsolutePath.startsWith(possibleParent.normalize().toAbsolutePath)
  } else {
    return maybeChild.normalize().toAbsolutePath.startsWith(possibleParent.normalize().toAbsolutePath)
  }
}

En scala puedes tener un enfoque similar:

val baseDir = Paths.get("/home/luvar/tmp")
val baseDirF = baseDir.toFile
//val requestedFile = Paths.get("file1")
val requestedFile = Paths.get("../.viminfo")
val fileToBeRead = if (requestedFile.isAbsolute) {
  requestedFile
} else {
  baseDir.resolve(requestedFile)
}
fileToBeRead.toAbsolutePath
baseDir.toAbsolutePath
fileToBeRead.normalize()
baseDir.normalize()
val isSubpath = fileToBeRead.normalize().toAbsolutePath.startsWith(baseDir.normalize().toAbsolutePath)