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.

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.

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.

You can use processBuilder API for this purpose. See this example.

When you invoke a command in Unix, you provide a sequence of "words". These are not processed or reinterpreted at all; the first word is the command to invoke and the remaining words are its arguments. (In a Dockerfile, compare to the JSON-array exec-form syntax of CMD.)

In your examples, you're trying to mix this string-array syntax with shell constructs. If you try to run "bash", "foo", "&&", "bar", then it will specifically use bash as an interpreter to run foo as a shell script, passing it two arguments && and bar. In your very first example you use sh -c passing the rest of the command as a single argument. This has the right effect, but it makes you vulnerable to a shell injection attack if, for example, the folder name includes a semicolon.

String folder = "; rm -rf /;";
// uh oh
Runtime.getRuntime().exec(new String[]{"bash", "-c", "cd " + folder + "&& ..."});

All of your commands are of the form cd directory && command. You can use ProcessBuilder.directory() to set the directory name, and then directly run command without actually involving a shell. This both solves your problem and the security issue.

Process process = new ProcessBuilder()
  .directory(new File("/home/alex/IdeaProjects/test/src/main/java/Docker"))
  .command("docker", "build", " -f", "Dockerfile.txt", "-t", "java-app1", ".")
  .start();

The actual right answer to this is to use a Docker SDK rather than invoke the docker CLI tool. Using docker-java, for example, you might write

DockerClientConfig standard = DefaultDockerClientConfig
  .createDefaultConfigBuilder()
  .build();
DockerHttpClient httpClient = new ApacheDockerHttpClient.Builder()
  .dockerHost(config.getDockerHost())
  .sslConfig(config.getSSLConfig())
  .build();
DockerClient dockerClient = DockerClientImpl.getInstance(config, httpClient);

dockerClient.buildImageCmd()
  .withBaseDirectory(new File("/home/alex/IdeaProjects/test/src/main/java/Docker"))
  .withDockerfilePath("Dockerfile.txt")
  .withTags(Set.of("java-app1"))
  .start();
// ...and wait for its completion

Remember in any case that, if you can access the Docker socket at all, then you can launch a new container, running as root, bind-mounting the host filesystem, and take over the whole machine.