Java File.getCanonicalPath方法代码示例

import java.io.File; //导入方法依赖的package包/类
public void initialize(String rootDirName) throws RuntimeException, IOException {
    String jFluidNativeLibFullName = Platform.getAgentNativeLibFullName(rootDirName, false, null, -1);

    String jFluidNativeLibDirName = jFluidNativeLibFullName.substring(0, jFluidNativeLibFullName.lastIndexOf('/')); // NOI18N

    String checkedPath = ""; // NOI18N   // Needed only for error reporting

    try {
        File rootDir = MiscUtils.checkDirForName(checkedPath = rootDirName);
        MiscUtils.checkDirForName(checkedPath = jFluidNativeLibDirName);
        MiscUtils.checkFile(new File(checkedPath = jFluidNativeLibFullName), false);

        jFluidRootDirName = rootDir.getCanonicalPath();
    } catch (IOException e) {
        throw new IOException("Problem with a required JFluid installation directory or file " + checkedPath, e);
    }
}
 

import java.io.File; //导入方法依赖的package包/类
private static String getFileText(File file) {
	if (file == null) {
		return Strings.get("fileOpenRecentNoChoices");
	} else {
		String ret;
		try {
			ret = file.getCanonicalPath();
		} catch (IOException e) {
			ret = file.toString();
		}
		if (ret.length() <= MAX_ITEM_LENGTH) {
			return ret;
		} else {
			ret = ret.substring(ret.length() - MAX_ITEM_LENGTH + 3);
			int splitLoc = ret.indexOf(File.separatorChar);
			if (splitLoc >= 0) {
				ret = ret.substring(splitLoc);
			}
			return "..." + ret;
		}
	}
}
 

import java.io.File; //导入方法依赖的package包/类
private static Collection<String> getResourcesFromDirectory(
        final File directory,
        final Pattern pattern) {
    final ArrayList<String> retval = new ArrayList<>();
    final File[] fileList = directory.listFiles();
    for (final File file : fileList) {
        if (file.isDirectory()) {
            retval.addAll(getResourcesFromDirectory(file, pattern));
        } else {
            try {
                final String fileName = file.getCanonicalPath();
                final boolean accept = pattern.matcher(fileName).matches();
                if (accept) {
                    retval.add(fileName);
                }
            } catch (final IOException e) {
                throw new Error(e);
            }
        }
    }
    return retval;
}
 

import java.io.File; //导入方法依赖的package包/类
@Override public void process(Commandline args) throws ShellCommandException {
    checkArgsSize(args, 0);

    beginReadTransaction();

    try {
        File outDir = new File(".", "dump");
        if (! outDir.exists()) {
            outDir.mkdir();
        } else if (! outDir.isDirectory()) {
            throw new ShellCommandException("出力先エラー: " + outDir.getCanonicalPath());
        }

        for (UiTypeName typename : SkeltonTefService.instance().uiTypeNames().instances()) {
            dump(outDir, typename);
        }
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    }
}
 

import java.io.File; //导入方法依赖的package包/类
/**
 * 这个方法可以通过与某个类的class文件的相对路径来获取文件或目录的绝对路径。 通常在程序中很难定位某个相对路径，特别是在B/S应用中。
 * 通过这个方法，我们可以根据我们程序自身的类文件的位置来定位某个相对路径。
 * 比如：某个txt文件相对于程序的Test类文件的路径是../../resource/test.txt，
 * 那么使用本方法Path.getFullPathRelateClass("../../resource/test.txt",Test.class)
 * 得到的结果是txt文件的在系统中的绝对路径。
 * 
 * @param relatedPath 相对路径
 * @param cls 用来定位的类
 * @return 相对路径所对应的绝对路径
 * @throws IOException 因为本方法将查询文件系统，所以可能抛出IO异常
 */
public static final String getFullPathRelateClass(String relatedPath, Class<?> cls) {
	String path = null;
	if (relatedPath == null) {
		throw new NullPointerException();
	}
	String clsPath = getPathFromClass(cls);
	File clsFile = new File(clsPath);
	String tempPath = clsFile.getParent() + File.separator + relatedPath;
	File file = new File(tempPath);
	try {
		path = file.getCanonicalPath();
	} catch (IOException e) {
		e.printStackTrace();
	}
	return path;
}
 

import java.io.File; //导入方法依赖的package包/类
@ApiMethod
public static boolean copy(File srcDir, File srcFile, File dstDir)
{
   try
   {
      String dest = srcFile.getCanonicalPath();
      dest = dest.substring(srcDir.getCanonicalPath().length(), dest.length());
      if (dest.startsWith("/") || dest.startsWith("\\"))
      {
         dest = dest.substring(1, dest.length());
      }

      File dstFile = new File(dstDir, dest);
      return copyFile(srcFile, dstFile);
   }
   catch (Exception ex)
   {
      Lang.rethrow(ex);
   }
   return false;
}
 

import java.io.File; //导入方法依赖的package包/类
public void produceAdditionalOutput() {
    File swanVisualizerExe = visualizerConfig.getVisualizerExe();
    File swivtPresentationSettingsFile = visualizerConfig.getPresentationSettingsDirectory();
    File outputDir = visualizerConfig.getOutputDirectory();
    System.out.println("SWIVT OUT:\n\t" + swanVisualizerExe.getAbsolutePath() + "\n\t" +
            swivtPresentationSettingsFile.getAbsolutePath() + "\n\t" +
            outputDir.getAbsolutePath());
    try {
        String dirSep = File.separator;
        String[] arguments = new String[]{
                swanVisualizerExe.getParentFile().getCanonicalPath() + dirSep,
                swivtPresentationSettingsFile.getCanonicalPath() + dirSep,   // TODO:  + dirSep for Swivt 2.0
                visualizerConfig.getObservationDirectory().getCanonicalPath() + dirSep,
                visualizerConfig.getModelDirectory().getCanonicalPath() + dirSep,
                visualizerConfig.getOutputDirectory().getCanonicalPath() + dirSep
        };
        BBUtils.runExecutable(swanVisualizerExe.getAbsolutePath(), swanVisualizerExe.getParentFile(), arguments);
    } catch (IOException e) {
        throw new RuntimeException("Could not run " + swanVisualizerExe.getAbsolutePath());
    }
}
 

