¿Cómo obtener el directorio de trabajo actual en Java?

Quiero acceder a mi directorio de trabajo actual usando Java.

Mi código:

 String currentPath = new java.io.File(".").getCanonicalPath();
 System.out.println("Current dir:" + currentPath);

 String currentDir = System.getProperty("user.dir");
 System.out.println("Current dir using System:" + currentDir);

Salida:

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

Mi salida no es correcta porque la unidad C no es mi directorio actual.

¿Cómo obtener el directorio actual?

preguntado el 02 de febrero de 11 a las 02:02

¿Puedes pegar aquí lo que ves cuando ejecutas? cd comando en su símbolo del sistema cuando ejecuta esto? -

¿Qué está tratando de lograr accediendo al directorio de trabajo? ¿Podría hacerse utilizando la ruta de clases en su lugar? Por ejemplo, si necesita leer un archivo de texto en el sistema de archivos, puede encontrarlo fácilmente cuando está en la ruta de clases. -

¿Cómo? ¿Podría explicarme por favor? -

Para obtener información sobre cómo acceder a un archivo en la ruta de clases, consulte stackoverflow.com/questions/1464291/… -

Para fines de depuración, el directorio de trabajo podría ser útil para saber si el programa no parece poder acceder a los archivos que existen. -

25 Respuestas

Código:

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

Esto imprimirá la ruta absoluta del directorio actual desde donde se inicializó su aplicación.


Explicación:

Desde el documentación:

java.io El paquete resuelve los nombres de ruta relativos utilizando el directorio de usuario actual. El directorio actual se representa como propiedad del sistema, es decir, user.dir y es el directorio desde donde se invocó la JVM.

Respondido 26 Oct 20, 05:10

@ubuntudroid: es por eso que mencioné específicamente que imprimirá la ruta desde donde se inicializó la aplicación. Supongo que el iniciador de subprocesos ejecuta directamente el jar / programa después de iniciar el símbolo del sistema commnad (que está básicamente en C: \ WINDOWS \ system32). Espero que entiendas mi punto. Suponiendo que votó en contra, aprecie que al menos le importó dejar una respuesta. :) - Anuj Patel

user.dir obtendrá la ruta a la carpeta donde se inició el proceso. Para obtener la ruta real a la carpeta principal de la aplicación, vea mi respuesta a continuación. - pedro de invierno

Me refiero a "todo el código que se basa en él para encontrar el directorio actual falla. ". No todo el código en general. (Fui muy lento para editar el comentario original) - Subóptimo

@SubOptimal si el usuario configuró -Duser.dir, es probable que desee ejecutarlo en un directorio de trabajo personalizado. - barwnikk

@indyaah de hecho, esta respuesta es incorrecta, hay una sutil diferencia entre un directorio de trabajo de usuario y un directorio de trabajo actual de un proceso del sistema (cwd); la mayoría de las veces, "user.dir" apunta al cwd de un proceso (java); pero "user.dir" tiene una semántica diferente y no se utilizará para obtener el cwd de un proceso java; por cierto: hay más propiedades disponibles para el proceso de Java docs.oracle.com/javase/tutorial/essential/environment/… solo para referencia - comeGetSome

Ver: Operaciones de ruta (Tutoriales de Java ™> Clases esenciales> E / S básica).

Usar java.nio.file.Path y java.nio.file.Paths, puede hacer lo siguiente para mostrar lo que Java piensa que es su ruta actual. Esto para 7 años en adelante, y usa NIO.

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

Esto produce:

Current relative path is: /Users/george/NetBeansProjects/Tutorials

que en mi caso es de donde ejecuté la clase.

La construcción de rutas de forma relativa, al no utilizar un separador inicial para indicar que está construyendo una ruta absoluta, utilizará esta ruta relativa como punto de partida.

Respondido el 11 de junio de 21 a las 15:06

El primero no lo ha verificado, pero el segundo realmente obtendrá su carpeta de inicio. No es el directorio de trabajo actual en el que se ejecuta la aplicación. - pedro de invierno

No confunda el directorio de inicio del usuario ("user.home", / Users / george en su caso) y el directorio de trabajo actual ("user.dir", que será el directorio desde el que inició la JVM para su aplicación , por lo que podría ser algo como, por ejemplo, / Users / george / workspace / FooBarProject). - David

