How do I execute an external .exe?

Question

easy question I hope.
I'm just making a front-end program with some buttons on it. You push a button, and when you do, an external EXE is called.

Answer 1

Here is something that should help. Runtime.exec() is actually quite complicated even though it's interface is seemingly not (hinting that it's a bad API design):
You should be able to fill in any missing external references w/o difficulty.
package com.solutions400;
import java.util.*;
import java.io.*;
import java.util.logging.*;
* Wraps the complexities of Runtime.exec().
* @author  Joshua Allen
* @created December 10, 2002
public class RuntimeExec
     private static final Logger myLog = SystemDetails.log();
     private Process myProc;
     private StreamGobbler myErrorStream, myOutStream;
     // Access is synchronized so that the check and interrupt call can be an
     // atomic action.  Hence the reason for not using Boolean.FALSE.
     private MutableBoolean myIsWaiting = new MutableBoolean(false);
      * Number of milliseconds to wait for a process to finish before
      * interrupting it when getting the output and/or exit value.
     public final static int TIMEOUT = 1000 * 60;
      * Value returned by exitValue() if the process did not terminate before the
      * timeout and hence true exitValue is unknown.
     public final static int EXIT_VALUE_INTERRUPTED = -999;
     public RuntimeExec(String command)
     throws IOException
          Runtime os = Runtime.getRuntime();
          myProc = os.exec(command);
          myErrorStream = new StreamGobbler(myProc.getErrorStream());
          myOutStream = new StreamGobbler(myProc.getInputStream());
          myErrorStream.start();
          myOutStream.start();
      * @return stderr ouput from command.  Will only wait at most a minute for
      *     the
     public String getError() {
          try {
               myErrorStream.join(TIMEOUT);
          } catch (InterruptedException e) {
               myLog.log(Level.FINE, "Joining interrupted.", e);
          return myErrorStream.getOut();
      * @return stdout output from command. 
     public String getOut() {
          try {
               myOutStream.join(TIMEOUT);
          } catch (InterruptedException e) {
               myLog.log(Level.FINE, "Joining interrupted.", e);
          return myOutStream.getOut();
      * @return exit value of command.  EXIT_VALUE_INTERRUPTED if the process
      *     was interrupted before it terminated.
     public int exitValue() {
          final Thread thisThread = Thread.currentThread();
          Thread t = new Thread() {
               public void run() {
                    Helpers.sleep(TIMEOUT);
                    synchronized (myIsWaiting) {
                         if (myIsWaiting.get()) {
                              thisThread.interrupt();
          t.start();
          synchronized (myIsWaiting) {
               myIsWaiting.set(true);
          waitFor();
          synchronized (myIsWaiting) {
               myIsWaiting.set(false);
          try {
               return myProc.exitValue();
          } catch (IllegalThreadStateException e) {
               myLog.log(Level.FINE, "Process did not exit.", e);
               if (myLog.isLoggable(Level.FINER)) {
                    myLog.exiting(Runtime.class.getName(), "exitValue",
                              new Integer(EXIT_VALUE_INTERRUPTED));
               return EXIT_VALUE_INTERRUPTED;
      * Waits for the process to finish.
     public void waitFor() {
          try {
               myProc.waitFor();
          } catch (InterruptedException e) {
               myLog.log(Level.FINE, "Waiting interrupted.", e);
     private class StreamGobbler
     extends Thread
          Reader myIn;
          CharArrayWriter myBufOut = new CharArrayWriter();
          StreamGobbler(InputStream in)
               myIn = new BufferedReader(new InputStreamReader(in));
          public String getOut() {
               return new String(myBufOut.toCharArray());
          public void run()
               Writer out = null;
               try     {
                    out = new BufferedWriter(myBufOut);
                    char[] buf = new char[SystemDetails.BUF_SIZE];
                    int numRead;
                    while ((numRead = myIn.read(buf)) >= 0) {
                         out.write(buf, 0, numRead);
               } catch (IOException e) {
                    myLog.log(Level.FINE, "Error retrieving output.", e);
                    PrintWriter pw = new PrintWriter(out);
                    e.printStackTrace(pw);
               } finally {
                    Helpers.close(out);
     }///:>
}///:~