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 

First, don't use Runtime.exec. Always use ProcessBuilder, which has much more reliable and predictable behavior.

Second, everything in your string is being passed as a single command, including the vertical bars. You are not passing it to a shell (like /bin/bash), so piping commands to one another won't work.

Third, you need to consume the command's output as it is running. If you call waitFor() and then try to read the output, it may work sometimes, but it will also fail much of the time. This behavior is highly operating system dependent, and can even vary among different Linux and Unix kernels and shells.

Finally, you don't need grep or wc. You have Java. Doing the same thing in Java is pretty easy (and probably easier than trying to invoke a shell so piping will work):

ProcessBuilder builder =
    new ProcessBuilder("asterisk", "-rx", "ss7 linestat");
builder.inheritIO().redirectOutput(ProcessBuilder.Redirect.PIPE);
Process p = builder.start();

int freeE1s = 0;
try (BufferedReader buf =
        new BufferedReader(new InputStreamReader(p.getInputStream()))) {
    String line;
    while ((line = buf.readLine()) != null) {
        if (line.contains("Idle")) {    // No need for 'grep'
            freeE1s++;                  // No need for 'wc'
        }
    }
}

p.waitFor();

System.out.println(freeE1s);

As of Java 8, you can make it even shorter:

ProcessBuilder builder =
    new ProcessBuilder("asterisk", "-rx", "ss7 linestat");
builder.inheritIO().redirectOutput(ProcessBuilder.Redirect.PIPE);
Process p = builder.start();

long freeE1s;
try (BufferedReader buf =
        new BufferedReader(new InputStreamReader(p.getInputStream()))) {
    freeE1s = buf.lines().filter(line -> line.contains("Idle")).count();
}

p.waitFor();

System.out.println(freeE1s);