Yo prefiero esta forma. Cuando necesito el padre del directorio de trabajo, esto lo hace no trabajo: Paths.get("").getParent(), da null. En cambio, esto funciona: Paths.get("").toAbsolutePath().getParent(). - Ole VV

Lo siguiente funciona en Java 7 y versiones posteriores (consulte aquí para documentación).

import java.nio.file.Paths;

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

contestado el 25 de mayo de 16 a las 20:05

¿Cómo es esto mejor que el más portátil? import java.io.File; File(".").getAbsolutePath() ? - Evgeni Serguéiev

Cuando dice portátil, ¿quiere decir que funciona en Java 6 y versiones anteriores? Paths.get() puede considerarse mejor en el sentido de que da acceso directo a los más poderosos Path interfaz. - Ole VV

¿Cuál es la ventaja potencial de usar .normalize() ¿en este contexto? - Ole VV

@ OleV.V. Desde Javadoc: (normalizar el método) Returns a path that is this path with redundant name elements eliminated. - Stephan

Esto le dará la ruta de su directorio de trabajo actual:

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

Y esto le dará la ruta a un archivo llamado "Foo.txt" en el directorio de trabajo:

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

Editar: Para obtener una ruta absoluta del directorio actual:

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

* Actualización * Para obtener el directorio de trabajo actual:

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

respondido 05 mar '20, 19:03

esto solo devuelve '.' para mi. - john ktejik

Sí, en muchos sistemas esa será la referencia al directorio de trabajo. Para obtener la ruta absoluta, puede agregar una llamada más al método Path path = FileSystems.getDefault().getPath(".").toAbsolutePath(); - Mark

No necesita foo.txt, solo ingrese una cadena vacía para obtener el directorio - john ktejik

En Windows (10) esto solo me da una Path objeto apuntando a un archivo llamado . dentro del directorio de trabajo actual. Usando una cadena vacía, en lugar de "." trabajó para mi. - Krow

Java 11 y más reciente

Esta solución es mejor que otras y más portátil:

Path cwd = Path.of("").toAbsolutePath();

O incluso

String cwd = Path.of("").toAbsolutePath().toString();

respondido 30 mar '21, 16:03

Esto es exactamente lo mismo que la respuesta de comeGetSome y en realidad es la forma Java <7: GoGoris

debe ser Path cwd = Paths.get (""). toAbsolutePath (); - Jahangir Alam

Mejor usar Path.of, porque Las rutas pueden quedar obsoletas. Además, Paths.get solo llama Path.of. - onkar ruikar

@onkarruikar buen punto, actualizaré la respuesta - desarrollo libre

Esta es la solucion para mi

File currentDir = new File("");

contestado el 29 de mayo de 13 a las 00:05

Esto tiene efectos secundarios cuando usa un objeto Archivo como padre de otro Archivo: el archivo nuevo (Archivo nuevo (""), "subdirectorio") no funcionará como se esperaba - alwasser

Para solucionar esto, use new File("").getAbsoluteFile() en lugar de. - alwasser

Por lo que vale, tuve mejor suerte con File ("."). - keshlam

Cómo definir una ruta relativa en Java Esta página me ayudó. También asumí que debería usar / al crear una ruta relativa. Estaba equivocado, no empieces con /. ../ también funciona para subir en el árbol de directorios. - Irracionalkilla

@keshlam Eso me dio un archivo en el directorio actual llamado .. - Krow

Qué te hace pensar que c: \ windows \ system32 no es su directorio actual? La user.dir propiedad es explícitamente "directorio de trabajo actual del usuario".

Para decirlo de otra manera, a menos que inicie Java desde la línea de comando, c: \ windows \ system32 probablemente sea tu CWD. Es decir, si hace doble clic para iniciar su programa, es poco probable que el CWD sea el directorio desde el que hace doble clic.

Editar: Parece que esto solo es cierto para las versiones antiguas de Windows y / o Java.

contestado el 07 de mayo de 16 a las 11:05

Esto no parece ser cierto, al menos no en mi máquina con Windows 7 que usa Java 7. user.dir es consistentemente la carpeta donde hice doble clic en el archivo jar. - Jolta

