You should really look at Process Builder. It is really built for this kind of thing.

ProcessBuilder pb = new ProcessBuilder("myshellScript.sh", "myArg1", "myArg2");
 Map<String, String> env = pb.environment();
 env.put("VAR1", "myValue");
 env.remove("OTHERVAR");
 env.put("VAR2", env.get("VAR1") + "suffix");
 pb.directory(new File("myDir"));
 Process p = pb.start();

You could use Runtime.exec(). Here is a very simple example:

import java.io.*;
import java.util.*;

class Foo {
    public static void main(String[] args) throws Exception {
        // Run command and wait till it's done
        Process p = Runtime.getRuntime().exec("ping -n 3 www.google.de");
        p.waitFor();

        // Grab output and print to display
        BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));

        String line = "";
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
    }
}

Your code is right and I am sure you are not getting exceptions, if you read using proc.getErrorStream() you will not get anything.
Commands 100% get executed that way, having said that now thing is that you are echo'ing something and you need to read it back using BufferedReader.

Check below example which will successfully create a directory called "stackOverflow" and print what you are echo'ing. For the putting it into a log file I am afraid that you can do it using ">", you may have to use some editor command or create file using Java.

Bottom line: Runtime.getRuntime().exec("command") is the correct and defined way to execute Unix commands or scripts from Java and it WORKS.

test.sh

#!/bin/bash
echo "hola"
mkdir stackOverflow

Test.java

import java.io.*;
public class Test {

        public static void main(String[] args) throws Exception {
                try {
                        String target = new String("/home/hagrawal/test.sh");
// String target = new String("mkdir stackOver");
                        Runtime rt = Runtime.getRuntime();
                        Process proc = rt.exec(target);
                        proc.waitFor();
                        StringBuffer output = new StringBuffer();
                        BufferedReader reader = new BufferedReader(new InputStreamReader(proc.getInputStream()));
                        String line = "";                       
                        while ((line = reader.readLine())!= null) {
                                output.append(line + "\n");
                        }
                        System.out.println("### " + output);
                } catch (Throwable t) {
                        t.printStackTrace();
                }
        }
}

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 should be able to use Runtime.exec() or ProcessBuilder to invoke a shell to run a script, but the whole process is full of pitfalls.

I would suggest reading this article:

https://www.infoworld.com/article/2071275/when-runtime-exec---won-t.html

which explains many of these pitfalls, and how to avoid them. In particular, on Linux you'll almost certainly need to consume stdout and stderr from your shell invocation -- that's sometimes true even if the script doesn't produce any output. You'll also need to be careful how you handle spaces and special characters -- if there are any -- in the arguments to your script. The parser that Java uses for the command line blindly breaks a command line at whitespace.

Make sure bash.exe is in PATH as Charles Duffy said. Having bash installed without that being the case, is, after all, not much use. When that's the case and your script is in the current directory, the following is equivalent to your code:

public class Test {
    public static void main(String[] args) throws Exception {
        String[] command = { "bash", "test.sh" };
        ProcessBuilder pb = new ProcessBuilder(command).inheritIO();
        Process p = pb.start();
        p.waitFor();
        System.out.println(p.exitValue());
    }
}