The system cannot find the file specified java

Question

Yes, I already know this question is a duplicate, but just bear with me here. None of the other questions answered this.

This is my code:

package pc.setup;

import java.io.IOException;

public class DirectoryCreator {
    public static void setupDirectories() throws IOException {
        Runtime.getRuntime().exec("cd\\");
    }
}

This is the error I get:

Exception in thread "main" java.io.IOException: Cannot run program "cd\": CreateProcess error=2, The system cannot find the file specified
    at java.lang.ProcessBuilder.start(Unknown Source)
    at java.lang.Runtime.exec(Unknown Source)
    at java.lang.Runtime.exec(Unknown Source)
    at java.lang.Runtime.exec(Unknown Source)
    at pc.setup.DirectoryCreator.setupDirectories(DirectoryCreator.java:7)
    at pc.load.PieClickerRunner.main(PieClickerRunner.java:9)
Caused by: java.io.IOException: CreateProcess error=2, The system cannot find the file specified
    at java.lang.ProcessImpl.create(Native Method)
    at java.lang.ProcessImpl.<init>(Unknown Source)
    at java.lang.ProcessImpl.start(Unknown Source)
    ... 6 more

Answer 1

There are two problems here:

• cd is not an executable on its own; it is a built-in of the command shell. exec only runs executables (in their own files). That is why it is not found. exec can run a command shell, but ...
• Even if you did change directory in a command shell, that change is only in effect for the newly spawned process, not for the program that launched it.

Sorry, but that approach does not work in Java.

Answer 2

I am assuming that you are running this application under Windows operating systems family (otherwise you will have to adapt it a little bit). The Runtime.exec() method is used to execute executable commands. It is not the case with dir, cd, copy, ... As a consequence of this it triggers an exception which is what you are experiencing.

The cd command is part of the windows command interpreter cmd. It can either be executed with command.com or cmd.exe depending on the version of the operating system.

Therefore we should run the command interpreter first and feed it the user - supplied command (such as dir, cd, copy, ...)

Here is a program that does that. It checks the os.name environment variable in order to select the right command interpreter. I test for Windows NT and Windows 95. If none of these two is found but is still a Windows operating system, then I assume it is a modern windows (such as Windows 7 or Windows 8) and it is using cmd.exe.

import java.util.*;
import java.io.*;
class StreamGobbler extends Thread
{
    InputStream is;
    String type;

    StreamGobbler(InputStream is, String type)
    {
        this.is = is;
        this.type = type;
    }

    public void run()
    {
        try
        {
            InputStreamReader isr = new InputStreamReader(is);
            BufferedReader br = new BufferedReader(isr);
            String line=null;
            while ( (line = br.readLine()) != null)
                System.out.println(type + ">" + line);    
         } catch (IOException ioe)
         {
            ioe.printStackTrace();  
         }
    }
}
public class GoodWindowsExec
{
    public static void main(String args[])
    {
        if (args.length < 1)
        {
            System.out.println("USAGE: java GoodWindowsExec <cmd>");
            System.exit(1);
        }

        try
        {            
            String osName = System.getProperty("os.name" );
            System.out.println("OS NAME IS " + osName);
            String[] cmd = new String[3];
            if( osName.equals( "Windows NT" ) )
            {
                cmd[0] = "cmd.exe" ;
                cmd[1] = "/C" ;
                cmd[2] = args[0];
            }
            else if( osName.equals( "Windows 95" ) )
            {
                cmd[0] = "command.com" ;
                cmd[1] = "/C" ;
                cmd[2] = args[0];
            } else if (osName.toUpperCase().trim().contains("WINDOWS")) {
                cmd[0] = "cmd.exe" ;
                cmd[1] = "/C" ;
                cmd[2] = args[0];
            }

            Runtime rt = Runtime.getRuntime();
            System.out.println("Execing " + cmd[0] + " " + cmd[1] 
                           + " " + cmd[2]);
            Process proc = rt.exec(cmd);
            // any error message?
            StreamGobbler errorGobbler = new 
                StreamGobbler(proc.getErrorStream(), "ERROR");            

            // any output?
            StreamGobbler outputGobbler = new 
                StreamGobbler(proc.getInputStream(), "OUTPUT");

            // kick them off
            errorGobbler.start();
            outputGobbler.start();

            // any error???
            int exitVal = proc.waitFor();
            System.out.println("ExitValue: " + exitVal);        
        } catch (Throwable t)
          {
            t.printStackTrace();
          }
    }
}

Here is a Simple runner for this class

public class GoodWindowsExecRunner {

    public static void main(String[] args) {
        //GoodWindowsExec.main(new String[] {"dir *.*"});
        GoodWindowsExec.main(new String[] {"cd .."});
    }

}

Here is the result from executing the "cd .." command

Here is the result from executing a "dir ." command

There is an excellent article on java world called When Runtime.exec won't

Answer 3

Thank you everyone for your answers. They were wordy, though, so in this answer I will try to summarize it.

When you call Runtime.getRuntime.exec(), you must specify what shell you are using (only on Windows). So, you would say Runtime.getRuntime.exec("command here", "cmd.exe"). As you probably know, CMD is the Windows command shell for modern Windows operating systems.

Once again, thank you for your answers.