在哪里使用 java.nio.file.Path 类的 resolve() 和 relativize() 方法?

Question

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

输出

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

我不明白resolve()和relativize()是如何工作的？

result1和result2的实际用途是什么？

Answer 1

我不明白 resolve(( 和 relativize(( 方法是如何工作的？

Path resolve(Path)针对this路径解析给定路径。
Path relativize(Path)针对this路径构造给定路径的相对路径。
这些是反向操作。

路径

---

解析(路径其他(

在resolve()的一般用例中，您希望返回一个新的Path对象，在该对象中，您将Path对象连接到相对Path的Path参数，例如：

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

这里result1将是p1和p2的路径连接，即/Users/jack/text1.txt：

在您的示例中，传递给方法的参数不是相对Path而是绝对参数：

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

如果第二个是绝对Path，则将Path"追加"到另一个是没有意义的。
所以javadoc认为在这种情况下，参数作为resolve()的结果返回：

如果另一个参数是绝对路径，则此方法很简单 返回其他。

路径相对化(路径其他(

文档更具体地说：

此方法尝试构造一个相对路径，当解析时 针对this路径，生成一个路径，该路径定位与 给定路径。

这意味着返回的Path是Path参数相对于thisPath的相对路径。

例如，如果this路径"/a/b"并且给定路径"/a/b/c/d"则生成的相对路径将为"c/d"。

我们将用您的示例进行检查：

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

../../text2.txt路径是预期的，因为根据this路径(/Users/jack/Documents/text1.txt(解析产生的相对路径(../../text2.txt(产生一个路径，该路径定位与给定路径(/Users/jack/text2.txt(相同的文件：

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

Answer 2

resolve()：连接两条路径。

relativize ()：构造从文件系统中的一个位置到另一个位置的路径。

输出说明：

result1: /Users/jack/text2.txt：因为您在绝对路径中传递，所以resolve()返回路径中传递的路径，就好像它是绝对路径一样。

result2: ../../text2.txt：要从/Users/jack/Documents/text1.txt"访问/Users/jack/text2.txt，您需要向上两层，然后选择"text2.txt文件。

Answer 3

路径：：resolve - 针对此路径解析给定路径。

如果另一个参数是绝对路径，则此方法通常返回其他参数。

Path p1 = Paths.get("/usr");
Path p2 = Paths.get("/etc");
Path p3 = p1.resolve(p2); // returns /etc

如果 other 是空路径，则此方法通常返回此路径。

Path p1 = Paths.get("/usr");
Path p2 = Paths.get("");
Path p3 = p1.resolve(p2); // returns /usr

否则，此方法将此路径视为目录，并针对此路径解析给定路径。

Path p1 = Paths.get("/usr");
Path p2 = Paths.get("local");
Path p3 = p1.resolve(p2); // returns /usr/local

Path：：relativize - 构造此路径和给定路径之间的相对路径。

Path p1 = Paths.get("/usr");
Path p2 = Paths.get("/usr/local");
Path p3 = p1.relativize(p2); // returns local

这也意味着

Path p1 = Paths.get("/usr");
Path p2 = Paths.get("/usr/../usr/local");
Path p3 = p1.relativize(p2); // returns local

但是，如果两条路径相等，则返回一个空路径

Path p1 = Paths.get("/usr");
Path p2 = Paths.get("/usr/../usr");
Path p3 = p1.relativize(p2); // returns empty path

Answer 4

这些是我的代码库中的代码片段，可帮助您了解 resolve(( 方法的使用

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

这些是使用 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;
}

Answer 5

resolve(Path)是一种通过将现有路径连接到当前路径来创建新路径的方法。

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

其结果将是 ：/test1/../test2/test3

事实上，方法相对化(Path(用于构造从一个Path对象到另一个Path对象的相对路径：

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

结果将是：

..test2test3  relative path from path1 to path2
....test1     relative path from path2 to path1