java - mas - ¿Cómo comprobar si un camino determinado es posible hijo de otro camino?

codigo de grafos en java netbeans

Question

Estoy tratando de encontrar si el camino dado es posible hijo de otro camino usando java. Ambos caminos pueden no existir.

Digamos 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());
}

Answer 1

¡Sé consciente de los caminos relativos! 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)

Answer 2

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

Es posible que desee buscar en getParentFile() en el "hijo tal vez" 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 child.getParentFile() sea estricta (es decir, un directorio no es un elemento secundario), puede cambiar la asignación child inicial en la línea 9 para que sea child.getParentFile() modo que la primera verificación se child.getParentFile() en el directorio contenedor del hijo.

Answer 3

Esto funcionará para tu ejemplo. También devolverá 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();
}

Answer 4

Pregunta anterior pero una solución anterior a 1.7:

public boolean startsWith(String possibleRoot, String possibleChildOrSame) {
        String[] possiblePath = new File(possibleRoot).getAbsolutePath().replace(''//', ''/'').split("/");
        String[] possibleChildOrSamePath = new File(possibleChildOrSame).getAbsolutePath().replace(''//', ''/'').split("/");

        if (possibleChildOrSamePath.length < possiblePath.length) {
            return false;
        }

        // not ignoring case
        for (int i = 0; i < possiblePath.length; i++) {
            if (!possiblePath[i].equals(possibleChildOrSamePath[i])) {
                return false;
            }
        }
        return true;
}

Para completar la solución java 1.7+:

public boolean startsWith(String possibleRoot, String possibleChildOrSame) {
        Path p1 = Paths.get(possibleChildOrSame).toAbsolutePath();
        Path p2 = Paths.get(possibleRoot).toAbsolutePath();
        return p1.startsWith(p2);
}

Answer 5

Probablemente funcionará bien, aunque usaría getCanonicalPath() lugar de getAbsolutePath() . Esto debería normalizar cualquier x/../y/z extraña como x/../y/z que de otro modo x/../y/z el emparejamiento.

Answer 6

También puede usar java.nio.file.Path para hacer esto mucho más fácilmente. El método java.nio.file.Path.startsWith 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, "");
}

salidas

/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".

Answer 7

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

Answer 8

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