Use Process.getInputStream() to get an InputStream that represents the stdout of the newly created process.

Note that starting/running external processes from Java can be very tricky and has quite a few pitfalls.

They are described in this excellent article, which also describes ways around them.

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.

The primary reason why this doesn't work is that `$2` is not the same as `ls -1 | tail -1`, even when $2 is set to that string.

If your script accepts a literal string with a command to execute, you can use eval to do so.

I created a complete example. Please copy-paste it and verify that it works before you try applying any of it to your own code. Here's Test.java:

Copyimport java.io.*;

public class Test {
  public static void main(String[] args) throws Exception {
    String[] command = { "./myscript", "key", "ls -t | tail -n 1" };
    Process process = Runtime.getRuntime().exec(command);
    BufferedReader reader = new BufferedReader(new InputStreamReader(
        process.getInputStream()));
    String s;
    while ((s = reader.readLine()) != null) {
      System.out.println("Script output: " + s);
    }
  }
}

And myscript:

Copy#!/bin/bash
key="$1"
value=$(eval "$2")
echo "The command  $2  evaluated to: $value"

Here's how we can run myscript separately:

Copy$ ls -t | tail -n 1
Templates

$ ./myscript foo 'ls -t | tail -n 1'
The command  ls -t | tail -n 1  evaluated to: Templates

And here's the result of running the Java code:

Copy$ javac Test.java && java Test
Script output: The command  ls -t | tail -n 1  evaluated to: Templates 

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 read InputStream from the process, here is an example:

Edit I modified the code as suggested here to receive the errStream with the stdInput

ProcessBuilder builder = new ProcessBuilder("command goes here");
builder.redirectErrorStream(true);
Process process = builder.start();
InputStream is = process.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(is));

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

For debugging purpose, you can read the input as bytes instead of using readLine just in case that the process does not terminate messages with newLine