Comment obtenir le répertoire de travail actuel en Java?

Je veux accéder à mon répertoire de travail actuel en utilisant java.

Mon code:

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

Production:

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

Ma sortie n'est pas correcte car le lecteur C n'est pas mon répertoire actuel.

Comment obtenir le répertoire courant?

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

Cela imprimera un chemin absolu complet à partir duquel votre application a été initialisée.

De la documentation :

java.iole package résout les chemins d'accès relatifs à l'aide du répertoire utilisateur actuel. Le répertoire actuel est représenté comme une propriété système, c'est-à-dire, user.diret est le répertoire à partir duquel la JVM a été invoquée.

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

En utilisant java.nio.file.Pathet java.nio.file.Paths, vous pouvez faire ce qui suit pour montrer ce que Java pense être votre chemin actuel. Ceci pour 7 et plus, et utilise NIO.

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

Cela génère Current relative path is: /Users/george/NetBeansProjects/Tutorialsque dans mon cas, j'ai exécuté la classe. La construction de chemins d'une manière relative, en n'utilisant pas de séparateur de tête pour indiquer que vous construisez un chemin absolu, utilisera ce chemin relatif comme point de départ.

Les travaux suivants sur Java 7 et plus (voir ici pour la documentation).

import java.nio.file.Paths;

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

Cela vous donnera le chemin de votre répertoire de travail actuel:

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

Et cela vous donnera le chemin vers un fichier appelé "Foo.txt" dans le répertoire de travail:

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

Edit: Pour obtenir un chemin absolu du répertoire courant:

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

* Mise à jour * Pour obtenir le répertoire de travail actuel:

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

C'est la solution pour moi

File currentDir = new File("");

J'ai trouvé cette solution dans les commentaires qui est meilleure que les autres et plus portable:

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

Ou même

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

Qu'est-ce qui vous fait penser que c: \ windows \ system32 n'est pas votre répertoire actuel? leuser.dir propriété doit être explicitement le "répertoire de travail actuel de l'utilisateur".

Autrement dit, sauf si vous démarrez Java à partir de la ligne de commande, c: \ windows \ system32 est probablement votre CWD. Autrement dit, si vous double-cliquez pour démarrer votre programme, il est peu probable que le CWD soit le répertoire à partir duquel vous double-cliquez.

Edit : Il semble que cela ne soit vrai que pour les anciennes fenêtres et / ou versions Java.

Utilisation CodeSource#getLocation() .

Cela fonctionne également très bien dans les fichiers JAR. Vous pouvez obtenir CodeSourcepar ProtectionDomain#getCodeSource()et le ProtectionDomaintour peut être obtenu par 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()

généralement, en tant qu'objet File:

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

vous voudrez peut-être avoir une chaîne complète comme "D: / a / b / c":

getCwd().getAbsolutePath()

Je suis sous Linux et j'obtiens le même résultat pour ces deux approches:

@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

Sous Linux, lorsque vous exécutez un fichier jar à partir du terminal , ces deux paramètres renverront le même String: "/ home / CurrentUser" , peu importe où se trouve votre fichier jar. Cela dépend uniquement du répertoire courant que vous utilisez avec votre terminal, lorsque vous démarrez le fichier jar.

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

System.getProperty("user.dir");

Si votre Classavec mainest appelé MainClass, essayez:

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

Cela renverra un Stringavec chemin absolu du pot fichier.

L'utilisation de Windows user.dir renvoie le répertoire comme prévu, mais PAS lorsque vous démarrez votre application avec des droits élevés (exécuté en tant qu'administrateur), dans ce cas, vous obtenez C: \ WINDOWS \ system32

J'espère que vous souhaitez accéder au répertoire actuel, y compris le package, c'est-à-dire si votre programme Java est dans c:\myApp\com\foo\src\service\MyTest.javaet que vous souhaitez imprimer jusque- c:\myApp\com\foo\src\servicelà, vous pouvez essayer le code suivant:

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

Remarque: Ce code n'est testé que sous Windows avec Oracle JRE.

Mentionnez qu'il est enregistré uniquement Windowsmais je pense que cela fonctionne parfaitement sur d'autres systèmes d'exploitation [ Linux,MacOs,Solaris] :).

J'avais 2 .jar fichiers dans le même répertoire. Je voulais à partir d'un .jarfichier pour démarrer l'autre .jarfichier qui se trouve dans le même répertoire.

Le problème est que lorsque vous le démarrez à partir du cmdrépertoire en cours, c'est system32.

Avertissements!

• Ce qui suit semble fonctionner assez bien dans tous les tests que j'ai faits, même avec le nom du dossier ;][[;'57f2g34g87-8+9-09!2#@!$%^^&()ou()%&$%^@# cela fonctionne bien.
• J'utilise le ProcessBuilderavec le ci-dessous comme suit:

🍂 ..

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

Le répertoire de travail actuel est défini différemment dans différentes implémentations Java. Pour certaines versions antérieures à Java 7, il n'existait aucun moyen cohérent d'obtenir le répertoire de travail. Vous pouvez contourner cela en lançant un fichier Java avec -Det en définissant une variable pour contenir les informations

Quelque chose comme

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

Ce n'est pas tout à fait vrai, mais vous voyez l'idée. Alors System.getProperty("com.mycompany.workingDir")...

supposons que vous essayez d'exécuter votre projet dans eclipse, ou netbean ou autonome à partir de la ligne de commande. J'ai écrit une méthode pour y remédier

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

Pour l'utiliser, partout où vous voulez obtenir le chemin de base pour lire le fichier, vous pouvez passer votre classe d'ancrage à la méthode ci-dessus, le résultat peut être la chose dont vous avez besoin: D

Meilleur,

Aucune des réponses publiées ici n'a fonctionné pour moi. Voici ce qui a fonctionné:

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

Edit: La version finale de mon code:

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

Ceci est ma balle d'argent quand le moment de confusion se propage. (Appelez-le comme première chose principale). Par exemple, JVM est glissé pour être une version différente par IDE. Cette fonction statique recherche le processus PID en cours et ouvre VisualVM sur ce pid. La confusion s'arrête là parce que vous voulez tout et vous l'obtenez ...

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

c'est le nom du répertoire actuel

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

c'est le chemin du répertoire courant

String path=folder.getPath();