import java.io.File; //导入方法依赖的package包/类
@Test
public void testLoggingWrongFileType() throws Exception {
    File log4jFile = createLog4jFile(LOG4J_CONFIG1);
    try {
        // Set path of log4j properties
        String log4jPath = log4jFile.getCanonicalPath();
        setSysSetting(log4jPath);

        // Invoke "private" method :)
        Method method = testElm.getClass().getDeclaredMethod(
                "postConstruct");
        method.setAccessible(true);
        method.invoke(testElm);

    } finally {
        log4jFile.delete();
        resetSysSetting();
    }

}
 

import java.io.File; //导入方法依赖的package包/类
private boolean validateContextPath(File appBase, String contextPath) {
    // More complicated than the ideal as the canonical path may or may
    // not end with File.separator for a directory

    StringBuilder docBase;
    String canonicalDocBase = null;

    try {
        String canonicalAppBase = appBase.getCanonicalPath();
        docBase = new StringBuilder(canonicalAppBase);
        if (canonicalAppBase.endsWith(File.separator)) {
            docBase.append(contextPath.substring(1).replace(
                    '/', File.separatorChar));
        } else {
            docBase.append(contextPath.replace('/', File.separatorChar));
        }
        // At this point docBase should be canonical but will not end
        // with File.separator

        canonicalDocBase =
            (new File(docBase.toString())).getCanonicalPath();

        // If the canonicalDocBase ends with File.separator, add one to
        // docBase before they are compared
        if (canonicalDocBase.endsWith(File.separator)) {
            docBase.append(File.separator);
        }
    } catch (IOException ioe) {
        return false;
    }

    // Compare the two. If they are not the same, the contextPath must
    // have /../ like sequences in it
    return canonicalDocBase.equals(docBase.toString());
}
 

import java.io.File; //导入方法依赖的package包/类
@Override
String[] linkCount(File file) throws IOException {
  String[] buf = new String[getLinkCountCommand.length];
  System.arraycopy(getLinkCountCommand, 0, buf, 0, 
                   getLinkCountCommand.length);
  buf[getLinkCountCommand.length - 1] = file.getCanonicalPath();
  return buf;
}
 

import java.io.File; //导入方法依赖的package包/类
String relativePath(File file) throws IOException {
    String canonicalPath = file.getCanonicalPath();
    if (!canonicalPath.startsWith(sourceDirectory)) {
        throw new IOException(format("the path %s is not a decendent of the basedir %s", canonicalPath, sourceDirectory));
    }
    return canonicalPath.substring(sourceDirectory.length()).replaceAll("^" + quote(File.separator), "");
}
 

import java.io.File; //导入方法依赖的package包/类
private boolean isForbiddenToRead (File file, ProtectionDomain protectionDomain)
{
    if (null == protectionDomain) {
        return false;
    }
    try {
        FilePermission filePermission =
                new FilePermission(file.getCanonicalPath(), "read, delete");
        if (protectionDomain.implies(filePermission)) {
            return false;
        }
    } catch (IOException e) {}

    return true;
}
 

import java.io.File; //导入方法依赖的package包/类
private static void validateCurrentDir(final File directoryToExecuteIn) throws IOException {
  if (directoryToExecuteIn != null) {
    if (!directoryToExecuteIn.exists())
      throw new IOException("Directory does not exist: \"" + directoryToExecuteIn.getCanonicalPath() + '\"');
    if (!directoryToExecuteIn.isDirectory())
      throw new IOException("Path is not a directory: \"" + directoryToExecuteIn.getCanonicalPath() + '\"');
  }
}
 

import java.io.File; //导入方法依赖的package包/类
public static String realpath(String path) {
    File f = new File(path);
    String ret = null;
    try {
        ret = f.getCanonicalPath();
    } catch (Exception ex) {
        LOG.warn(ex);
    }
    return (ret);
}
 

import java.io.File; //导入方法依赖的package包/类
/** Returns the relative path of the first file resolved against the second. */
public static String getRelativePath(File firstFile, File secondFile) throws IOException {
	String canonicalFirstPath = firstFile.getCanonicalPath();
	String canonicalSecondPath = secondFile.getCanonicalPath();

	int minLength = Math.min(canonicalFirstPath.length(), canonicalSecondPath.length());
	int index = 0;
	for (index = 0; index < minLength; index++) {
		if (canonicalFirstPath.charAt(index) != canonicalSecondPath.charAt(index)) {
			break;
		}
	}

	String relPath = canonicalFirstPath;
	int lastSeparatorIndex = canonicalFirstPath.substring(0, index).lastIndexOf(File.separator);
	if (lastSeparatorIndex != -1) {
		String absRest = canonicalSecondPath.substring(lastSeparatorIndex + 1);
		StringBuffer relPathBuffer = new StringBuffer();
		while (absRest.indexOf(File.separator) >= 0) {
			relPathBuffer.append(".." + File.separator);
			absRest = absRest.substring(absRest.indexOf(File.separator) + 1);
		}
		relPathBuffer.append(canonicalFirstPath.substring(lastSeparatorIndex + 1));
		relPath = relPathBuffer.toString();
	}
	return relPath;
}