Jak uzyskać bieżący katalog roboczy w Javie?

Chcę uzyskać dostęp do mojego bieżącego katalogu roboczego za pomocą java.

Mój kod:

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

Wynik:

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

Moje dane wyjściowe są nieprawidłowe, ponieważ dysk C nie jest moim bieżącym katalogiem.

Jak uzyskać bieżący katalog?

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

Spowoduje to wydrukowanie pełnej ścieżki bezwzględnej, z której zainicjowano aplikację.

Z dokumentacji :

java.iopakiet rozpoznaje względne ścieżki przy użyciu bieżącego katalogu użytkownika. Bieżący katalog jest reprezentowany jako właściwość systemowa, czyli user.dirkatalog, z którego została wywołana maszyna JVM.

Zobacz: http://docs.oracle.com/javase/tutorial/essential/io/pathOps.html

Za pomocą java.nio.file.Pathi java.nio.file.Pathsmożesz wykonać następujące czynności, aby pokazać, co Java uważa za twoją bieżącą ścieżkę. Działa to od 7 lat i używa NIO.

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

Dane wyjściowe, Current relative path is: /Users/george/NetBeansProjects/Tutorialsktóre w moim przypadku są miejscem, z którego prowadziłem klasę. Konstruowanie ścieżek we względny sposób, nie używając separatora wiodącego do wskazania, że ​​budujesz ścieżkę bezwzględną, wykorzysta tę ścieżkę względną jako punkt początkowy.

Poniższe działa na Javie 7 i nowszych (patrz dokumentacja tutaj ).

import java.nio.file.Paths;

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

To da ci ścieżkę do twojego bieżącego katalogu roboczego:

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

To da ci ścieżkę do pliku o nazwie „Foo.txt” w katalogu roboczym:

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

Edycja: Aby uzyskać bezwzględną ścieżkę do bieżącego katalogu:

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

* Aktualizacja * Aby uzyskać bieżący katalog roboczy:

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

To jest dla mnie rozwiązanie

File currentDir = new File("");

Znalazłem to rozwiązanie w komentarzach, które jest lepsze niż inne i bardziej przenośne:

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

Lub nawet

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

Co sprawia, że ​​myślisz, że c: \ windows \ system32 nie jest twoim bieżącym katalogiem? user.dirNieruchomość jest wyraźnie będzie „bieżący katalog roboczy użytkownika”.

Innymi słowy, chyba że uruchamiasz Javę z wiersza poleceń, c: \ windows \ system32 prawdopodobnie jest twoją CWD. Oznacza to, że jeśli klikniesz dwukrotnie, aby uruchomić program, prawdopodobnie nie będzie katalogu, z którego klikniesz dwukrotnie.

Edycja : Wygląda na to, że dotyczy to tylko starych wersji Windows i / lub Java.

Zastosowanie CodeSource#getLocation().

Działa to również dobrze w plikach JAR. Możesz uzyskać CodeSourceprzez, ProtectionDomain#getCodeSource()a z ProtectionDomainkolei można uzyskać przez 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()

ogólnie jako obiekt File:

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

możesz chcieć mieć pełny ciąg znaków, taki jak „D: / a / b / c” wykonujący:

getCwd().getAbsolutePath()

Korzystam z systemu Linux i uzyskuję taki sam wynik dla obu tych podejść:

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

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

Paths.get("") dokumenty

System.getProperty("user.dir") dokumenty

W systemie Linux po uruchomieniu pliku jar z terminala oba zwrócą to samo String: „/ home / CurrentUser” , bez względu na to, gdzie znajduje się plik jar. Zależy to tylko od tego, jakiego bieżącego katalogu używasz z terminalem podczas uruchamiania pliku jar.

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

System.getProperty("user.dir");

Jeśli twoja Classz mainzostanie wywołana MainClass, spróbuj:

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

Będzie to zwróci Stringz bezwzględną ścieżkę do jar pliku.

Użycie Windows user.dir zwraca katalog zgodnie z oczekiwaniami, ale NIE przy uruchamianiu aplikacji z podwyższonymi uprawnieniami (działającymi jako administrator), w takim przypadku otrzymujesz C: \ WINDOWS \ system32

Mam nadzieję, że chcesz uzyskać dostęp do bieżącego katalogu wraz z pakietem, tj. Jeśli Twój program Java jest już włączony c:\myApp\com\foo\src\service\MyTest.javai chcesz wydrukować do c:\myApp\com\foo\src\servicetego czasu , możesz wypróbować następujący kod:

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

Uwaga: ten kod jest testowany tylko w systemie Windows z Oracle JRE.

Wspomnij, że jest sprawdzany tylko w, Windowsale myślę, że działa idealnie na innych systemach operacyjnych [ Linux,MacOs,Solaris] :).

Miałem 2 .jar pliki w tym samym katalogu. Chciałem, aby z jednego .jarpliku uruchomić drugi .jarplik, który znajduje się w tym samym katalogu.

Problem polega na tym, że po uruchomieniu z cmdbieżącego katalogu jest system32.

Ostrzeżenia!

• Poniższe wydaje się działać całkiem dobrze we wszystkich testach, które przeprowadziłem, nawet z nazwą folderu ;][[;'57f2g34g87-8+9-09!2#@!$%^^&()lub ()%&$%^@# działa dobrze.
• Korzystam ProcessBuilderz poniższych poniżej:

🍂 ..

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

Bieżący katalog roboczy jest różnie zdefiniowany w różnych implementacjach Java. W przypadku niektórych wersji wcześniejszych niż Java 7 nie było spójnego sposobu uzyskania katalogu roboczego. Można obejść ten problem, uruchamiając plik Java -Di definiując zmienną do przechowywania informacji

Coś jak

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

To nie do końca prawda, ale masz pomysł. Więc System.getProperty("com.mycompany.workingDir")...

Załóżmy, że próbujesz uruchomić swój projekt w środowisku Eclipse lub w sieci lub samodzielnie z wiersza poleceń. Mam sposób, aby to naprawić

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

Aby użyć wszędzie tam, gdzie chcesz uzyskać podstawową ścieżkę do odczytu pliku, możesz przekazać klasę zakotwiczenia do powyższej metody, wynik może być tym, czego potrzebujesz: D

Najlepsza,

Żadna z zamieszczonych tutaj odpowiedzi nie działała dla mnie. Oto, co zadziałało:

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

Edycja: Ostateczna wersja w moim kodzie:

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

To jest moja srebrna kula, kiedy tylko pojawia się moment pomieszania. (Nazwij to przede wszystkim). Może na przykład JVM ma inną wersję IDE. Ta funkcja statyczna wyszukuje bieżący PID procesu i otwiera VisualVM na tym pid. Zamieszanie kończy się tutaj, ponieważ chcesz tego wszystkiego i dostajesz to ...

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

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

to jest nazwa bieżącego katalogu

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

to jest bieżąca ścieżka do katalogu

String path=folder.getPath();