Como rodar um programa externo?

package corretor;

import java.io.BufferedReader;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import javax.sound.midi.SysexMessage;
import logica.Constantes;

/**
 * Classe que executa processos externos.
 */
public class Executador {
    
    private int exitVal = 0;
    private BufferedReader br = null;
    private String[] args = null;
    private File diretorio = null ;
    private String entrada = null;
    private String saida = null;
    private long tempoExecucao = 0;
    private StreamGobbler outputGobbler = null;
    private static Process proc = null;
    boolean travou = false;
 
    /**
     * Cria uma nova instância da classe Executador.
     * @param diretorio O diretório padrão que terá o processo.
     * @param args Um vetor de argumentos que serão executados no processo.
     * @param entrada A entrada que o processo terá.
     */
    public Executador(File diretorio, String[] args, String entrada) {
        this.diretorio = diretorio;
        this.args = args;
        this.entrada = entrada;
    }

    /**
     * Executa um determinado processo com os parâmetros passados no construtor.
     */
    public void executar() {
        try {
            Runtime rt = Runtime.getRuntime();
            System.out.println("Setando diretório: " + diretorio.getAbsolutePath());
            String texto = "";
            for (int i = 0; i <= args.length - 1; i++) {
                texto += args[i] + " ";
            }
            System.out.println("Executando:" + texto);
            String[] env = new String[] {"PATH=" + System.getenv("PATH")};
            proc = rt.exec(args, env, diretorio);
            
            // alguma mensagem de erro?
            StreamGobbler errorGobbler = new 
                StreamGobbler(proc.getErrorStream(), "ERRO");

            // alguma saída?
            outputGobbler = new StreamGobbler(proc.getInputStream(), "SAÍDA");

            long tempoInicial = System.currentTimeMillis();
            errorGobbler.start();
            outputGobbler.start();
            
            if (entrada != null) {
                OutputStream out = proc.getOutputStream();
                out.write((entrada).getBytes());
                out.flush();
                out.close();
                
                testarTravamento();
                
                exitVal = proc.waitFor();
                proc.destroy();
                outputGobbler.parar();
                saida = outputGobbler.getSaida();
            } else {
                testarTravamento();
                exitVal = proc.waitFor();
            }
            tempoExecucao = System.currentTimeMillis() - tempoInicial;
             
            System.out.println("Valor de Saída: " + exitVal);
        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
    
    /**
     * Retorna o tempo de execução do processo.
     */
    public long getTempoExecucao() {
        return tempoExecucao;
    }
    
    /**
     * Retorna a saída do processo.
     */
    public String getSaida() {
        return saida;
    }
    
    /**
     * Retorna o valor de saída do processo.
     */
    public int getValorSaida() {
        return exitVal;
    }
    
    private void testarTravamento() {
        travou = false;
        new Thread(new Runnable() {
            public void run() {
                try {
                    Thread.currentThread().sleep(Constantes.getTempoMaximoExecucao());
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if (outputGobbler.isAlive()) {
                    travou = true;
                    proc.destroy();
                    String processo = args[2].substring(0, args[2].length() - 4);
                    String[] argsD = new String[] { "cmd", "/C", "tskill", processo};
                    Executador exec = new Executador(diretorio, argsD, null);
                    exec.executar();
                }
            } 
        }).start();
    }
    
    /**
     * Classe interna utilizada para capturar as saídas e mensagens de erro
     * de um determinado processo.
     */
    class StreamGobbler extends Thread {
        InputStream is = null;
        String type = null;
        String saida = null;
        boolean flagParar = false;
        
        public void parar() {  
            flagParar = true;  
        } 

        StreamGobbler(InputStream is, String type) {
            this.is = is;
            this.type = type;
            this.saida = new String();
        }

        public void run() {
            try {
                InputStreamReader isr = new InputStreamReader(is);
                br = new BufferedReader(isr);
                String line = null;
                while ( (line = br.readLine()) != null) {
                    System.out.println(type + ">" + line);
                    if (saida != null) {
                        saida += line + "\n";
                    }
                    if (flagParar) {
                        System.out.flush();
                        return;
                    }
                }
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
        }

        /**
         * Retorna a saída do processo.
         */
        public String getSaida() {
            return saida;
        }
    }
}

String[] args = new String[] { "cmd", "/C", "programa.exe" };
File diretorio = new File("c:\Programas em Teste\");
String entrada = "1 5 10\nPedro\n9";

Executador ex = new Executador(diretorio, args, entrada);
ex.executar();
long tempoExecucao = ex.getTempoExecucao();
String saida = ex.getSaida();

OutputStream out = proc.getOutputStream();  
out.write((entrada).getBytes());  
out.flush();  
out.close();