Come ottenere l'attuale directory di lavoro in Java?

Voglio accedere alla mia directory di lavoro corrente utilizzando Java.

Il mio codice:

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

Produzione:

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

Il mio output non è corretto perché l'unità C non è la mia directory corrente.

Come ottenere la directory corrente?

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

Questo stamperà un percorso assoluto completo da dove è stata inizializzata l'applicazione.

Dalla documentazione :

java.ioil pacchetto risolve i percorsi relativi usando la directory utente corrente. La directory corrente è rappresentata come proprietà di sistema, ovvero user.dired è la directory da cui è stata richiamata la JVM.

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

Usando java.nio.file.Pathe java.nio.file.Paths, puoi fare quanto segue per mostrare ciò che Java pensa sia il tuo percorso attuale. Questo per 7 e oltre, e utilizza NIO.

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

Ciò produce Current relative path is: /Users/george/NetBeansProjects/Tutorialsche nel mio caso è da dove ho tenuto la classe. Costruire percorsi in modo relativo, non usando un separatore principale per indicare che stai costruendo un percorso assoluto, utilizzerà questo percorso relativo come punto di partenza.

Quanto segue funziona su Java 7 e versioni successive (vedere qui per la documentazione).

import java.nio.file.Paths;

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

Questo ti darà il percorso della tua attuale directory di lavoro:

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

E questo ti darà il percorso di un file chiamato "Foo.txt" nella directory di lavoro:

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

Modifica: per ottenere un percorso assoluto della directory corrente:

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

* Aggiorna * Per ottenere la directory di lavoro corrente:

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

Questa è la soluzione per me

File currentDir = new File("");

Ho trovato questa soluzione nei commenti che è migliore di altri e più portatile:

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

O anche

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

Cosa ti fa pensare che c: \ windows \ system32 non sia la tua directory attuale? La user.dirproprietà deve essere esplicitamente "Directory di lavoro corrente dell'utente".

Per dirla in altro modo, a meno che non si avvii Java dalla riga di comando, c: \ windows \ system32 probabilmente è il CWD. Cioè, se si fa doppio clic per avviare il programma, è improbabile che il CWD sia la directory da cui si fa doppio clic.

Modifica : sembra che ciò sia vero solo per vecchie versioni di Windows e / o Java.

Usa CodeSource#getLocation().

Funziona bene anche nei file JAR. È possibile ottenere CodeSourceda ProtectionDomain#getCodeSource()e il ProtectionDomaina sua volta può essere ottenuto da 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()

generalmente, come oggetto File:

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

potresti voler avere una stringa qualificata come "D: / a / b / c" che fa:

getCwd().getAbsolutePath()

Sono su Linux e ottengo lo stesso risultato per entrambi questi approcci:

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

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

Paths.get("") docs

System.getProperty("user.dir") docs

Su Linux quando si esegue un file jar dal terminale , entrambi restituiranno lo stesso String: "/ home / CurrentUser" , indipendentemente da dove si trovi il file jar. Dipende solo dalla directory corrente che stai usando con il tuo terminale, quando avvii il file jar.

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

System.getProperty("user.dir");

Se il tuo Classcon mainsarebbe chiamato MainClass, quindi prova:

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

Ciò restituirà un percorso assolutoString con il file jar .

L'uso di user.dir di Windows restituisce la directory come previsto, ma NON quando si avvia l'applicazione con diritti elevati (esegui come admin), in tal caso si ottiene C: \ WINDOWS \ system32

Spero che tu voglia accedere alla directory corrente incluso il pacchetto, ad esempio se il tuo programma Java è attivo c:\myApp\com\foo\src\service\MyTest.javae vuoi stampare fino a c:\myApp\com\foo\src\servicequel momento puoi provare il seguente codice:

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

Nota: questo codice è testato solo in Windows con Oracle JRE.

Menzione che è registrato solo in Windowsma penso che funzioni perfettamente su altri sistemi operativi [ Linux,MacOs,Solaris] :).

Ho avuto 2 .jar file nella stessa directory. Volevo da un .jarfile avviare l'altro .jarfile che si trova nella stessa directory.

Il problema è che quando lo si avvia dalla cmddirectory corrente è system32.

Avvertenze!

• Quanto segue sembra funzionare abbastanza bene in tutti i test che ho fatto anche con il nome della cartella ;][[;'57f2g34g87-8+9-09!2#@!$%^^&()o ()%&$%^@# funziona bene.
• Sto usando il ProcessBuildercon il seguito come segue:

🍂 ..

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

La directory di lavoro corrente è definita in modo diverso nelle diverse implementazioni Java. Per alcune versioni precedenti a Java 7 non esisteva un modo coerente per ottenere la directory di lavoro. È possibile aggirare il problema avviando il file Java con -De definendo una variabile per contenere le informazioni

Qualcosa di simile a

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

Non è del tutto giusto, ma hai l'idea. Allora System.getProperty("com.mycompany.workingDir")...

supponi che stai provando a eseguire il tuo progetto all'interno di eclipse, o netbean o stand-alone dalla riga di comando. Ho scritto un metodo per risolverlo

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

Per usare, ovunque tu voglia ottenere il percorso base per leggere il file, puoi passare la tua classe di ancoraggio al metodo sopra, il risultato potrebbe essere quello che ti serve: D

Migliore,

Nessuna delle risposte pubblicate qui ha funzionato per me. Ecco cosa ha funzionato:

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

Modifica: la versione finale nel mio codice:

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

Questo è il mio proiettile d'argento ogni volta che arriva il momento di confusione. (Chiamalo come prima cosa principale). Forse, ad esempio, JVM è considerato diverso da IDE. Questa funzione statica ricerca il PID del processo corrente e apre VisualVM su quel pid. La confusione si ferma proprio lì perché vuoi tutto e lo ottieni ...

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

questo è il nome della directory corrente

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

questo è il percorso della directory corrente

String path=folder.getPath();