รับสองเส้นทางสัมบูรณ์เช่น
/var/data/stuff/xyz.dat
/var/data
เราจะสร้างเส้นทางสัมพัทธ์ที่ใช้เส้นทางที่สองเป็นฐานได้อย่างไร ในตัวอย่างด้านบนผลลัพธ์ควรเป็น:./stuff/xyz.dat
รับสองเส้นทางสัมบูรณ์เช่น
/var/data/stuff/xyz.dat
/var/data
เราจะสร้างเส้นทางสัมพัทธ์ที่ใช้เส้นทางที่สองเป็นฐานได้อย่างไร ในตัวอย่างด้านบนผลลัพธ์ควรเป็น:./stuff/xyz.dat
คำตอบ:
มันเป็นวงเวียนเล็ก ๆ แต่ทำไมไม่ใช้ URI มันมีวิธีการ relativize ซึ่งจะทำการตรวจสอบที่จำเป็นทั้งหมดสำหรับคุณ
String path = "/var/data/stuff/xyz.dat";
String base = "/var/data";
String relative = new File(base).toURI().relativize(new File(path).toURI()).getPath();
// relative == "stuff/xyz.dat"
โปรดทราบว่าเส้นทางของไฟล์มีjava.nio.file.Path#relativize
ตั้งแต่ Java 1.7 เป็นออกแหลมโดย@Jirka Meluzinในคำตอบอื่น ๆ
java.nio.file.Path#relativize(Path)
มันใช้ได้กับผู้ปกครองจุดคู่และทั้งหมด
toPath()
toURI()
มันสามารถสร้างสิ่งต่าง ๆ ได้อย่าง"..\.."
สมบูรณ์แบบ แต่ต้องตระหนักถึงjava.lang.IllegalArgumentException: 'other' has different root
ข้อยกเว้นเมื่อขอเส้นทางญาติจากไป"C:\temp"
"D:\temp"
ตั้งแต่ Java 7 คุณสามารถใช้วิธีrelativize :
import java.nio.file.Path;
import java.nio.file.Paths;
public class Test {
public static void main(String[] args) {
Path pathAbsolute = Paths.get("/var/data/stuff/xyz.dat");
Path pathBase = Paths.get("/var/data");
Path pathRelative = pathBase.relativize(pathAbsolute);
System.out.println(pathRelative);
}
}
เอาท์พุท:
stuff/xyz.dat
..
เมื่อจำเป็น (ไม่)
java.nio.file
:(
pathBase.normalize().relativize(pathAbsolute);
ตามกฎทั่วไป
ในช่วงเวลาของการเขียน (มิถุนายน 2010) นี่เป็นทางออกเดียวที่ผ่านกรณีทดสอบของฉัน ฉันไม่สามารถรับประกันได้ว่าวิธีนี้จะปราศจากข้อผิดพลาด แต่มันผ่านการทดสอบรวมกรณี วิธีการและการทดสอบที่ฉันเขียนขึ้นอยู่กับFilenameUtils
คลาสจากApacheทั่วไป
โซลูชันได้รับการทดสอบด้วย Java 1.4 หากคุณใช้ Java 1.5 (หรือสูงกว่า) คุณควรพิจารณาแทนที่StringBuffer
ด้วยStringBuilder
(หากคุณยังคงใช้ Java 1.4 คุณควรพิจารณาเปลี่ยนนายจ้างแทน)
import java.io.File;
import java.util.regex.Pattern;
import org.apache.commons.io.FilenameUtils;
public class ResourceUtils {
/**
* Get the relative path from one file to another, specifying the directory separator.
* If one of the provided resources does not exist, it is assumed to be a file unless it ends with '/' or
* '\'.
*
* @param targetPath targetPath is calculated to this file
* @param basePath basePath is calculated from this file
* @param pathSeparator directory separator. The platform default is not assumed so that we can test Unix behaviour when running on Windows (for example)
* @return
*/
public static String getRelativePath(String targetPath, String basePath, String pathSeparator) {
// Normalize the paths
String normalizedTargetPath = FilenameUtils.normalizeNoEndSeparator(targetPath);
String normalizedBasePath = FilenameUtils.normalizeNoEndSeparator(basePath);
// Undo the changes to the separators made by normalization
if (pathSeparator.equals("/")) {
normalizedTargetPath = FilenameUtils.separatorsToUnix(normalizedTargetPath);
normalizedBasePath = FilenameUtils.separatorsToUnix(normalizedBasePath);
} else if (pathSeparator.equals("\\")) {
normalizedTargetPath = FilenameUtils.separatorsToWindows(normalizedTargetPath);
normalizedBasePath = FilenameUtils.separatorsToWindows(normalizedBasePath);
} else {
throw new IllegalArgumentException("Unrecognised dir separator '" + pathSeparator + "'");
}
String[] base = normalizedBasePath.split(Pattern.quote(pathSeparator));
String[] target = normalizedTargetPath.split(Pattern.quote(pathSeparator));
// First get all the common elements. Store them as a string,
// and also count how many of them there are.
StringBuffer common = new StringBuffer();
int commonIndex = 0;
while (commonIndex < target.length && commonIndex < base.length
&& target[commonIndex].equals(base[commonIndex])) {
common.append(target[commonIndex] + pathSeparator);
commonIndex++;
}
if (commonIndex == 0) {
// No single common path element. This most
// likely indicates differing drive letters, like C: and D:.
// These paths cannot be relativized.
throw new PathResolutionException("No common path element found for '" + normalizedTargetPath + "' and '" + normalizedBasePath
+ "'");
}
// The number of directories we have to backtrack depends on whether the base is a file or a dir
// For example, the relative path from
//
// /foo/bar/baz/gg/ff to /foo/bar/baz
//
// ".." if ff is a file
// "../.." if ff is a directory
//
// The following is a heuristic to figure out if the base refers to a file or dir. It's not perfect, because
// the resource referred to by this path may not actually exist, but it's the best I can do
boolean baseIsFile = true;
File baseResource = new File(normalizedBasePath);
if (baseResource.exists()) {
baseIsFile = baseResource.isFile();
} else if (basePath.endsWith(pathSeparator)) {
baseIsFile = false;
}
StringBuffer relative = new StringBuffer();
if (base.length != commonIndex) {
int numDirsUp = baseIsFile ? base.length - commonIndex - 1 : base.length - commonIndex;
for (int i = 0; i < numDirsUp; i++) {
relative.append(".." + pathSeparator);
}
}
relative.append(normalizedTargetPath.substring(common.length()));
return relative.toString();
}
static class PathResolutionException extends RuntimeException {
PathResolutionException(String msg) {
super(msg);
}
}
}
กรณีทดสอบที่ผ่านนี้คือ
public void testGetRelativePathsUnix() {
assertEquals("stuff/xyz.dat", ResourceUtils.getRelativePath("/var/data/stuff/xyz.dat", "/var/data/", "/"));
assertEquals("../../b/c", ResourceUtils.getRelativePath("/a/b/c", "/a/x/y/", "/"));
assertEquals("../../b/c", ResourceUtils.getRelativePath("/m/n/o/a/b/c", "/m/n/o/a/x/y/", "/"));
}
public void testGetRelativePathFileToFile() {
String target = "C:\\Windows\\Boot\\Fonts\\chs_boot.ttf";
String base = "C:\\Windows\\Speech\\Common\\sapisvr.exe";
String relPath = ResourceUtils.getRelativePath(target, base, "\\");
assertEquals("..\\..\\Boot\\Fonts\\chs_boot.ttf", relPath);
}
public void testGetRelativePathDirectoryToFile() {
String target = "C:\\Windows\\Boot\\Fonts\\chs_boot.ttf";
String base = "C:\\Windows\\Speech\\Common\\";
String relPath = ResourceUtils.getRelativePath(target, base, "\\");
assertEquals("..\\..\\Boot\\Fonts\\chs_boot.ttf", relPath);
}
public void testGetRelativePathFileToDirectory() {
String target = "C:\\Windows\\Boot\\Fonts";
String base = "C:\\Windows\\Speech\\Common\\foo.txt";
String relPath = ResourceUtils.getRelativePath(target, base, "\\");
assertEquals("..\\..\\Boot\\Fonts", relPath);
}
public void testGetRelativePathDirectoryToDirectory() {
String target = "C:\\Windows\\Boot\\";
String base = "C:\\Windows\\Speech\\Common\\";
String expected = "..\\..\\Boot";
String relPath = ResourceUtils.getRelativePath(target, base, "\\");
assertEquals(expected, relPath);
}
public void testGetRelativePathDifferentDriveLetters() {
String target = "D:\\sources\\recovery\\RecEnv.exe";
String base = "C:\\Java\\workspace\\AcceptanceTests\\Standard test data\\geo\\";
try {
ResourceUtils.getRelativePath(target, base, "\\");
fail();
} catch (PathResolutionException ex) {
// expected exception
}
}
เมื่อใช้ java.net.URI.relativize คุณควรระวัง Java bug: JDK-6226081 (URI ควรจะสัมพันธ์กับ path ด้วย root บางส่วน)
ในขณะนี้
relativize()
วิธีการURI
จะให้ความสำคัญกับ URI เมื่อหนึ่งเป็นคำนำหน้าของอีก
ซึ่งหมายความว่าjava.net.URI.relativize
จะไม่สร้าง ".. " สำหรับคุณ
URIUtils.resolve()
กล่าวถึง JDK-4708535 และจากซอร์สโค้ดฉันไม่เห็นอะไรที่เกี่ยวข้องกับการย้อนรอย (เช่น..
ส่วน) คุณสับสนข้อผิดพลาดสองข้อหรือไม่?
ข้อผิดพลาดที่อ้างถึงในคำตอบอื่นได้รับการแก้ไขโดยURIUtilsในApache HttpComponents
public static URI resolve(URI baseURI,
String reference)
แก้ไขการอ้างอิง URI กับ URI ฐาน แก้ไขข้อผิดพลาดใน java.net.URI ()
ในJava 7และใหม่กว่าคุณสามารถใช้ (และในทางตรงกันข้ามURI
มันไม่มีข้อบกพร่อง):
Path#relativize(Path)
หากคุณรู้ว่าสตริงที่สองเป็นส่วนหนึ่งของสตริงแรก:
String s1 = "/var/data/stuff/xyz.dat";
String s2 = "/var/data";
String s3 = s1.substring(s2.length());
หรือถ้าคุณต้องการให้ช่วงเวลาเป็นจุดเริ่มต้นตามตัวอย่าง:
String s3 = ".".concat(s1.substring(s2.length()));
การเรียกซ้ำผลิตโซลูชันที่เล็กกว่า สิ่งนี้จะส่งข้อยกเว้นหากผลลัพธ์เป็นไปไม่ได้ (เช่นดิสก์ Windows อื่น) หรือทำไม่ได้ (รูทเป็นไดเรกทอรีทั่วไปเท่านั้น)
/**
* Computes the path for a file relative to a given base, or fails if the only shared
* directory is the root and the absolute form is better.
*
* @param base File that is the base for the result
* @param name File to be "relativized"
* @return the relative name
* @throws IOException if files have no common sub-directories, i.e. at best share the
* root prefix "/" or "C:\"
*/
public static String getRelativePath(File base, File name) throws IOException {
File parent = base.getParentFile();
if (parent == null) {
throw new IOException("No common directory");
}
String bpath = base.getCanonicalPath();
String fpath = name.getCanonicalPath();
if (fpath.startsWith(bpath)) {
return fpath.substring(bpath.length() + 1);
} else {
return (".." + File.separator + getRelativePath(parent, name));
}
}
นี่เป็นวิธีแก้ปัญหาห้องสมุดอื่น ๆ ฟรี:
Path sourceFile = Paths.get("some/common/path/example/a/b/c/f1.txt");
Path targetFile = Paths.get("some/common/path/example/d/e/f2.txt");
Path relativePath = sourceFile.relativize(targetFile);
System.out.println(relativePath);
เอาท์พุท
..\..\..\..\d\e\f2.txt
[แก้ไข] จริงแล้วมันส่งออกมากกว่า .. \ เพราะแหล่งที่มาไม่ใช่ไฟล์ ทางออกที่ถูกต้องสำหรับเคสของฉันคือ:
Path sourceFile = Paths.get(new File("some/common/path/example/a/b/c/f1.txt").parent());
Path targetFile = Paths.get("some/common/path/example/d/e/f2.txt");
Path relativePath = sourceFile.relativize(targetFile);
System.out.println(relativePath);
เวอร์ชันของฉันหลวมตามรุ่นของMattและSteve :
/**
* Returns the path of one File relative to another.
*
* @param target the target directory
* @param base the base directory
* @return target's path relative to the base directory
* @throws IOException if an error occurs while resolving the files' canonical names
*/
public static File getRelativeFile(File target, File base) throws IOException
{
String[] baseComponents = base.getCanonicalPath().split(Pattern.quote(File.separator));
String[] targetComponents = target.getCanonicalPath().split(Pattern.quote(File.separator));
// skip common components
int index = 0;
for (; index < targetComponents.length && index < baseComponents.length; ++index)
{
if (!targetComponents[index].equals(baseComponents[index]))
break;
}
StringBuilder result = new StringBuilder();
if (index != baseComponents.length)
{
// backtrack to base directory
for (int i = index; i < baseComponents.length; ++i)
result.append(".." + File.separator);
}
for (; index < targetComponents.length; ++index)
result.append(targetComponents[index] + File.separator);
if (!target.getPath().endsWith("/") && !target.getPath().endsWith("\\"))
{
// remove final path separator
result.delete(result.length() - File.separator.length(), result.length());
}
return new File(result.toString());
}
"/".length()
ใช้ตัวคั่นคุณควรใช้ตัวคั่นความยาว
วิธีการแก้ปัญหาของ Matt B ทำให้จำนวนไดเรกทอรีย้อนรอยผิด - ควรเป็นความยาวของเส้นทางพื้นฐานลบด้วยจำนวนองค์ประกอบทางเดินทั่วไปลบหนึ่ง (สำหรับองค์ประกอบเส้นทางสุดท้ายซึ่งเป็นชื่อไฟล์หรือตามรอยที่""
สร้างขึ้นsplit
) . มันเกิดขึ้นกับการทำงานกับ/a/b/c/
และ/a/x/y/
แต่แทนที่ข้อโต้แย้งด้วย/m/n/o/a/b/c/
และ/m/n/o/a/x/y/
และคุณจะเห็นปัญหา
นอกจากนี้ยังต้องการelse break
ภายในวงแรกสำหรับการวนซ้ำหรือมันจะผิดพลาดเส้นทางที่เกิดขึ้นจะมีชื่อไดเรกทอรีที่ตรงกันเช่น/a/b/c/d/
และ/x/y/c/z
- ที่c
อยู่ในช่องเดียวกันในทั้งสองอาร์เรย์ แต่ไม่ตรงกับที่เกิดขึ้นจริง
การแก้ปัญหาทั้งหมดเหล่านี้ขาดความสามารถในการจัดการเส้นทางที่ไม่สามารถ relativized กับอีกคนหนึ่งเพราะพวกเขามีรากเข้ากันไม่ได้เช่นและC:\foo\bar
D:\baz\quux
อาจเป็นเพียงปัญหาใน Windows แต่น่าสังเกต
ฉันใช้เวลานานกว่านี้กับที่ตั้งใจไว้ แต่ก็ไม่เป็นไร ฉันต้องการสิ่งนี้จริงๆสำหรับการทำงานดังนั้นขอขอบคุณทุกคนที่ chimed และฉันแน่ใจว่าจะมีการแก้ไขในเวอร์ชันนี้ด้วย!
public static String getRelativePath(String targetPath, String basePath,
String pathSeparator) {
// We need the -1 argument to split to make sure we get a trailing
// "" token if the base ends in the path separator and is therefore
// a directory. We require directory paths to end in the path
// separator -- otherwise they are indistinguishable from files.
String[] base = basePath.split(Pattern.quote(pathSeparator), -1);
String[] target = targetPath.split(Pattern.quote(pathSeparator), 0);
// First get all the common elements. Store them as a string,
// and also count how many of them there are.
String common = "";
int commonIndex = 0;
for (int i = 0; i < target.length && i < base.length; i++) {
if (target[i].equals(base[i])) {
common += target[i] + pathSeparator;
commonIndex++;
}
else break;
}
if (commonIndex == 0)
{
// Whoops -- not even a single common path element. This most
// likely indicates differing drive letters, like C: and D:.
// These paths cannot be relativized. Return the target path.
return targetPath;
// This should never happen when all absolute paths
// begin with / as in *nix.
}
String relative = "";
if (base.length == commonIndex) {
// Comment this out if you prefer that a relative path not start with ./
//relative = "." + pathSeparator;
}
else {
int numDirsUp = base.length - commonIndex - 1;
// The number of directories we have to backtrack is the length of
// the base path MINUS the number of common path elements, minus
// one because the last element in the path isn't a directory.
for (int i = 1; i <= (numDirsUp); i++) {
relative += ".." + pathSeparator;
}
}
relative += targetPath.substring(common.length());
return relative;
}
และนี่คือการทดสอบเพื่อครอบคลุมหลายกรณี:
public void testGetRelativePathsUnixy()
{
assertEquals("stuff/xyz.dat", FileUtils.getRelativePath(
"/var/data/stuff/xyz.dat", "/var/data/", "/"));
assertEquals("../../b/c", FileUtils.getRelativePath(
"/a/b/c", "/a/x/y/", "/"));
assertEquals("../../b/c", FileUtils.getRelativePath(
"/m/n/o/a/b/c", "/m/n/o/a/x/y/", "/"));
}
public void testGetRelativePathFileToFile()
{
String target = "C:\\Windows\\Boot\\Fonts\\chs_boot.ttf";
String base = "C:\\Windows\\Speech\\Common\\sapisvr.exe";
String relPath = FileUtils.getRelativePath(target, base, "\\");
assertEquals("..\\..\\..\\Boot\\Fonts\\chs_boot.ttf", relPath);
}
public void testGetRelativePathDirectoryToFile()
{
String target = "C:\\Windows\\Boot\\Fonts\\chs_boot.ttf";
String base = "C:\\Windows\\Speech\\Common";
String relPath = FileUtils.getRelativePath(target, base, "\\");
assertEquals("..\\..\\Boot\\Fonts\\chs_boot.ttf", relPath);
}
public void testGetRelativePathDifferentDriveLetters()
{
String target = "D:\\sources\\recovery\\RecEnv.exe";
String base = "C:\\Java\\workspace\\AcceptanceTests\\Standard test data\\geo\\";
// Should just return the target path because of the incompatible roots.
String relPath = FileUtils.getRelativePath(target, base, "\\");
assertEquals(target, relPath);
}
ที่จริงแล้วคำตอบอื่น ๆ ของฉันไม่ได้ผลถ้าเส้นทางเป้าหมายไม่ใช่ลูกของเส้นทางพื้นฐาน
สิ่งนี้น่าจะใช้ได้
public class RelativePathFinder {
public static String getRelativePath(String targetPath, String basePath,
String pathSeparator) {
// find common path
String[] target = targetPath.split(pathSeparator);
String[] base = basePath.split(pathSeparator);
String common = "";
int commonIndex = 0;
for (int i = 0; i < target.length && i < base.length; i++) {
if (target[i].equals(base[i])) {
common += target[i] + pathSeparator;
commonIndex++;
}
}
String relative = "";
// is the target a child directory of the base directory?
// i.e., target = /a/b/c/d, base = /a/b/
if (commonIndex == base.length) {
relative = "." + pathSeparator + targetPath.substring(common.length());
}
else {
// determine how many directories we have to backtrack
for (int i = 1; i <= commonIndex; i++) {
relative += ".." + pathSeparator;
}
relative += targetPath.substring(common.length());
}
return relative;
}
public static String getRelativePath(String targetPath, String basePath) {
return getRelativePath(targetPath, basePath, File.pathSeparator);
}
}
public class RelativePathFinderTest extends TestCase {
public void testGetRelativePath() {
assertEquals("./stuff/xyz.dat", RelativePathFinder.getRelativePath(
"/var/data/stuff/xyz.dat", "/var/data/", "/"));
assertEquals("../../b/c", RelativePathFinder.getRelativePath("/a/b/c",
"/a/x/y/", "/"));
}
}
เย็น!! ฉันต้องการรหัสเล็กน้อยเช่นนี้ แต่เพื่อเปรียบเทียบเส้นทางไดเรกทอรีบนเครื่อง Linux ฉันพบว่าสิ่งนี้ไม่ทำงานในสถานการณ์ที่ไดเรกทอรีหลักเป็นเป้าหมาย
นี่เป็นวิธีที่เป็นมิตรกับไดเรกทอรีรุ่น:
public static String getRelativePath(String targetPath, String basePath,
String pathSeparator) {
boolean isDir = false;
{
File f = new File(targetPath);
isDir = f.isDirectory();
}
// We need the -1 argument to split to make sure we get a trailing
// "" token if the base ends in the path separator and is therefore
// a directory. We require directory paths to end in the path
// separator -- otherwise they are indistinguishable from files.
String[] base = basePath.split(Pattern.quote(pathSeparator), -1);
String[] target = targetPath.split(Pattern.quote(pathSeparator), 0);
// First get all the common elements. Store them as a string,
// and also count how many of them there are.
String common = "";
int commonIndex = 0;
for (int i = 0; i < target.length && i < base.length; i++) {
if (target[i].equals(base[i])) {
common += target[i] + pathSeparator;
commonIndex++;
}
else break;
}
if (commonIndex == 0)
{
// Whoops -- not even a single common path element. This most
// likely indicates differing drive letters, like C: and D:.
// These paths cannot be relativized. Return the target path.
return targetPath;
// This should never happen when all absolute paths
// begin with / as in *nix.
}
String relative = "";
if (base.length == commonIndex) {
// Comment this out if you prefer that a relative path not start with ./
relative = "." + pathSeparator;
}
else {
int numDirsUp = base.length - commonIndex - (isDir?0:1); /* only subtract 1 if it is a file. */
// The number of directories we have to backtrack is the length of
// the base path MINUS the number of common path elements, minus
// one because the last element in the path isn't a directory.
for (int i = 1; i <= (numDirsUp); i++) {
relative += ".." + pathSeparator;
}
}
//if we are comparing directories then we
if (targetPath.length() > common.length()) {
//it's OK, it isn't a directory
relative += targetPath.substring(common.length());
}
return relative;
}
ฉันสมมติว่าคุณมีfromPath (พา ธ สัมบูรณ์สำหรับโฟลเดอร์) และtoPath (พา ธ สัมบูรณ์สำหรับโฟลเดอร์ / ไฟล์) และคุณกำลังมองหาพา ธ ที่มีไฟล์ / โฟลเดอร์ในtoPathเป็นพา ธ สัมพัทธ์ from fromPath (ไดเรกทอรีการทำงานปัจจุบันของคุณคือfromPath ) ดังนั้นสิ่งนี้ควรใช้งานได้:
public static String getRelativePath(String fromPath, String toPath) {
// This weirdness is because a separator of '/' messes with String.split()
String regexCharacter = File.separator;
if (File.separatorChar == '\\') {
regexCharacter = "\\\\";
}
String[] fromSplit = fromPath.split(regexCharacter);
String[] toSplit = toPath.split(regexCharacter);
// Find the common path
int common = 0;
while (fromSplit[common].equals(toSplit[common])) {
common++;
}
StringBuffer result = new StringBuffer(".");
// Work your way up the FROM path to common ground
for (int i = common; i < fromSplit.length; i++) {
result.append(File.separatorChar).append("..");
}
// Work your way down the TO path
for (int i = common; i < toSplit.length; i++) {
result.append(File.separatorChar).append(toSplit[i]);
}
return result.toString();
}
มีคำตอบมากมายที่นี่ แต่ฉันพบว่าพวกเขาไม่ได้จัดการทุกกรณีเช่นฐานและเป้าหมายเหมือนกัน ฟังก์ชั่นนี้ใช้เวลาไดเรกทอรีฐานและเส้นทางเป้าหมายและส่งกลับเส้นทางญาติ หากไม่มีเส้นทางสัมพัทธ์อยู่เส้นทางเป้าหมายจะถูกส่งคืน File.separator ไม่จำเป็น
public static String getRelativePath (String baseDir, String targetPath) {
String[] base = baseDir.replace('\\', '/').split("\\/");
targetPath = targetPath.replace('\\', '/');
String[] target = targetPath.split("\\/");
// Count common elements and their length.
int commonCount = 0, commonLength = 0, maxCount = Math.min(target.length, base.length);
while (commonCount < maxCount) {
String targetElement = target[commonCount];
if (!targetElement.equals(base[commonCount])) break;
commonCount++;
commonLength += targetElement.length() + 1; // Directory name length plus slash.
}
if (commonCount == 0) return targetPath; // No common path element.
int targetLength = targetPath.length();
int dirsUp = base.length - commonCount;
StringBuffer relative = new StringBuffer(dirsUp * 3 + targetLength - commonLength + 1);
for (int i = 0; i < dirsUp; i++)
relative.append("../");
if (commonLength < targetLength) relative.append(targetPath.substring(commonLength));
return relative.toString();
}
ต่อไปนี้เป็นวิธีการแก้ไขพา ธ สัมพัทธ์จากพา ธ ฐานโดยไม่คำนึงถึงว่าอยู่ในรูทเดียวกันหรือต่างรูท:
public static String GetRelativePath(String path, String base){
final String SEP = "/";
// if base is not a directory -> return empty
if (!base.endsWith(SEP)){
return "";
}
// check if path is a file -> remove last "/" at the end of the method
boolean isfile = !path.endsWith(SEP);
// get URIs and split them by using the separator
String a = "";
String b = "";
try {
a = new File(base).getCanonicalFile().toURI().getPath();
b = new File(path).getCanonicalFile().toURI().getPath();
} catch (IOException e) {
e.printStackTrace();
}
String[] basePaths = a.split(SEP);
String[] otherPaths = b.split(SEP);
// check common part
int n = 0;
for(; n < basePaths.length && n < otherPaths.length; n ++)
{
if( basePaths[n].equals(otherPaths[n]) == false )
break;
}
// compose the new path
StringBuffer tmp = new StringBuffer("");
for(int m = n; m < basePaths.length; m ++)
tmp.append(".."+SEP);
for(int m = n; m < otherPaths.length; m ++)
{
tmp.append(otherPaths[m]);
tmp.append(SEP);
}
// get path string
String result = tmp.toString();
// remove last "/" if path is a file
if (isfile && result.endsWith(SEP)){
result = result.substring(0,result.length()-1);
}
return result;
}
ผ่านการทดสอบของDónalการเปลี่ยนแปลงเพียงอย่างเดียว - หากไม่มีรูททั่วไปที่จะส่งคืนพา ธ เป้าหมาย (มันอาจจะสัมพันธ์กันอยู่แล้ว)
import static java.util.Arrays.asList;
import static java.util.Collections.nCopies;
import static org.apache.commons.io.FilenameUtils.normalizeNoEndSeparator;
import static org.apache.commons.io.FilenameUtils.separatorsToUnix;
import static org.apache.commons.lang3.StringUtils.getCommonPrefix;
import static org.apache.commons.lang3.StringUtils.isBlank;
import static org.apache.commons.lang3.StringUtils.isNotEmpty;
import static org.apache.commons.lang3.StringUtils.join;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
public class ResourceUtils {
public static String getRelativePath(String targetPath, String basePath, String pathSeparator) {
File baseFile = new File(basePath);
if (baseFile.isFile() || !baseFile.exists() && !basePath.endsWith("/") && !basePath.endsWith("\\"))
basePath = baseFile.getParent();
String target = separatorsToUnix(normalizeNoEndSeparator(targetPath));
String base = separatorsToUnix(normalizeNoEndSeparator(basePath));
String commonPrefix = getCommonPrefix(target, base);
if (isBlank(commonPrefix))
return targetPath.replaceAll("/", pathSeparator);
target = target.replaceFirst(commonPrefix, "");
base = base.replaceFirst(commonPrefix, "");
List<String> result = new ArrayList<>();
if (isNotEmpty(base))
result.addAll(nCopies(base.split("/").length, ".."));
result.addAll(asList(target.replaceFirst("^/", "").split("/")));
return join(result, pathSeparator);
}
}
หากคุณกำลังเขียนปลั๊กอิน Maven คุณสามารถใช้Plexus 'PathTool
:
import org.codehaus.plexus.util.PathTool;
String relativeFilePath = PathTool.getRelativeFilePath(file1, file2);
หาก Paths ไม่พร้อมใช้งานสำหรับ JRE 1.5 runtime หรือปลั๊กอิน maven
package org.afc.util;
import java.io.File;
import java.util.LinkedList;
import java.util.List;
public class FileUtil {
public static String getRelativePath(String basePath, String filePath) {
return getRelativePath(new File(basePath), new File(filePath));
}
public static String getRelativePath(File base, File file) {
List<String> bases = new LinkedList<String>();
bases.add(0, base.getName());
for (File parent = base.getParentFile(); parent != null; parent = parent.getParentFile()) {
bases.add(0, parent.getName());
}
List<String> files = new LinkedList<String>();
files.add(0, file.getName());
for (File parent = file.getParentFile(); parent != null; parent = parent.getParentFile()) {
files.add(0, parent.getName());
}
int overlapIndex = 0;
while (overlapIndex < bases.size() && overlapIndex < files.size() && bases.get(overlapIndex).equals(files.get(overlapIndex))) {
overlapIndex++;
}
StringBuilder relativePath = new StringBuilder();
for (int i = overlapIndex; i < bases.size(); i++) {
relativePath.append("..").append(File.separatorChar);
}
for (int i = overlapIndex; i < files.size(); i++) {
relativePath.append(files.get(i)).append(File.separatorChar);
}
relativePath.deleteCharAt(relativePath.length() - 1);
return relativePath.toString();
}
}
org.apache.ant มีคลาส FileUtils พร้อมเมธอด getRelativePath ยังไม่ได้ลองด้วยตัวเอง แต่อาจคุ้มค่าที่จะลองดู
http://javadoc.haefelinger.it/org.apache.ant/1.7.1/org/apache/tools/ant/util/FileUtils.html#getRelativePath(java.io.File , java.io.File)
private String relative(String left, String right){
String[] lefts = left.split("/");
String[] rights = right.split("/");
int min = Math.min(lefts.length, rights.length);
int commonIdx = -1;
for(int i = 0; i < min; i++){
if(commonIdx < 0 && !lefts[i].equals(rights[i])){
commonIdx = i - 1;
break;
}
}
if(commonIdx < 0){
return null;
}
StringBuilder sb = new StringBuilder(Math.max(left.length(), right.length()));
sb.append(left).append("/");
for(int i = commonIdx + 1; i < lefts.length;i++){
sb.append("../");
}
for(int i = commonIdx + 1; i < rights.length;i++){
sb.append(rights[i]).append("/");
}
return sb.deleteCharAt(sb.length() -1).toString();
}
หลอกรหัส:
return "." + whicheverPathIsLonger.substring(commonPath.length);