将两个完全不同/不相关的绝对路径应用于nio相对化的意义何在？

Question

我了解以下 - 这对我来说很有意义：

Path path3 = Paths.get("/partA/partB"); 
    Path path4 = Paths.get("/partA/partC"); 

    System.out.println(path3.relativize(path4)); 
    System.out.println(path4.relativize(path3)); 

它打印

../partC

../partB

我明白无论partB和partC有一个共同的父文件夹，称为partA。因此，这两条路径可以在逻辑上相对化，并且../在上面的打印结果中指的是这个共同的父文件夹。

但是当我做同样的两个完全无关的绝对路径如下：

path3 = Paths.get("/xyz"); 
    path4 = Paths.get("/folder/abc"); 

    System.out.println("path3 is absolute - "+path3.isAbsolute()); 
    System.out.println("path4 is absolute - "+path4.isAbsolute()); 

    Path path3a = path3.relativize(path4); 
    System.out.println(path3a); 
    Path path4a = path4.relativize(path3); 
    System.out.println(path4a); 

我得到以下结果：

path3时，是绝对的 - 真正的

PATH4是绝对的 - true

../folder/abc

../../xyz

这没有道理给我。例如，我认为两个不相关的绝对路径可以相对化，假设它们代表本地网络中两台不同计算机的路径。

如果这种理解是正确的，那么在第一种情况下，我得到../（一个文件夹上层），但在其他情况下，我得到../../为什么（两个文件夹上） - 如果他们在这两个文件夹的绝对一个网络不应该在网络层面有共同的父母吗？也就是说，下面的结果不应该是这样吗？ ：

../folder/abc

../xyz

如果我的理解是不正确的是第二个相对化背后的逻辑（与无关的绝对路径））？这一切在现实生活中的应用是什么？什么时候可以有用？

当我将它转换为绝对路径，如下所示我迷路更：

Path path3b = path3a.toAbsolutePath(); 
    Path path4b = path4a.toAbsolutePath(); 
    Path path3c = path3b.normalize(); 
    Path path4c = path4b.normalize(); 
    System.out.println("path3a - "+path3a+" \npath4a - "+path4a); 
    System.out.println("path3b - "+path3b+" \npath4b - "+path4b); 
    System.out.println("path3c - "+path3c+" \npath4c - "+path4c); 

它打印：

path3a - ../folder/abc

path4a - ../../xyz

path3b - /Users/myMac/NetBeansProjects/OCP/../folder/abc

path4b - /Users/myMac/NetBeansProjects/OCP/../ ../ XYZ

path3c - /用户/ myMac /的NetBeansProjects /文件夹/ ABC

path4c - /用户/ myMac/XYZ

我完全失去了，因为如何在两个绝对路径走过了相对化路径被添加到我的电脑当前路径 - 不应该被转换回原来的绝对路径？我在理解纯粹逻辑和应用这一切时缺少什么？

（我的理解代码是如何工作的，我不明白，在现实生活中的情况下背后的逻辑和应用程序时，两个不相干的路径相对化）

非常感谢提前。

Answer 1

如果你从/folder/abc开始，你想要得到/xyz，你必须上升两层，然后下降一层。向上两级意味着../..和降序一意味着xyz。这就是../../xyz。

下面是当您的解决相对路径../../xyz时发生的情况，起始路径为/folder/abc。

/folder/abc + .. == /folder/abc/.. == /folder 
/folder  + .. == /folder/..  ==/
/   + xyz == /xyz 

要计算给无关联的路径B从某个路径中的相对路径，必须先到达顶层由多达..的加在一起的人数是A.这让你到/目录。然后连接B.

Answer 2

当你使用relativize时，你试图找出哪一个是你正在使用该方法的Path对象到你发送的路径作为参数的相对路径。基本上是：

from.relativize(to) 

如果from /a/b/c，并为/a/d/e然后从/a/b/c到/a/d/e相对路径是../../d/e

所以你的情况，从/xyz去/folder/abc会要求它../folder/abc中去其他方式从/folder/abc到/xyz将需要相对路径为../../xyz。

关于正常化方法，请考虑..就好像它们是上一个被访问的文件夹一样，因此，对于每个使用的..，您必须返回一个文件夹。

Answer 3

好的，由@JohnKugelman提供的解释澄清了它（我接受了这个解释，发布这个时刻我有11个声望点，而投票时我需要15个代表点，现在投票你的答案，希望稍后再做）。

基本上，我误解的主要原因是相对于路径中顶层文件夹的相对工作的假设 - 它并不完全不合逻辑，因为一旦两条路径中的顶级文件夹相对化（两者的顶级文件夹之间的映射路径已知），则可以确定从路径1中的任何文件夹到路径2中的任何文件夹的路线图。但这种理解是不正确的。

现在我得到的理解相对化适当一个需要记住两点：

1）事实证明，相对化有关作品的路径的底层（不顶层文件夹，因为我以为，所以在/ folder/abc的情况下，Java会构造相对于abc的相对路径）; 2）如fmbesteiro的回答中所述，它的工作原理是FROM.relativize（TO）;

因此，当我这样做：

path3 = Paths.get("/xyz"); 
path4 = Paths.get("/folder/abc");   
System.out.println(path3.relativize(path4)); 
System.out.println(path4.relativize(path3)); 

，并得到这个：

../folder/abc

../../xyz

在第一种情况下（从路径3到路径4），John Kugelman写道，我必须上升一级并向下两级折叠呃先，然后abc。在第二种情况下（从路径4到路径3），我必须上升两级，然后下一级到xyz。

将相对化的绝对路径重新转换为AbbsolutePath（） - 我明白这是没有意义的，没有意义，因为@EJP在上面评论中提到过（如果您使用绝对路径）。既然你已经使用了绝对路径，你已经知道它，为什么要使用toAbsolutePath（）呢 - 我试过了，因为我只是试验它，并期望得到我用于相对化的绝对路径。但是如果我有其他的东西，那就不是问题，因为我已经知道绝对路径。

我还决定分享一些我用来了解相对化和规范化的代码 - 我希望它能帮助别人。

// prepared for Mac, needs to be changed for Windows 

import java.nio.file.Path; 
import java.nio.file.Paths; 

public class nio2test { 

public static void main(String [] args) { 

    System.out.println(Paths.get("/aaaa/bbbb/cccc/./dddd").normalize()); 
    // /aaaa/bbbb/cccc/dddd 

    System.out.println(Paths.get("/aaaa/bbbb/cccc/../dddd").normalize()); 
    // /aaaa/bbbb/dddd 

    // note one dot 
    System.out.println(Paths.get("/aaaa/./bbbb/cccc/../dddd").normalize()); 
    // /aaaa/bbbb/dddd 

    System.out.println(Paths.get("/aaaa/bbbb/cccc/../../dddd").normalize()); 
    // /aaaa/dddd 
    // and so on 

    // Note the comma within get - operating system-dependent path.separator is automatically inserted between elements 
    System.out.println(Paths.get("/aaaa/.././bbbb","../cccc").normalize()); 
    // /cccc 


    System.out.println(); 
    Path currentPath4Java = Paths.get("."); 
    System.out.println("currentPath4Java    - "+currentPath4Java); 
    System.out.println("currentPath4Java (relative) - "+currentPath4Java.toAbsolutePath()); 
    System.out.println("currentPath4Java (normalised) - "+currentPath4Java.toAbsolutePath().normalize()); 

    System.out.println("this is the location in relation to which Java constructs all relative paths"); 

    } 
}