web-dev-qa-db-fra.com

Où utiliser les méthodes resol () et relativize () de la classe Java.nio.file.Path?

Path p1 = Paths.get("/Users/jack/Documents/text1.txt");
Path p2 = Paths.get("/Users/jack/text2.txt");
Path result1 = p1.resolve(p2);
Path result2 = p1.relativize(p2);

System.out.println("result1: "+result1);
System.out.println("result2: "+result2);

SORTIE

result1: /Users/jack/text2.txt
result2: ../../text2.txt

Je ne comprends pas comment fonctionne resolve() et relativize()? 

Quelle est l'utilisation réelle de result1 et result2?

javapathresolve
7
sagar varsani

Ce sont les extraits de code de ma base de code qui vous aident à comprendre l'utilisation de la méthode resol ().

private File initUsersText() throws Exception
{
    Path dir = testdir.getPath().toRealPath();
    FS.ensureDirExists(dir.toFile());
    File users = dir.resolve("users.txt").toFile();

    writeUser( users );
    return users;
}


private File initUsersText() throws Exception
{
    Path dir = testdir.getPath().toRealPath();
    FS.ensureDirExists(dir.toFile());
    File users = dir.resolve("users.txt").toFile();

    writeUser( users );
    return users;
}

Et ce sont les exemples d'utilisation de relativize ()

public ScopePath pathToClassName(Path file) {
    if (!isValidClass(file))
        return null;

    Path relativePath = root.relativize(root.resolve(file));
    String withoutExtension = removeExtension(relativePath.toString());
    return new ScopePath(withoutExtension.replace(File.separator, "."));
}


private String getRelativePath(Path p) {
    String relativePath = packageDir.relativize(p)
            .toString();

    if (File.separator.equals("\\")) {
        relativePath = relativePath.replace("\\", "/");
    }

    return relativePath;
}
4
Akshay Pethani

Je ne comprends pas comment fonctionne la méthode resol () et relativize ()?

Path resolve(Path) résout le chemin donné en this chemin.
Path relativize(Path) construit un chemin relatif du chemin donné par rapport au chemin this.
Ce sont des opérations inverses. 

Chemin résolu (chemin autre) 

Dans le cas d'utilisation générale de resolve(), vous souhaitez renvoyer un nouvel objet Path dans lequel vous joindrez cet objet Path au paramètre Path qui est une variable Path relative, telle que:

Path p1 = Paths.get("/Users/jack");
Path p2 = Paths.get("text1.txt");
Path result1 = p1.resolve(p2);

Ici, result1 sera le chemin de jointure de p1 et p2, c'est-à-dire: /Users/jack/text1.txt. 

Dans votre exemple, le paramètre transmis à la méthode n'est pas une variable Path relative, mais un absolu:

Path p1 = Paths.get("/Users/jack/Documents/text1.txt");
Path p2 = Paths.get("/Users/jack/text2.txt");
Path result1 = p1.resolve(p2);

Cela n'a aucun sens "d'ajouter" une Path à une autre si la seconde est une absolue Path.
Le javadoc considère donc que dans ce cas, le paramètre est renvoyé comme résultat de resolve(): 

Si l'autre paramètre est un chemin absolu, cette méthode est triviale retourne autre.

Chemin relativise (Chemin autre) 

La doc dit plus spécifiquement:

Cette méthode tente de construire un chemin relatif qui une fois résolu contre this path, donne un chemin qui localise le même fichier que le fichier chemin donné. 

Cela signifie que la Path renvoyée est le chemin relatif du paramètre Path par rapport à thisPath.

Par exemple, si this path est "/a/b" et que le chemin indiqué est "/a/b/c/d", le chemin relatif résultant sera "c/d". 

Nous vérifierons cela avec votre exemple:

Path p1 = Paths.get("/Users/jack/Documents/text1.txt");
Path p2 = Paths.get("/Users/jack/text2.txt");
Path result2 = p1.relativize(p2);   
// result2= ../../text2.txt

Le chemin ../../text2.txt est attendu comme résultat car le chemin relatif généré (../../text2.txt) résolu en chemin this (/Users/jack/Documents/text1.txt) donne un chemin qui localise le même fichier que le chemin donné (/Users/jack/text2.txt):

Paths.of("/Users/jack/Documents/text1.txt").resolve("../../text2.txt")

returns -> /Users/jack/text2.txt
9
davidxxx

resolve(): rejoint deux chemins.

relativize (): construit un chemin d'un emplacement du système de fichiers à un autre.

Explication de sortie:

result1: /Users/jack/text2.txt: parce que vous avez passé un chemin absolu, resolve() renvoie le passé dans le chemin tel quel s'il s'agit d'un chemin absolu.

result2: ../../text2.txt: pour accéder à /Users/jack/text2.txt à partir de /Users/jack/Documents/text1.txt", vous devez monter deux niveaux et sélectionner simplement le fichier `text2.txt.

2
QuakeCore

resolve(Path) est une méthode permettant de créer un nouveau chemin en joignant un chemin existant au chemin actuel.

Path path1 = Paths.get("/test1/../test2");
Path path2 = Paths.get("test3");
System.out.println(path1.resolve(path2));

Le résultat sera: /test1/../test2/test3

En fait, la méthode relativize (Path) est utilisée pour construire le chemin relatif d'un objet Path à un autre:

Path path1= Paths.get("E:\\test1");
Path path2= Paths.get("E:\\test2\\test3");
System.out.println(path1.relativize(path2));
System.out.println(path2.relativize(path1));

Le résultat sera:

..\test2\test3  relative path from path1 to path2
..\..\test1     relative path from path2 to path1
0
Imar