Utiliza la CodeSource#getLocation().

Esto también funciona bien en archivos JAR. Puedes obtener CodeSource by ProtectionDomain#getCodeSource() y ProtectionDomain a su vez se puede obtener por 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());
    }
}

Respondido 01 Feb 16, 16:02

Esto devuelve la ubicación del archivo JAR. No es lo que se pidió. - user207421

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

contestado el 15 de mayo de 13 a las 15:05

Lanza un NPE cuando ejecuto mi aplicación desde un archivo JAR haciendo doble clic en él. - Mateo sabio

Esto vuelve "" si la aplicación se ejecuta desde un archivo JAR o un elemento CLASSPATH. No es lo que se pidió. - user207421

@ Zizouz212 getClass() es un método de objeto, por lo que en un contexto estático simplemente eliminando this no funciona. Tendrías que referirte explícitamente a la clase en la que estás haciendo MyClass.class.getClassLoader()...... - Krow

generalmente, como un objeto Archivo:

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

es posible que desee tener una cadena completa calificada como "D: / a / b / c" haciendo:

getCwd().getAbsolutePath()

Respondido el 28 de enero de 15 a las 10:01

Esto funciona bien en las pruebas de Android, ya que Android no incluye java.nio.file.Files. - soyreptar

No parece funcionar para mí en un contexto estático (el archivo nuevo ("") arroja NullPointerException) ..? - nsandersen

@nsandersen probablemente utilizó un objeto File incorrecto: System.out.println (new java.io.File (""). getAbsolutePath ()); - comeGetSome

Estoy en Linux y obtengo el mismo resultado para ambos enfoques:

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

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

Paths.get("") documentos

System.getProperty("user.dir") documentos

Respondido 12 ago 14, 20:08

Espero que desee acceder al directorio actual, incluido el paquete, es decir, si su programa Java está en c:\myApp\com\foo\src\service\MyTest.java y quieres imprimir hasta c:\myApp\com\foo\src\service entonces puedes probar el siguiente código:

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: Este código solo se prueba en Windows con Oracle JRE.

Respondido el 05 de junio de 13 a las 16:06

Sería un flaco favor no rechazar esta respuesta. Piense más detenidamente antes de publicar. Su código está roto, a menos que todo esto sea cierto: 1. el JRE es de Oracle; de ​​lo contrario, no habrá propiedad del sistema "sun.java.command" → NPE; 2. el sistema operativo es Windows (use File.separator en su lugar, o un argumento múltiple File constructor); 3. la ruta de clase se especifica en la línea de comando, y el 'directorio actual que incluye el paquete' (??) es: a. especificado primero, b. especificado absolutamente, c. coincide exactamente con el CWD (incluso con la insensibilidad a mayúsculas y minúsculas de Windows), y d. es un descendiente del CWD - Michael Scheper

Eso aborda los puntos 1 y 2. Pero a menos que me falte algo, todavía confía en que la ruta de clase se especifique en la línea de comando (es decir, no en una variable de entorno), y para el 'directorio actual que incluye el paquete' admito que realmente no entiendo lo que quieres decir con eso) ser descendiente de específicamente el primer elemento en el classpath. Y el problema de la coincidencia de casos persiste. Lo siento si mi comentario no fue útil; Sacrifiqué la claridad para mantenerme dentro del límite de caracteres del comentario. - Michael Scheper

@Inversus, solo "funciona perfectamente" en algunos entornos; acaba de tener la suerte de probarlo en uno de esos. Escribir software que falla en entornos de ejecución legítimos no es una buena práctica, incluso cuando su conjunto de entornos de prueba no es lo suficientemente amplio como para incluirlos. - Carlos Duffy

@CharlesDuffy Tienes razón, esa no es una buena práctica. Afortunadamente, esta solución "resolviendo mi problema específico" no provocó que "[fallara] en entornos de ejecución legítimos". De hecho, me ayudó a resolver tal falla y a escribir un código más robusto, además de resolver el problema muy específico que tenía (que solo estaba algo relacionado con esta pregunta / respuesta). Supongo que tuve suerte de encontrarlo. - Inverso

