ජාවා හි වත්මන් වැඩ නාමාවලිය ලබා ගන්නේ කෙසේද?

ජාවා භාවිතයෙන් මගේ වර්තමාන වැඩ කරන නාමාවලියට ප්‍රවේශ වීමට මට අවශ්‍යය.

මගේ කේතය:

 String current = new java.io.File( "." ).getCanonicalPath();
        System.out.println("Current dir:"+current);
 String currentDir = System.getProperty("user.dir");
        System.out.println("Current dir using System:" +currentDir);

ප්‍රතිදානය:

Current dir: C:\WINDOWS\system32
Current dir using System: C:\WINDOWS\system32

සී ඩ්‍රයිව් මගේ වත්මන් නාමාවලිය නොවන නිසා මගේ ප්‍රතිදානය නිවැරදි නොවේ.

වත්මන් නාමාවලිය ලබා ගන්නේ කෙසේද?

public class JavaApplication {
  public static void main(String[] args) {
       System.out.println("Working Directory = " + System.getProperty("user.dir"));
  }
}

මෙය ඔබගේ යෙදුම ආරම්භ කළ ස්ථානයෙන් සම්පූර්ණ නිරපේක්ෂ මාර්ගයක් මුද්‍රණය කරනු ඇත .

සිට ප්රලේඛනය :

java.ioපැකේජය වත්මන් පරිශීලක නාමාවලිය භාවිතා කරමින් සාපේක්ෂ මාර්ග නාම නිරාකරණය කරයි. වත්මන් නාමාවලිය පද්ධති දේපල ලෙස නිරූපණය කෙරේ, එනම් user.dirජේවීඑම් ආයාචනය කළ නාමාවලියයි.

බලන්න: http://docs.oracle.com/javase/tutorial/essential/io/pathOps.html

භාවිතා java.nio.file.Pathහා java.nio.file.Paths, ඔබ ජාවා ඔබේ වත්මන් මාර්ගය සිතන දේ පෙන්වන්න කරන්න පුළුවන්. මෙය 7 සහ ඊට පසුව NIO භාවිතා කරයි.

Path currentRelativePath = Paths.get("");
String s = currentRelativePath.toAbsolutePath().toString();
System.out.println("Current relative path is: " + s);

මෙය Current relative path is: /Users/george/NetBeansProjects/Tutorialsමගේ නඩුවේදී මම පන්තිය මෙහෙයවූ ස්ථානයයි. ඔබ නිරපේක්ෂ මාර්ගයක් ගොඩනඟන බව දැක්වීමට ප්‍රමුඛ බෙදුම්කරුවෙකු භාවිතා නොකිරීමෙන් සාපේක්ෂ ආකාරයකින් මාර්ග තැනීම, මෙම සාපේක්ෂ මාර්ගය ආරම්භක ලක්ෂ්‍යය ලෙස භාවිතා කරනු ඇත.

පහත දැක්වෙන්නේ ජාවා 7 සහ ඊට ඉහළින් ක්‍රියා කරයි ( ප්‍රලේඛනය සඳහා මෙහි බලන්න ).

import java.nio.file.Paths;

Paths.get(".").toAbsolutePath().normalize().toString();

මෙය ඔබගේ වර්තමාන වැඩ කරන නාමාවලියෙහි මාවත ලබා දෙනු ඇත:

Path path = FileSystems.getDefault().getPath(".");

මෙය ඔබට වැඩ කරන නාමාවලියෙහි "Foo.txt" නම් ගොනුවකට මාවත ලබා දෙනු ඇත:

Path path = FileSystems.getDefault().getPath("Foo.txt");

සංස්කරණය කරන්න: වත්මන් නාමාවලියෙහි නිරපේක්ෂ මාර්ගයක් ලබා ගැනීම සඳහා:

Path path = FileSystems.getDefault().getPath(".").toAbsolutePath();

* යාවත්කාලීන කිරීම * වත්මන් වැඩ නාමාවලිය ලබා ගැනීම සඳහා:

Path path = FileSystems.getDefault().getPath("").toAbsolutePath();

මෙය මට විසඳුමයි

File currentDir = new File("");

මෙම විසඳුම අනෙක් අයට වඩා හොඳ සහ වඩා අතේ ගෙන යා හැකි අදහස් වලින් මම සොයාගෙන ඇත:

String cwd = new File("").getAbsolutePath();

නැත්නම් පවා

String cwd = Paths.get("").toAbsolutePath();

C: \ windows \ system32 ඔබේ වර්තමාන නාමාවලිය නොවේ යැයි ඔබ සිතන්නේ කුමක් ද ? මෙම user.dir"පරිශීලක වත්මන් කම්කරු බහලුම" ලෙස දේපල සුවිශේෂව වේ.

