What is the best way to convert an Input Stream to an Array in Java?

Question

I'm writing code that will accept byte values from an arduino, store them as an array, preform some mathematical calculations, and then send the values back to the arduino. Right now I can send 127 values to the Arduino and I get 127 values back, but they are of type string, and any attempts to use the Integer class to convert these strings results in a program hang. I believe the buffer sometimes provides empty strings, and parseInt() doesn't know what to do. Does anyone have any suggestions? I'm very much a beginner in java and would be open to better solutions.

Here is my code:

package GridMap;

import gnu.io.CommPort;
import gnu.io.CommPortIdentifier;
import gnu.io.SerialPort;
import gnu.io.SerialPortEvent;
import gnu.io.SerialPortEventListener;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;

/**
 *
*/
public class SerialWriter implements Runnable {

OutputStream out;
byte array[] = new byte[10];
byte c;

public SerialWriter(OutputStream out, byte[] in) {
    this.out = out;
    array = in;
}

public void run() {

        try {
            int index = 0;
            c = array[index];
            while ((c) > -1) {
                this.out.write(c);
                System.out.println("sent " + c);
                if (index == 64){
                    Thread.sleep(2);
                }
                index++;
                c = array[index];
            }
            TwoWaySerialComm.recieve();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(-1);
        }


}
}

public class SerialReader implements Runnable {
static byte[] output = new byte[128];
private InputStream in;
private int[] buffer = new int[11];
static SerialPort thisSerialPort;
static OutputStream thisOut;
static String total = new String("333");

public SerialReader(InputStream in) {
    this.in = in;

    for (byte i = 0; i < 127; i++) {
            output[i] = i;
        }
    output[127] = - 1;
}
public void run ()
    {
        byte[] buffer = new byte[1024];
        int len = -1;
        int index = 0;
        int value;
        try
        {
            Thread.sleep(200);

            while (( len = this.in.read(buffer)) > -1 && index < 200)
            {


                String string = new String(buffer, 0, len);
                //value = Integer.getInteger(string, len);
               // System.out.print(value);
                //System.out.println("buffer" + value);
                System.out.print(string);
                index++;

            }


            TwoWaySerialComm.send(output);
        }
        catch (Exception e )
        {
            e.printStackTrace();
        } 
    }
public static int byteArrayToInt(byte[] b) 
{
return   b[3] & 0xFF |
        (b[2] & 0xFF) << 8 |
        (b[1] & 0xFF) << 16 |
        (b[0] & 0xFF) << 24;
}


}
public class TwoWaySerialComm {

static SerialPort serialPort;
static OutputStream out = null;
static InputStream in;
static Thread receiveThread;
static Thread sendThread;
static byte[] output = new byte[11];


public TwoWaySerialComm() {
    super();
}

void connect(String portName) throws Exception {
    CommPortIdentifier portIdentifier = CommPortIdentifier.getPortIdentifier(portName);
    if (portIdentifier.isCurrentlyOwned()) {
        System.out.println("Error: Port is currently in use");
    } else {
        CommPort commPort = portIdentifier.open(this.getClass().getName(), 2000);

        if (commPort instanceof SerialPort) {
            serialPort = (SerialPort) commPort;
            serialPort.setSerialPortParams(114400, SerialPort.DATABITS_8, SerialPort.STOPBITS_1, SerialPort.PARITY_NONE);




        } else {
            System.out.println("Error: Only serial ports are handled by this example.");
        }
    }

}

static void send(byte[] output) {
    try {
        out = serialPort.getOutputStream();
        sendThread = new Thread(new SerialWriter(out, output));
        sendThread.start();
        //sendThread.join();
    } catch (Exception e) {
        System.out.println("Port Not Avaialable (send) ");
    }
}

static void recieve(){
    try {
    in = serialPort.getInputStream();
    receiveThread = new Thread(new SerialReader(in));
    receiveThread.start();
    receiveThread.join();
    } catch (Exception e) {

    }
}

public static void main(String[] args) {
    try {

        (new TwoWaySerialComm()).connect("COM3");

        for (byte i = 0; i < 10; i++) {
            output[i] = i;
        }
        output[10] = -1;
        send(output);  



    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

public static SerialPort returnSerialPort(){
    return serialPort;
}
}

Answer 1

I did not quite get the description.
But the answer to the Title on the question is here.
Convert InputStream to byte array in Java

Answer 2

From corsiKa's answer to Determine if a String is an Integer in Java, you can check if a String is a valid int like this:

public static boolean isInteger(String s) {
    try { 
        Integer.parseInt(s); 
    } catch(NumberFormatException e) { 
        return false; 
    }
    // only got here if we didn't return false
    return true;
}

Answer 3

If you want get int from your stream, it is easier with a BuffereInputStream and use the read() method which return a int -> no conversion needed. Add this in your SerialReader class :

  Thread.sleep(200);
  BufferedInputStream input = new BufferedInputStream(in);

  while ((value = input.read()) != 1 && index < 200)
  {
    compute(value);
    index++;
  }
  input.close();

Don't forget to close() your stream when you have read all the data. This is more important when you write, because if you don't close() not all data are written (except if you flush() before).