Thread: Can anyone point me in the right direction dealing with bytes

does anyone know any good tutorials or information on working with bytes like taking a file putting the bytes into an array, searching through the bytes, displaying them etc? any info of this kind is greatly appreciated thanks

also anything to do with signed and unsigned integers and such

Originally Posted by derekxec

...also anything to do with signed and unsigned integers and such

The bottom line is that the creators and maintainers of Java decided (waaaay back when) that it's just too confusing to have to explain the difference between treatment of signed integer data types and unsigned integer data types to new (and some not-so-new) programmers, so: In Java there are no unsigned integer data types. (Really: no unsigned integer fundamental data types.) Period. Full Stop.

If you read (carefully) tutorial or other reference material you will see that the low-level read() functions that grab a single byte from a file return an int, not a byte. That way, an end-of-file condition (trying to read past the last byte in the file) can be indicated to the calling function by returning an integer value of -1, whereas all valid file byte values (0-255) are returned in the lower eight bits of the integer return value.

That's a fine point (well, maybe not really a fine point, but it is fundamental) that somehow gets overlooked by lots of people. If the file just contains ASCII characters (0-127), it doesn't really make much difference, but when you are reading binary files (or any other kind of file that may contain byte values that would be greater than 127), it can make a huge difference in behavior.

Also note...

For the write() functions that put out a single character to the disk file, the argument when calling write() is an int. If you call it with a byte argument, the byte gets "promoted" to a signed int, but that's OK, since the function itself will ignore the upper 24 bits, and the lower eight bits will be sent to the file, as you undoubtedly intended.

A simple non-file example:

public class Z
{
    public static void main(String [] args)
    {
        byte x = 127;
        ++x;
        int ix = (int)x;
        int iy = (int)x & 0xff;
        System.out.printf(" x = %d\n", x);
        System.out.printf("ix = %d\n", ix);
        System.out.printf("iy =  %d\n", iy);
    }
}

Output:

 x = -128
ix = -128
iy =  128

Of course having bypassed any meaningful exposition about signed integer data types vis-à-vis unsigned integer data types, now someone has to explain why incrementing a byte value of 127 gives -128. Oh, well...



Cheers!


Z

Just to clarify, there is only one unsigned data-type in Java: char (well, I suppose you could consider boolean to be unsigned). It's a 16-bit unsigned variable.

Also, it's possible to perform some operations on signed data and have the results be the same as if it were unsigned. These operations are addition, subtraction, and all bit-wise operators except >> (signed shift right). Displaying the correct value may be tricky, but it can be done using bitwise operators instead of casting:

// display an "unsigned byte"
byte val = -100;
short display = 0xFF & val;
System.out.println(display); // prints 156, the unsigned bit equivalent of -100