在Java中将输入流转换为数组的最佳方式是什么？

Question

我正在写代码，它将接受来自arduino的字节值，将它们存储为数组，然后执行一些数学计算，然后将值发送回arduino。现在我可以向Arduino发送127个值，并返回127个值，但是它们是字符串类型，并且任何使用Integer类转换这些字符串的尝试都会导致程序挂起。我相信缓冲区有时会提供空字符串，而parseInt（）不知道该怎么做。有没有人有什么建议？我非常喜欢java的初学者，并且愿意提供更好的解决方案。

这里是我的代码：

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

如果你想从你的流得到整型，它是一个BuffereInputStream和使用更方便read（）方法返回一个int - > no转换需要。在SerialReader类 补充一点：

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

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

不要忘记关闭（），您的流时，您已经阅读所有的数据。这在编写时更重要，因为如果不关闭（），则不会写入所有数据（除非在之前使用flush（））。

Answer 2

我并没有完全得到说明。
但问题标题的答案在这里。
Convert InputStream to byte array in Java

Answer 3

从corsiKa的回答Determine if a String is an Integer in Java，您可以检查一个字符串是这样一个有效的int：

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; 
}