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

Quiero acceder a mi directorio de trabajo actual usando java.

Mi código :

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

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?

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

Esto imprimirá una ruta absoluta completa desde donde se inicializó su aplicación.

De la documentación :

java.ioEl 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.diry es el directorio desde el que se invocó la JVM.

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

Usando java.nio.file.Pathy java.nio.file.Paths, puede hacer lo siguiente para mostrar lo que Java cree que es su ruta actual. Esto para 7 y más, y usa NIO.

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

Esto da como resultado Current relative path is: /Users/george/NetBeansProjects/Tutorialsque en mi caso es donde ejecuté la clase. Al construir 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.

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

import java.nio.file.Paths;

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

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

Esta es la solución para mi

File currentDir = new File("");

He encontrado esta solución en los comentarios que es mejor que otros y más portátil:

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

O incluso

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

¿Qué te hace pensar que c: \ windows \ system32 no es tu directorio actual? La user.dirpropiedad es explícitamente "Directorio de trabajo actual del usuario".

Para decirlo de otra manera, a menos que inicie Java desde la línea de comandos, c: \ windows \ system32 probablemente sea su 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 ventanas antiguas y / o versiones de Java.

Uso CodeSource#getLocation().

Esto también funciona bien en archivos JAR. Puede obtener CodeSourcepor ProtectionDomain#getCodeSource()y ProtectionDomaina su vez 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());
    }
}

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

generalmente, como un objeto File:

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

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

getCwd().getAbsolutePath()

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

System.getProperty("user.dir") docs

En Linux cuando ejecuta un archivo jar desde la terminal , ambos devolverán lo mismo String: "/ home / CurrentUser" , sin importar dónde se encuentre su archivo jar. Depende de qué directorio actual esté utilizando con su terminal, cuando inicie el archivo jar.

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

System.getProperty("user.dir");

Si su Classcon mainque se llamaría MainClass, a continuación, tratar:

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

Esto devolverá una Stringcon ruta absoluta del frasco de archivo.

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

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.javaejecución y desea imprimir hasta c:\myApp\com\foo\src\serviceentonces, puede 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.

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

Tenía 2 .jar archivos en el mismo directorio. Quería que desde un .jararchivo comenzara el otro .jararchivo que está en el mismo directorio.

El problema es que cuando lo inicia desde el cmddirectorio 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#@!$%^^&()o ()%&$%^@# funciona bien.
• Estoy usando ProcessBuilderel siguiente a continuación:

🍂 ..

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

El directorio de trabajo actual se define de manera diferente en diferentes implementaciones de Java. Para ciertas versiones anteriores a Java 7 no había una forma consistente de obtener el directorio de trabajo. Podría solucionar este problema iniciando un archivo Java -Dy definiendo una variable para contener la información

Algo como

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

Eso no está del todo bien, pero entiendes la idea. Entonces System.getProperty("com.mycompany.workingDir")...

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

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, en cualquier lugar donde desee obtener la ruta base para leer el archivo, puede pasar su clase de ancla al método anterior, el resultado puede ser lo que necesita: D

Mejor,

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

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

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

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 actual del directorio

String path=folder.getPath();