වෙනත් ආකාරයකින් කිවහොත්, ඔබ විධාන රේඛාවෙන් ජාවා ආරම්භ නොකරන්නේ නම්, c: \ windows \ system32 බොහෝ විට ඔබේ සීඩබ්ලිව්ඩී විය හැකිය. එනම්, ඔබ ඔබේ වැඩසටහන ආරම්භ කිරීමට දෙවරක් ක්ලික් කරන්නේ නම්, ඔබ දෙවරක් ක්ලික් කරන නාමාවලිය සීඩබ්ලිව්ඩී විය නොහැක.

සංස්කරණය කරන්න : මෙය පැරණි කවුළු සහ / හෝ ජාවා අනුවාද සඳහා පමණක් සත්‍ය බව පෙනේ.

භාවිත CodeSource#getLocation() .

මෙය JAR ලිපිගොනු වලද හොඳින් ක්‍රියාත්මක වේ. ඔබ ලබා ගත හැක CodeSourceවිසින් ProtectionDomain#getCodeSource()සහ ProtectionDomainඅනෙක් අතට ලබා ගත හැක Class#getProtectionDomain().

public class Test {
    public static void main(String... args) throws Exception {
        URL location = Test.class.getProtectionDomain().getCodeSource().getLocation();
        System.out.println(location.getFile());
    }
}

this.getClass().getClassLoader().getResource("").getPath()

සාමාන්‍යයෙන්, ගොනු වස්තුවක් ලෙස:

File getCwd() {
  return new File("").getAbsoluteFile();
}

ඔබට "D: / a / b / c" වැනි සම්පූර්ණ සුදුසුකම් ලත් නූලක් කිරීමට අවශ්‍ය විය හැකිය:

getCwd().getAbsolutePath()

මම ලිනක්ස් හි සිටින අතර මෙම ප්‍රවේශයන් දෙකටම එකම ප්‍රති result ල ලබා ගන්න:

@Test
public void aaa()
{
    System.err.println(Paths.get("").toAbsolutePath().toString());

    System.err.println(System.getProperty("user.dir"));
}

Paths.get("") ලියකියවිලි

System.getProperty("user.dir") ලියකියවිලි

ඔබ ටර්මිනලයේ සිට භාජන ගොනුවක් ධාවනය කරන විට ලිනක්ස් මත , මෙම දෙකම එකම ආපසු String: "/ home / CurrentUser" මගේ හිතේ තියෙන භාජනයක් ගොනුව කොතැනක,. එය රඳා පවතින්නේ ඔබ භාජන ගොනුව ආරම්භ කරන විට ඔබේ පර්යන්තය සමඟ භාවිතා කරන වත්මන් නාමාවලිය මත පමණි.

Paths.get("").toAbsolutePath().toString();

System.getProperty("user.dir");

ඔබගේ Classසමඟ mainකැඳවනු ලැබුවහොත් MainClass, උත්සාහ කරන්න:

MainClass.class.getProtectionDomain().getCodeSource().getLocation().getFile();

මෙය නැවත පැමිණෙන Stringසමග සත්ය මාර්ගය පිළිබඳ භාජනයක් ගොනුව.

වින්ඩෝස් user.dir භාවිතා කිරීමෙන් ඩිරෙක්ටරිය බලාපොරොත්තු වූ පරිදි ලබා දෙයි, නමුත් ඔබ ඔබේ යෙදුම උසස් අයිතිවාසිකම් සමඟ ආරම්භ කරන විට (පරිපාලක ලෙස ධාවනය කරන්න), එවැනි අවස්ථාවකදී ඔබට C: \ WINDOWS \ system32 ලැබේ

පැකේජය ඇතුළුව වත්මන් නාමාවලියට ප්‍රවේශ වීමට ඔබට අවශ්‍ය යැයි මම විශ්වාස කරමි, එනම් ඔබේ ජාවා වැඩසටහන ක්‍රියාත්මක වී c:\myApp\com\foo\src\service\MyTest.javaඔබට එතෙක් මුද්‍රණය කිරීමට අවශ්‍ය c:\myApp\com\foo\src\serviceනම් ඔබට පහත කේතය උත්සාහ කළ හැකිය:

String myCurrentDir = System.getProperty("user.dir")
            + File.separator
            + System.getProperty("sun.java.command")
                    .substring(0, System.getProperty("sun.java.command").lastIndexOf("."))
                    .replace(".", File.separator);
    System.out.println(myCurrentDir);

සටහන: මෙම කේතය වින්ඩෝස් හි පමණක් ඔරකල් ජේආර්ඊ සමඟ පරීක්ෂා කරනු ලැබේ.

