Why can't I put hex value to byte array in java?

Byte is a signed datatype in Java. It can take values from -128 (-0x80) to 127 (0x7f). Some of your constants won't fit in this range and are not, therefore, valid byte's. That's unlike C++, where BYTE is usually defined to be unsigned char. Also, Java is stricter about datatype conversions with loss of precision.

So 0xF2 is not a valid byte literal. It's a valid short and int and long. Java employs the crazy notion of negative hex literals for values like those. A negative hex literal for 0xF2 would be -0x0e.

Depending on your situation, either use a larger datatype, or use inline conversion (like (byte)0xF2), or use something like Excel to convert your literals of value 0x80 and more to negative-hex representation.

Bytes in Java (as all primitive number types) are signed.

The valid range of byte values is -128 to 127.

Thus, there is no byte that has the same value as the integer 0xFF = 255, but you need a cast, which is what your compiler is warning you of. Note that 255 will actually become -1.

Try the following code yourself:

byte test = (byte) 0xFF;
System.out.println(test == 0xFFFFFFFF); // True: -1 == -1 (as int)
System.out.println((byte)0xFF == 0xFFFFFFFF); // True: -1 == -1 (as int)
System.out.println(0xFF == (byte) 0xFFFFFFFF); // False: +255 != -1 (as int)
System.out.println((byte)0xFF == (byte) 0xFFFFFFFF); // True: -1 == -1 (as byte)
byte warn = (byte) 0xFF; // "error: possible loss of precision" unless cast
byte nowarn = -0x1; // No error. -0x1 is a *valid* byte in Java!
System.out.println(warn == nowarn); // True: -1 == -1 (as bytes)
System.out.println((int)warn == (int)nowarn); // True: -1 == -1 (as int, too)

This should print true, true, false, true, true, true as indicated.

You must realize that == when applied to byte == int, converts the (signed) byte to a (signed) integer, and byte -1 should of course become int -1.

Simply cast every byte:

byte a[]={(byte)0x01,(byte)0x01,(byte)0x01,}

As an alternative, in Java 7 you write byte literals in binary notation. eg. 0b101 is 5.

Instead of taking 0XFF we could use 0X7F and follow up the code as below

byte[] ba = new byte[charArray.length*2];
int j = 0;
byte mask = (byte) 0x7f;
System.out.println("mask value is:" + mask);

for (int i = 0; i < charArray.length; ++i, j+=2) {
    byte upper8bits = (byte) ((byte)(charArray[i] >> (1<<3)) & mask);
    byte lower8bits = (byte) ((byte) charArray[i] & mask);
    ba[j] = upper8bits;
    ba[j+1] = lower8bits;
    System.out.println("byte[]:" + Integer.toHexString(ba[j+1]));
}