Are there any programming defects in this Java code?

Question

    import java.lang.*;
import java.io.*;

class test 
{
    public static void main(String[] a) throws Exception
    {
        int i;
        String[] str = new String[]{"javac","example.java"};
        String[] str1 = new String[]{"java","example"};
        Runtime r = Runtime.getRuntime();
        Process p = null;
        Process p1 = null;
        p=r.exec(str);
        p1=r.exec(str1);
        InputStreamReader reader = new InputStreamReader (p1.getInputStream ());
        BufferedReader br = new BufferedReader(reader);
        FileWriter fw = new FileWriter("this.txt",true);
        char[] c = new char[1];
        while ((i=br.read())!=-1)
        {
            c[0]     = (char) i ;
            fw.write(c);
            c = new char[1];
        }
        fw.close();
    }
}

this a simple program using runtime class. is there any termination of 'process' code need to be employed?

Thanks in advance!!!

Answer 1

1 . There's no reason to initialize the process objects to null.

Just do:

Process p = r.exec(str);
Process p1 = r.exec(str1);

While you're at it, better variable names would help

2 . You can improve performance by reading and writing more than 1 character at a time:

3 . You may want to explicitly specify encodings, rather than using the platform default.

InputStreamReader reader = new InputStreamReader (p1.getInputStream (), inputCharsetName);
BufferedReader br = new BufferedReader(reader);
FileOutputStream fos = new FileOutputStream("this.txt", true);
Writer writer = new OutputStreamWriter(fos, outputCharsetName);

Answer 2

The input stream is never closed, and I recommend closing the writer in a finally block.

Answer 3

is there any termination of 'process' code need to be employed?

I think that depends on the processes - will they terminate on their own? (And do you want them to terminate when this program does?)

You can terminate easily with:

p.destroy();
p1.destroy();

Answer 4

Your program will not work the way as you would expect it to. ie. it will try to run the example.class before even the compilation of example.java is completed.

Answer 5

You should use Process.waitFor() in order to let the compiling process complete. Otherwise you will likely try to run a non-existing class file because compilation took too long.

The buffer is too small, everytime you do something like char[] c = new char[1]; // lolz array with exactly one element you should look at least twice.

Answer 6

First, you need to wait for the compilation to complete before executing the second process. Use the waitFor() method:

int compilationResult = -1;
try {
  compilationresult = p.waitFor();
}
catch (InterruptedException ie) {
  ...
}

Then check compilationResult (a value of 0 indicates successful compilation) to determine whether to continue with the rest of the code.

Secondly, if you're finished with the p1 process after processing its output, then you should either wait for it to finish, or kill it yourself - depending on whether you expect the process to complete by itself or not.

To wait for the process to complete normally, use a similar block of code to above, by enclosing p1.waitFor() in a try/catch block.

To kill it yourself, use:

p1.destroy();

After you're sure the process has completed, you might then want to check the exit value with p1.exitValue(). Why be so careful about this? Well, you probably shouldn't trust the output you're collecting and writing to this.txt until you're sure the process executed correctly.