title: Java - converting int to byte array without considering sign
body: <p>To convert an int into a byte array, I'm using the following code: </p>
  
  <pre><code>int a = 128;
  byte[] b = convertIntValueToByteArray(a);
  private static byte[] convertIntValueToByteArray(int intValue){
    BigInteger bigInteger = BigInteger.valueOf(intValue);
    byte[] origByteArray = bigInteger.toByteArray();
    byte[] noSignByteArray = new byte[bigInteger.bitLength()/8];
  
    if(bigInteger.bitLength()%8!=0){
      noSignByteArray = origByteArray;
    }else{
      System.arraycopy(origByteArray,1,noSignByteArray,0,noSignByteArray.length);
    }
  
    return noSignByteArray;
  }
  </code></pre>
  
  <p>There are two things which I'm attempting to do.</p>
  
  <p>1)I need to know the number of bytes (rounded up to the closes byte) of the original integer. However, I don't need the additional bit that is added for the sign bit when I call the toByteArray() method. This is the reason why I have the helper method. So in this example, if I don't have the helper method, when I convert 128 to a byte array I get the length to be 2 octets because of the sign bit but I'm only expecting it to be one octet.</p>
  
  <p>2)I need the positive representation of the number. In this example, if I attempt to print the first element in array b, I get -128. However, the numbers I will be using will be positive numbers only so what I actually want is 128. I'm limited to using a byte array. Is there a way to accomplish this? </p>
  
  <p><strong>Updated Post</strong></p>
  
  <p>Thank you for the responses. I haven't found the exact answer I was looking for so I'll attempt to give more details. Ultimately, I want to write values of different types over a data output stream. In this post, I'd like to clarify what happens when ints are written to a data output stream. I've come across two scenarios.</p>
  
  <p>1)</p>
  
  <pre><code>DataOutputStream os = new DataOutputStream(this.socket.getOutputStream());
  
  byte[] b = BigInteger.valueOf(128).toByteArray();
  
  os.write(b);
  </code></pre>
  
  <p>2)</p>
  
  <pre><code>DataOutputStream os = new DataOutputStream(this.socket.getOutputStream());
  os.write(128);
  </code></pre>
  
  <p>In the first scenario, when the bytes are read from a data input stream, it seems that the first element in the byte array is a 0 to represent the msb and the second element in the array contains the number -128. However, since the msb is 0 we would be able to determine that it is intended to be a positive number. In the second scenario, there is no msb and the only element present in the byte array read from the input stream is -128. I was expecting the write() method of the data output stream to convert the int into the byte array in the same manner as the toByteArray() method does on a BigInteger object. However, this doesn't seem to be the case as the msb is not present. So my question is, how in the second scenario are we supposed to know that 128 is supposed to be a positive number and not a negative one if there is no msb.</p>