Here is the way to go:

Runtime rt = Runtime.getRuntime();
String[] commands = {"system.exe", "-get t"};
Process proc = rt.exec(commands);

BufferedReader stdInput = new BufferedReader(new 
     InputStreamReader(proc.getInputStream()));

BufferedReader stdError = new BufferedReader(new 
     InputStreamReader(proc.getErrorStream()));

// Read the output from the command
System.out.println("Here is the standard output of the command:\n");
String s = null;
while ((s = stdInput.readLine()) != null) {
    System.out.println(s);
}

// Read any errors from the attempted command
System.out.println("Here is the standard error of the command (if any):\n");
while ((s = stdError.readLine()) != null) {
    System.out.println(s);
}

Read the Javadoc for more details here. ProcessBuilder would be a good choice to use.

You need to use ProcessBuilder to redirect.

ProcessBuilder builder = new ProcessBuilder("sh", "somescript.sh");
builder.redirectOutput(new File("out.txt"));
builder.redirectError(new File("out.txt"));
Process p = builder.start(); // may throw IOException

Because you haven't directed it to a file.

On the command line, you've requested that it be redirected to a file. You have to do the same thing in Java, via the InputStream provided by the Process object (which corresponds to the output stream of the actual process).

Here's how you get the output from the process.

InputStream in = new BufferedInputStream( pr.getInputStream());

You can read from this until EOF, and write the output to a file. If you don't want this thread to block, read and write from another thread.

InputStream in = new BufferedInputStream( pr.getInputStream());
OutputStream out = new BufferedOutputStream( new FileOutputStream( "output.txt" ));

int cnt;
byte[] buffer = new byte[1024];
while ( (cnt = in.read(buffer)) != -1) {
   out.write(buffer, 0, cnt );
}

When your run the java program, you must be in your project root directory, and run java package.to.ClassWhichContainsMainMethod

Runtime.getRuntime().exec() will give you a Process which contains an OutputStream and an InpuStream to the executed application.

You can redirect the InputStream content to your log file.

In your case I would use this exec : public Process exec(String command, String[] envp, File dir) like this :

exec("java HelloWorld", null, new File("C:/"));

To copy data from the inputStream to the file (code stolen on this post) :

public runningMethod(){
    Process p = exec("java HelloWorld", null, new File("C:/"));
    pipe(p.getInputStream(), new FileOutputStream("C:/test.txt"));
}

public void pipe(InputStream in, OutputStream out) {
    byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
    int writtenBytes;
    while((writtenBytes = in.read(buf)) >= 0) {
        out.write(buf, 0, writtenBytes);
    }
}

I recently ran into this problem and just wanted to mention that since java 7 the process builder api has been expanded. This problem can now be solved with:

ProcessBuilder pb = new ProcessBuilder("yourcommand");
pb.redirectOutput(Redirect.INHERIT);
pb.redirectError(Redirect.INHERIT);
Process p = pb.start();

Get the output and error streams from your process and read them to see what is happening. That should tell you what's wrong with your command.

For example:

try {
    final Process proc = Runtime.getRuntime().exec("dir");

    try {
        proc.waitFor();
    } catch (final InterruptedException e) {
        e.printStackTrace();
    }

    final BufferedReader outputReader = new BufferedReader(new InputStreamReader(proc
            .getInputStream()));
    final BufferedReader errorReader = new BufferedReader(new InputStreamReader(proc
            .getErrorStream()));

    String line;

    while ((line = outputReader.readLine()) != null) {
        System.out.println(line);
    }

    while ((line = errorReader.readLine()) != null) {
        System.err.println(line);
    }
} catch (final IOException e) {
    e.printStackTrace();
}

If there is no output in either stream, then I would next examine the external program and the command being sent to execute it.

Because the Process will execute in a new thread it's likely that there is no output or incomplete output available when you come to your while loop.

Process p = pb.start();  
// process runs in another thread parallel to this one

BufferedReader bri = new BufferedReader(new InputStreamReader(p.getInputStream()));

// bri may be empty or incomplete.
while ((line = bri.readLine()) != null) {
    RESULT+=line;
}

So you need to wait for the process to complete before attempting to interact with it's output. Try using the Process.waitFor() method to pause the current thread until your process has had an opportunity to complete.

Process p = pb.start();  
p.waitFor();  // wait for process to finish then continue.

BufferedReader bri = new BufferedReader(new InputStreamReader(p.getInputStream()));

while ((line = bri.readLine()) != null) {
    RESULT+=line;
}

This is only a simple approach you could also process the output of the process while it runs in parallel but then you would need to monitor the status of the process i.e. is it still running or has it completed, and the availability of output.

This is the simplest method i found on http://tamanmohamed.blogspot.in/2012/06/jdk7-processbuilder-and-how-redirecting.html

File output = new File("C:/PBExample/ProcessLog.txt");
ProcessBuilder pb = new ProcessBuilder("cmd");
pb.redirectOutput(output);