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 the OutputStream (InputStream) of your Process (and you should use a ProcessBuilder)... like so

public static void main(String[] args) {
  String filename = args[1].substring(0, args[1].length() - 5);
  String cmd1 = "javac " + args[1];
  String cmd2 = "java " + filename;

  try {
    // Use a ProcessBuilder
    ProcessBuilder pb = new ProcessBuilder(cmd1);

    Process p = pb.start();
    InputStream is = p.getInputStream();
    BufferedReader br = new BufferedReader(new InputStreamReader(is));
    String line = null;
    while ((line = br.readLine()) != null) {
      System.out.println(line);
    }
    int r = p.waitFor(); // Let the process finish.
    if (r == 0) { // No error
       // run cmd2.
    }
  } catch (Exception e) {
    e.printStackTrace();
  }
}

You can use the following code for this

import java.io.*; 

    public class doscmd 
    { 
        public static void main(String args[]) 
        { 
            try 
            { 
                Process p=Runtime.getRuntime().exec("cmd /c dir"); 
                p.waitFor(); 
                BufferedReader reader=new BufferedReader(
                    new InputStreamReader(p.getInputStream())
                ); 
                String line; 
                while((line = reader.readLine()) != null) 
                { 
                    System.out.println(line);
                } 

            }
            catch(IOException e1) {e1.printStackTrace();} 
            catch(InterruptedException e2) {e2.printStackTrace();} 

            System.out.println("Done"); 
        } 
    }

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.

 ProcessBuilder ps = new ProcessBuilder("java ", path);

You're executing java Second.java it should be java Second

replace path.replace(".java","") or create a variable without ".java"

nsaravanas@ubuntu:~$ pwd
/home/nsaravanas
nsaravanas@ubuntu:~$ javac com/test/Second.java
nsaravanas@ubuntu:~$ java com.test.Second
Hello world from Second.java
nsaravanas@ubuntu:~$

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

I don't have a windows machine to test this on, but generally to get the output for those builtins you run cmd.exe as the program and pass it the command as an argument.

Now, this has some limitations, because when the command finishes the executable stops. So if you do a cd command, it will work, but it only affect the subprocess, not your process. For those sorts of things, if you want them to change the state of your process, you'll need to use other facilities.

This version works on a Mac:

import java.io.*;
public class cmd {
    public static void  
        main(String[] argv){
        String line;
        String[] cmd = {"bash","-c","ls"};
        System.out.println("Hello, world!\n");
        try {
            Process p = Runtime.getRuntime().exec(cmd);
            BufferedReader input =
                new BufferedReader(new InputStreamReader(p.getInputStream()));
            while ((line = input.readLine()) != null) {
                System.out.println(line);
            }
            input.close();
        } catch (Exception e) {
        }
        return ;
    }
}