On Linux cuando ejecutas un tarro archivo de terminal, estos dos devolverán lo mismo String: "/ home / CurrentUser", no importa dónde esté el archivo jar. Depende solo del directorio actual que esté usando con su terminal, cuando inicie el archivo jar.

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

System.getProperty("user.dir");

Si Class con main se llamaría MainClass, entonces intenta:

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

Esto devolverá un String con camino absoluto de los tarro archivo.

Respondido el 17 de diciembre de 15 a las 22:12

Que no es lo que se pidió. - user207421

El uso de user.dir de Windows devuelve el directorio como se esperaba, pero NO cuando inicia su aplicación con derechos elevados (ejecutar como administrador), en ese caso obtiene C: \ WINDOWS \ system32

Respondido el 25 de diciembre de 15 a las 14:12

Mencione que solo está registrado Windows pero creo que funciona perfectamente en otros sistemas operativos [Linux,MacOs,Solaris] :).


Tuve 2 .jar archivos en el mismo directorio. Yo quería del uno .jar archivo para iniciar el otro .jar archivo que se encuentra en el mismo directorio.

El problema es que cuando lo inicias desde el cmd el directorio actual es system32.


Advertencias

  • Lo siguiente parece funcionar bastante bien en todas las pruebas que he hecho incluso con el nombre de la carpeta ;][[;'57f2g34g87-8+9-09!2#@!$%^^&() or ()%&$%^@# funciona bien.
  • Estoy usando el ProcessBuilder con lo siguiente como sigue:

🍂 ..

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

Respondido el 28 de enero de 17 a las 00:01

Esto devuelve la ubicación del archivo JAR. No es lo que se pidió. - user207421

@EJP ¿La ubicación del archivo .jar no es el directorio de trabajo actual del programa java? - GOXR3PLUS

suponga que está intentando ejecutar su proyecto dentro de eclipse, netbean o de forma independiente desde la línea de comandos. He escrito un método para solucionarlo

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

Para usar, donde quiera que desee obtener la ruta base para leer el archivo, puede pasar su clase de anclaje al método anterior, el resultado puede ser lo que necesita: D

Mejor,

Respondido 16 Abr '15, 05:04

Esto devuelve la ubicación del archivo JAR. No es lo que se pidió. - user207421

@ user207421 sí, sé que esta respuesta no es la respuesta verdadera para la pregunta, pero la mayoría de las veces, todos quieren obtener el "directorio donde se encuentran los frascos" en lugar del "directorio de trabajo de la línea de comandos". - Bachden

El directorio de trabajo actual se define de manera diferente en diferentes implementaciones de Java. Para cierta versión anterior a Java 7, no había una forma coherente de obtener el directorio de trabajo. Puede solucionar esto iniciando el archivo Java con -D y definir una variable para contener la información

Algo como

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

Eso no es del todo correcto, pero entiendes la idea. Luego System.getProperty("com.mycompany.workingDir")...

Respondido 08 Feb 17, 04:02

No es relevante para la pregunta. - pedro de invierno

Tiene un significado para Java: es la ubicación en el disco donde los archivos que abre con nombres de ruta relativos son relativos. - Rob yo

Sí, tiene un significado. Mis palabras fueron un tanto mal elegidas. Pero pierde el punto: antes de Java 7 no había forma de conocer el directorio de trabajo actual, y diferentes implementaciones los configuraban ... de manera diferente ... - MJB

Esta es mi bala de plata cuando surge el momento de confusión. (Llámalo como lo primero en main). Quizás, por ejemplo, IDE desliza JVM para que sea una versión diferente. Esta función estática busca el PID del proceso actual y abre VisualVM en ese pid. La confusión se detiene ahí mismo porque lo quieres todo y lo consigues ...

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

contestado el 18 de mayo de 20 a las 01:05

Deberías escribir un libro sobre esta cuestión. Estas 50 líneas de código no son suficientes. - user2719152

Esto no es exactamente lo que se pregunta, pero aquí hay una nota importante: cuando se ejecuta Java en una máquina con Windows, el instalador de Oracle coloca un "java.exe" en C: \ Windows \ system32, y esto es lo que actúa como iniciador para el Aplicación Java (A MENOS QUE haya un java.exe anteriormente en la RUTA y la aplicación Java se ejecute desde la línea de comandos). Esta es la razón por la que File (".") Sigue devolviendo C: \ Windows \ system32, y por qué los ejemplos de ejecución de implementaciones de macOS o * nix siguen apareciendo con resultados diferentes de Windows.

Desafortunadamente, realmente no hay una respuesta universalmente correcta para esta, por lo que he encontrado en veinte años de codificación de Java, a menos que desee crear su propio ejecutable de iniciador nativo usando JNI Invocation, y obtener el directorio de trabajo actual del código de iniciador nativo cuando se lanza. Todo lo demás va a tener al menos algún matiz que podría romperse en determinadas situaciones.

Respondido el 15 de Septiembre de 20 a las 23:09

Esto era cierto hace mucho tiempo (cuando se publicó esta Q), pero Microsoft desaconsejó que las aplicaciones cambiaran system32, y desde al menos 2015 los instaladores de Oracle Windows pusieron su código auxiliar en cualquiera de los dos \programdata\Oracle\Java\javapath or \Program Files [(x86)]\Common Files\Oracle\Java\javapathaprobado por MS - dave_thompson_085

Intente algo como esto. Sé que llego tarde para la respuesta, pero esto obvio sucedió en java8, una nueva versión desde donde se hace esta pregunta, pero ...

El código

import java.io.File;

public class Find_this_dir {

    public static void main(String[] args) {

//some sort of a bug in java path is correct but file dose not exist
        File this_dir = new File("");

//but these both commands work too to get current dir        
//      File this_dir_2 = new File(this_dir.getAbsolutePath());
        File this_dir_2 = new File(new File("").getAbsolutePath());

        System.out.println("new File(" + "\"\"" + ")");
        System.out.println(this_dir.getAbsolutePath());
        System.out.println(this_dir.exists());
        System.out.println("");
        System.out.println("new File(" + "new File(" + "\"\"" + ").getAbsolutePath()" + ")");
        System.out.println(this_dir_2.getAbsolutePath());
        System.out.println(this_dir_2.exists());
    }
}

Esto funcionará y le mostrará la ruta actual, pero ahora no sé por qué Java no puede encontrar el directorio actual en new File(""); además estoy usando el compilador Java8 ...

Esto funciona bien, incluso lo probé new File(new File("").getAbsolutePath());

Ahora tiene el directorio actual en un objeto de archivo, entonces (el objeto de archivo de ejemplo es f entonces),

f.getAbsolutePath() le dará la ruta en un tipo variable de cadena ...

Probado en otro directorio que no es la unidad C funciona bien

Respondido el 25 de enero de 21 a las 06:01

Para Java 11 también puede usar:

var path = Path.of(".").toRealPath();

respondido 24 mar '21, 17:03

Mi método favorito es obtenerlo de las variables de entorno del sistema adjuntas al proceso en ejecución actual. En este caso, la JVM administra su aplicación.

String currentDir = System.getenv("PWD");
/*
 /home/$User/Documents/java
*/

Para ver otras variables de entorno que pueden resultarle útiles, como directorio de inicio, versión del sistema operativo ........

//Home directory
String HomeDir = System.getEnv("HOME");


//Outputs for unix
/home/$USER

//Device user
String user = System.getEnv("USERNAME");


//Outputs for unix
$USER

Lo bueno de este enfoque es que todos los caminos se resolverán para todos los tipos de plataforma de sistema operativo.

Respondido el 01 de junio de 21 a las 11:06

Ninguna de las respuestas publicadas aquí funcionó para mí. Esto es lo que funcionó:

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

Editar: la versión final en mi código:

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

respondido 31 mar '15, 20:03

Esto devuelve la ubicación del archivo JAR. No es lo que se pidió. - user207421

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

Respondido el 03 de enero de 15 a las 23:01

este es el nombre del directorio actual

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

esta es la ruta del directorio actual

String path=folder.getPath();

respondido 20 nov., 13:08

El OP quería el directorio de trabajo actual desde donde se ejecutó la aplicación. - Leif Grünwoldt

Es tu hogar directorio, no el directorio de trabajo actual de nadie, excepto tal vez el tuyo. No es lo que se pidió. - user207421

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.