Como obter o diretório de trabalho atual em Java?

Quero acessar meu diretório de trabalho atual usando java.

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

Resultado:

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

Minha saída não está correta porque a unidade C não é meu diretório atual.

Como obter o diretório atual?

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

Isso imprimirá um caminho absoluto completo de onde seu aplicativo foi inicializado.

A partir da documentação :

java.iopacote resolve nomes de caminho relativos usando o diretório de usuário atual. O diretório atual é representado como propriedade do sistema, ou seja, user.dire é o diretório de onde a JVM foi chamada.

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

Usando java.nio.file.Pathe java.nio.file.Paths, você pode fazer o seguinte para mostrar o que Java acha que é o seu caminho atual. Isso para 7 em diante e usa o NIO.

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

Isso Current relative path is: /Users/george/NetBeansProjects/Tutorialsmostra que, no meu caso, é de onde eu executei a classe. Construir caminhos de maneira relativa, ao não usar um separador à esquerda para indicar que você está construindo um caminho absoluto, usará esse caminho relativo como ponto de partida.

O seguinte funciona no Java 7 e superior (veja aqui para documentação).

import java.nio.file.Paths;

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

Isso fornecerá o caminho do seu diretório de trabalho atual:

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

E isso lhe dará o caminho para um arquivo chamado "Foo.txt" no diretório de trabalho:

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

Edit: Para obter um caminho absoluto do diretório atual:

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

* Atualização * Para obter o diretório de trabalho atual:

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

Esta é a solução para mim

File currentDir = new File("");

Encontrei esta solução nos comentários, melhor do que outros e mais portátil:

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

Ou até

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

O que faz você pensar que c: \ windows \ system32 não é seu diretório atual? A user.dirpropriedade deve ser explicitamente "Diretório de trabalho atual do usuário".

Em outras palavras, a menos que você inicie o Java na linha de comando, c: \ windows \ system32 provavelmente é o seu CWD. Ou seja, se você clicar duas vezes para iniciar o programa, é improvável que o CWD seja o diretório em que você está clicando duas vezes.

Editar : parece que isso só é verdade para janelas antigas e / ou versões Java.

Use CodeSource#getLocation().

Isso funciona bem em arquivos JAR também. Você pode obter CodeSourcepor ProtectionDomain#getCodeSource()e, por ProtectionDomainsua vez, pode ser obtido 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()

geralmente, como um objeto File:

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

você pode querer ter uma sequência completa qualificada como "D: / a / b / c", fazendo:

getCwd().getAbsolutePath()

Estou no Linux e obtenho o mesmo resultado para ambas as abordagens:

@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

No Linux, quando você executa um arquivo jar no terminal , ambos retornam o mesmo String: "/ home / CurrentUser" , não importa onde esteja o arquivo jar. Depende apenas do diretório atual que você está usando com o seu terminal, quando inicia o arquivo jar.

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

System.getProperty("user.dir");

Se o seu Classcom mainseria chamado MainClass, então tente:

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

Isso retornará um Stringcom caminho absoluto do arquivo jar .

O uso do Windows user.dir retorna o diretório conforme o esperado, mas NÃO quando você inicia o aplicativo com direitos elevados (executado como admin); nesse caso, você obtém C: \ WINDOWS \ system32

Espero que você queira acessar o diretório atual, incluindo o pacote, ou seja, se o seu programa Java estiver presente c:\myApp\com\foo\src\service\MyTest.javae você desejar imprimir até c:\myApp\com\foo\src\serviceentão, tente o seguinte 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 é testado apenas no Windows com Oracle JRE.

Mencione que ele está marcado apenas Windowsmas acho que funciona perfeitamente em outros sistemas operacionais [ Linux,MacOs,Solaris] :).

Eu tinha 2 .jar arquivos no mesmo diretório. Eu queria que um .jararquivo iniciasse o outro .jararquivo que está no mesmo diretório.

O problema é que, quando você o inicia cmdno diretório atual, é system32.

Advertências!

• O abaixo parece funcionar muito bem em todos os testes que fiz, mesmo com o nome da pasta ;][[;'57f2g34g87-8+9-09!2#@!$%^^&()ou ()%&$%^@# funciona bem.
• Estou usando o ProcessBuildercom o seguinte, como a seguir:

🍂 ..

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

O diretório de trabalho atual é definido de maneira diferente em diferentes implementações Java. Para determinadas versões anteriores ao Java 7, não havia uma maneira consistente de obter o diretório de trabalho. Você pode contornar isso iniciando o arquivo Java -De definindo uma variável para conter as informações

Algo como

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

Isso não está certo, mas você entendeu. Então System.getProperty("com.mycompany.workingDir")...

suponha que você esteja tentando executar seu projeto dentro do eclipse ou netbean ou independente da linha de comando. Eu escrevi um método para corrigi-lo

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, em qualquer lugar que você deseja obter o caminho base para ler o arquivo, você pode passar sua classe âncora para o método acima, o resultado pode ser o que você precisa: D

melhor,

Nenhuma das respostas postadas aqui funcionou para mim. Aqui está o que funcionou:

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

Edit: A versão final no meu 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 é a minha bala de prata sempre que surge o momento de confusão. (Chame como a primeira coisa em geral). Talvez, por exemplo, a JVM tenha sido desviada para uma versão diferente pelo IDE. Essa função estática pesquisa o PID do processo atual e abre o VisualVM nesse pid. A confusão acaba aí porque você quer tudo e consegue ...

  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 é o nome do diretório atual

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

este é o caminho do diretório atual

String path=folder.getPath();