එය පරීක්ෂා කර ඇත්තේ පමණක් බව සඳහන් කරන්න, නමුත් එය Windowsවෙනත් මෙහෙයුම් පද්ධති මත පරිපූර්ණව ක්‍රියා කරයි යැයි සිතමි [ Linux,MacOs,Solaris] :).

එකම ඩිරෙක්ටරියේ මට ගොනු 2 ක් තිබුණි .jar. එක් .jarගොනුවකින් .jarඑකම ඩිරෙක්ටරියේ ඇති අනෙක් ගොනුව ආරම්භ කිරීමට මට අවශ්‍ය විය .

ගැටළුව වන්නේ ඔබ එය cmdවත්මන් නාමාවලියෙන් ආරම්භ කරන විට වීමයි system32.

අනතුරු ඇඟවීම්!

• පහත i පවා ෆෝල්ඩරය නම සමඟ කළ සියලු ටෙස්ට් ඉතා හොදින් වැඩ කිරීමට පෙනේ ;][[;'57f2g34g87-8+9-09!2#@!$%^^&()හෝ ()%&$%^@# එය හොඳින් ක්රියා කරයි.
• මම ProcessBuilderපහත සඳහන් දෑ පහත පරිදි භාවිතා කරමි :

..

//The class from which i called this was the class `Main`
String path = getBasePathForClass(Main.class);
String applicationPath=  new File(path + "application.jar").getAbsolutePath();


System.out.println("Directory Path is : "+applicationPath);

//Your know try catch here
//Mention that sometimes it doesn't work for example with folder `;][[;'57f2g34g87-8+9-09!2#@!$%^^&()` 
ProcessBuilder builder = new ProcessBuilder("java", "-jar", applicationPath);
builder.redirectErrorStream(true);
Process process = builder.start();

//...code

🍂 getBasePathForClass(Class<?> classs):

    /**
     * Returns the absolute path of the current directory in which the given
     * class
     * file is.
     * 
     * @param classs
     * @return The absolute path of the current directory in which the class
     *         file is.
     * @author GOXR3PLUS[StackOverFlow user] + bachden [StackOverFlow user]
     */
    public static final String getBasePathForClass(Class<?> classs) {

        // Local variables
        File file;
        String basePath = "";
        boolean failed = false;

        // Let's give a first try
        try {
            file = new File(classs.getProtectionDomain().getCodeSource().getLocation().toURI().getPath());

            if (file.isFile() || file.getPath().endsWith(".jar") || file.getPath().endsWith(".zip")) {
                basePath = file.getParent();
            } else {
                basePath = file.getPath();
            }
        } catch (URISyntaxException ex) {
            failed = true;
            Logger.getLogger(classs.getName()).log(Level.WARNING,
                    "Cannot firgue out base path for class with way (1): ", ex);
        }

        // The above failed?
        if (failed) {
            try {
                file = new File(classs.getClassLoader().getResource("").toURI().getPath());
                basePath = file.getAbsolutePath();

                // the below is for testing purposes...
                // starts with File.separator?
                // String l = local.replaceFirst("[" + File.separator +
                // "/\\\\]", "")
            } catch (URISyntaxException ex) {
                Logger.getLogger(classs.getName()).log(Level.WARNING,
                        "Cannot firgue out base path for class with way (2): ", ex);
            }
        }

        // fix to run inside eclipse
        if (basePath.endsWith(File.separator + "lib") || basePath.endsWith(File.separator + "bin")
                || basePath.endsWith("bin" + File.separator) || basePath.endsWith("lib" + File.separator)) {
            basePath = basePath.substring(0, basePath.length() - 4);
        }
        // fix to run inside netbeans
        if (basePath.endsWith(File.separator + "build" + File.separator + "classes")) {
            basePath = basePath.substring(0, basePath.length() - 14);
        }
        // end fix
        if (!basePath.endsWith(File.separator)) {
            basePath = basePath + File.separator;
        }
        return basePath;
    }

වර්තමාන වැඩ කරන නාමාවලිය විවිධ ජාවා ක්‍රියාත්මක කිරීමේදී වෙනස් ලෙස අර්ථ දක්වා ඇත. ජාවා 7 ට පෙර නිශ්චිත අනුවාදයක් සඳහා වැඩ කරන නාමාවලිය ලබා ගැනීමට ස්ථාවර ක්‍රමයක් නොතිබුණි. ජාවා ගොනුව දියත් කිරීමෙන් -Dසහ තොරතුරු රඳවා තබා ගැනීම සඳහා විචල්‍යයක් නිර්වචනය කිරීමෙන් ඔබට මෙය වටා වැඩ කළ හැකිය

වගේ දෙයක්

java -D com.mycompany.workingDir="%0"

එය එතරම් නිවැරදි නැත, නමුත් ඔබට අදහස ලැබේ. එහෙනම් System.getProperty("com.mycompany.workingDir")...

ඔබ ඔබේ ව්‍යාපෘතිය සූර්යග්‍රහණය තුළ හෝ නෙට්බීන් තුළ ක්‍රියාත්මක කිරීමට උත්සාහ කරන බව හෝ විධාන රේඛාවෙන් තනිවම සිටීමට උත්සාහ කරන්න. එය නිවැරදි කිරීම සඳහා මම ක්‍රමයක් ලියා ඇත

public static final String getBasePathForClass(Class<?> clazz) {
    File file;
    try {
        String basePath = null;
        file = new File(clazz.getProtectionDomain().getCodeSource().getLocation().toURI().getPath());
        if (file.isFile() || file.getPath().endsWith(".jar") || file.getPath().endsWith(".zip")) {
            basePath = file.getParent();
        } else {
            basePath = file.getPath();
        }
        // fix to run inside eclipse
        if (basePath.endsWith(File.separator + "lib") || basePath.endsWith(File.separator + "bin")
                || basePath.endsWith("bin" + File.separator) || basePath.endsWith("lib" + File.separator)) {
            basePath = basePath.substring(0, basePath.length() - 4);
        }
        // fix to run inside netbean
        if (basePath.endsWith(File.separator + "build" + File.separator + "classes")) {
            basePath = basePath.substring(0, basePath.length() - 14);
        }
        // end fix
        if (!basePath.endsWith(File.separator)) {
            basePath = basePath + File.separator;
        }
        return basePath;
    } catch (URISyntaxException e) {
        throw new RuntimeException("Cannot firgue out base path for class: " + clazz.getName());
    }
}

භාවිතා කිරීම සඳහා, ඔබට ගොනුව කියවීම සඳහා මූලික මාවතක් ලබා ගැනීමට අවශ්‍ය සෑම තැනකම, ඔබට ඔබේ නැංගුරම් පන්තිය ඉහත ක්‍රමයට යොමු කළ හැකිය, ප්‍රති result ලය ඔබට අවශ්‍ය දේ විය හැකිය: D

හොඳම,

ව්‍යාකූලත්වයේ මොහොත වන විට මෙය මගේ රිදී උණ්ඩයයි. (ප්‍රධාන වශයෙන් එය පළමු දෙය ලෙස හඳුන්වන්න). සමහර විට උදාහරණයක් ලෙස ජේවීඑම් IDE විසින් වෙනස් අනුවාදයක් ලෙස ලිස්සා ගොස් ඇත. මෙම ස්ථිතික ශ්‍රිතය වත්මන් ක්‍රියාවලිය PID සොයන අතර එම pid මත VisualVM විවෘත කරයි. ඔබට ඒ සියල්ල අවශ්‍ය නිසාත් එය ඔබට ලැබෙන නිසාත් ව්‍යාකූලත්වය එතැනම නතර වේ ...

  public static void callJVisualVM() {
    System.out.println("USER:DIR!:" + System.getProperty("user.dir"));
    //next search current jdk/jre
    String jre_root = null;
    String start = "vir";
    try {
        java.lang.management.RuntimeMXBean runtime =
                java.lang.management.ManagementFactory.getRuntimeMXBean();
        String jvmName = runtime.getName();
        System.out.println("JVM Name = " + jvmName);
        long pid = Long.valueOf(jvmName.split("@")[0]);
        System.out.println("JVM PID  = " + pid);
        Runtime thisRun = Runtime.getRuntime();
        jre_root = System.getProperty("java.home");
        System.out.println("jre_root:" + jre_root);
        start = jre_root.concat("\\..\\bin\\jvisualvm.exe " + "--openpid " + pid);
        thisRun.exec(start);
    } catch (Exception e) {
        System.getProperties().list(System.out);
        e.printStackTrace();
    }
}

මෙහි පළ කර ඇති පිළිතුරු කිසිවක් මට වැඩ කළේ නැත. වැඩ කළ දේ මෙන්න:

java.nio.file.Paths.get(
  getClass().getProtectionDomain().getCodeSource().getLocation().toURI()
);

සංස්කරණය කරන්න: මගේ කේතයේ අවසාන අනුවාදය:

URL myURL = getClass().getProtectionDomain().getCodeSource().getLocation();
java.net.URI myURI = null;
try {
    myURI = myURL.toURI();
} catch (URISyntaxException e1) 
{}
return java.nio.file.Paths.get(myURI).toFile().toString()

System.getProperty("java.class.path")

මෙය වත්මන් නාමාවලි නාමයයි

String path="/home/prasad/Desktop/folderName";
File folder = new File(path);
String folderName=folder.getAbsoluteFile().getName();

මෙය වත්මන් නාමාවලි මාර්ගයයි

String path=folder.getPath();