You start a new process with Runtime.exec(command). Each process has a working directory. This is normally the directory in which the parent process was started, but you can change the directory in which your process is started.

I would recommend to use ProcessBuilder

ProcessBuilder pb = new ProcessBuilder("ls");
pb.inheritIO();
pb.directory(new File("bin"));
pb.start();

If you want to run multiple commands in a shell it would be better to create a temporary shell script and run this.

public void executeCommands() throws IOException {

    File tempScript = createTempScript();

    try {
        ProcessBuilder pb = new ProcessBuilder("bash", tempScript.toString());
        pb.inheritIO();
        Process process = pb.start();
        process.waitFor();
    } finally {
        tempScript.delete();
    }
}

public File createTempScript() throws IOException {
    File tempScript = File.createTempFile("script", null);

    Writer streamWriter = new OutputStreamWriter(new FileOutputStream(
            tempScript));
    PrintWriter printWriter = new PrintWriter(streamWriter);

    printWriter.println("#!/bin/bash");
    printWriter.println("cd bin");
    printWriter.println("ls");

    printWriter.close();

    return tempScript;
}

Of course you can also use any other script on your system. Generating a script at runtime makes sometimes sense, e.g. if the commands that are executed have to change. But you should first try to create one script that you can call with arguments instead of generating it dynamically at runtime.

It might also be reasonable to use a template engine like velocity if the script generation is complex.

EDIT

You should also consider to hide the complexity of the process builder behind a simple interface.

Separate what you need (the interface) from how it is done (the implementation).

public interface FileUtils {
    public String[] listFiles(String dirpath);
}

You can then provide implementations that use the process builder or maybe native methods to do the job and you can provide different implementations for different environments like linux or windows.

Finally such an interface is also easier to mock in unit tests.

There are two ways to do this:

1. Use fully qualified paths for execution (java ... /path/to/file.jar)
2. Use cd in your scripts.

The first is self-explanatory - use full paths to your files at execution time.

The second is needed at each execution line for different directories to call cd /the/dir/to/enter before executing things. While cd does NOT affect the shell outside of the script, it executes in the shell that's spawned for the script, and has the same effect as you running cd on the command line directly.

You should use the returned Process to get the result.

Runtime#exec executes the command as a separate process and returns an object of type Process. You should call Process#waitFor so that your program waits until the new process finishes. Then, you can invoke Process.html#getOutputStream() on the returned Process object to inspect the output of the executed command.

An alternative way of creating a process is to use ProcessBuilder.

Process p = new ProcessBuilder("myCommand", "myArg").start();

With a ProcessBuilder, you list the arguments of the command as separate arguments.

See Difference between ProcessBuilder and Runtime.exec() and ProcessBuilder vs Runtime.exec() to learn more about the differences between Runtime#exec and ProcessBuilder#start.

To understand this, you first need to understand how you would run that command at a shell prompt.

$ sh -c "java -jar M1_MIAGE_PDL_VIZ_GROUPE3.jar menu"

Note where the double quotes are. The first argument is -c. The second argument is the stuff inside the quotes; i.e. java -jar M1_MIAGE_PDL_VIZ_GROUPE3.jar menu

Now we translate that into Java:

Process p = new ProcessBuilder(
   "/bin/sh", 
   "-c", 
   "java -jar M1_MIAGE_PDL_VIZ_GROUPE3.jar menu").start();

Having said that, the above doesn't actually achieve anything. Certainly, it doesn't open a fresh console window to display the console output etcetera. Unlike Windows "CMD.exe", UNIX / Linux shells do not provide console / terminal functionality. For that you need to use a "terminal" application.

For example, if you are using GNOME

Process p = new ProcessBuilder(
   "gnome-terminal", 
   "-e", 
   "java -jar M1_MIAGE_PDL_VIZ_GROUPE3.jar menu").start();

will (probably) do what you are trying to do.

When you use bash -c, the first argument after the -c is treated as a command, and any additional arguments are passed as positional parameters.

In your first fragment,

{"bash", "-c", "cd " + folder + "&& find . -type f | grep :*.txt "}

you are passing a single concatenated string argument "cd " + folder + "&& find . -type f | grep :*.txt " whereas in the second fragment,

{"bash", "-c", "~/Final-Year/src/query", "&& ./checkuser.sh", user}

you are passing 3 arguments:

• ~/Final-Year/src/query (which presumably should have been cd ~/Final-Year/src/query
• && ./checkuser.sh
• user

so it's equivalent to

bash -c '~/Final-Year/src/query' '&& ./checkuser.sh' user

which executes bash -c '~/Final-Year/src/query' or (corrected) bash -c 'cd ~/Final-Year/src/query' with literal string && ./checkuser.sh as positional parameter $0 and the substituted Java variable user as positional parameter $1

What you likely want is

bash -c 'cd ~/Final-Year/src/query && ./checkuser.sh user'

which would instead be

{"bash", "-c", "cd ~/Final-Year/src/query && ./checkuser.sh " + user}

Alternatively, you could make use of the positional parameter array like

{"bash", "-c", "cd ~/Final-Year/src/query && ./checkuser.sh \"$1\"", "bash", user}

where the shell's name bash is passed as $0 (you could use any arbitrary string here) and Java variable user as $1.

If the problem is that running the script doesn't show a terminal window, the solution depends on the window manager you're using. Gnome as well as KDE allow to edit properties of desktop shortcuts on a right-click and setting a option like "run in terminal" there.

Another way is to edit the desktop configuration file manually: you can find them in the Desktop subdirectory of your home dir. Just add a line with Terminal=true to the desktop configuration file that should run the server.