Edit - Stack Overflow

You are not logged in. Your edit will be placed in a queue until it is peer reviewed.

We welcome edits that make the post easier to understand and more valuable for readers. Because community members review edits, please try to make the post substantially better than how you found it, for example, by fixing grammar or adding additional resources and hyperlinks.

Required fields*

Rev

Required fields*

JAVA and byte arrays

I'm trying to use an API where there's a socket is used to communicate. A request is made up of different parts and one of them is the header which is stated as so:

Fixed header: 2 bytes, fixed at 0xffff

Generally I'm not good with bytes and streams, since I've never used it. So how should i create said byte array? I've tried the following

byte[] header = new byte[]{(byte)0xff, (byte)0xff};

But they bytes each become -1, which I believe is because 0xFF translates to 255 which is outside of the signed byte range (-128 to +127), but then how do I create a header like that?

Answer*

You just did it.

In the end, computers just know about bits. The rest is what the code, and the humans looking at it, make of it. A bit is a 0 or a 1. If you bought a computer with 4GB RAM, then your computer can remember 34359738368 of those.

That's a bit unwieldy, so AMD, or intel, or TSMC, or whomever baked your chip, baked into the chip's design that the chip groups them in sets of 8 (and for certain jobs, in sets of 64 or even higher). But that's where it ends. It's just bits, really. Negative number? What's that? 2? What is this 2 you speak of. I know only 0 and 1.

So that's unwieldy too, so we humans don't wanna say: This byte holds value 00000101. We'll just say 'that holds 5'.

```
bits = decimal
00000000 = 0
00000001 = 1
00000010 = 2
00000011 = 3
00000100 = 4
00000101 = 5
... and so on
```

That's great, but what about -1? We just have `0` and `1`. There's no - so how do we do this?

That's where it gets interesting. It's a convention, not something in the computer. There's this thing called two's complement: We all agree to check the first bit. If it is a 1, then we shall call this `-X`, where X is found by applying the following algorithm: Flip every bit (all zeroes become one, all ones become zeroes), and add 1 to it. 

```
11111011 = -5.

Why? Well, flip every bit: 00000100
then add 1 to it : 00000101

which is 5.
```

But that immediately eats half of what we can represent. After all, the biggest number we can now store in a byte is 127: `01111111`, which is 127. If we add 1 to this number, then we get to `10000000`, but hey that starts with a 1 bit, so assuming we are all in agreement that this means it is negative, that means `1000000` is -128 (bit of an exotic case).

And sometimes that's annoying or not worth it. So sometimes we all agree that the number __cannot be negative at all__, and `1000000` is just 128. and `11111111` is just 255.

The computer has no idea. 255 is `11111111` and so is -1. So what's `11111111`? The computer doesn't know. It doesn't even know what `2` is. It just knows zeroes and ones, and as far as the computer is concerned, `11111111` is what it is. (the math works out that + and - 'just work' regardless of whether we decree these numbers are to be seen as two's complement signed or not, cool, huh? Try it! If `11111011` is both -5 as well as 251 depending on the opinion of the one reading off the number, what happens? -5 + 2 is -3. 251 + 2 is 253. `-3` and `253` boil down to the same sequence of bits. Just an example. This is, incidentally, why we do the weirdo 'flip all bits and add 1' stuff. So that + and - just work and you don't need to pass along whether you consider the bits 'signed' or 'unsigned'.

In java, __all__ numeric types except `char` (which is a numeric type. You'd think it represents a character, but it really doesn't) are signed. `byte` is 'signed 8-bit number' (so, can represent from `-128` to `+127`, inclusive). char is the only exception, that is an 'unsigned 16-bit number', so can hold from `0` to `65535`, inclusive. It's just if you e.g. call `System.out.println((char) 65);`, the println method will interpret that number as: "Look this up in the unicode table and print whatever you find there", so that prints 'A'. That's part of the source code of that particular println method, it's nothing inherent about the `char` type in java, which is just 'a number between 0 and 65535'.

So, when you print your byte array containing `0xFF, 0xFF` in java, because java agreed that we consider it signed, it prints -1, -1. But that's just java-ese for 0xFF, 0xFF. Your byte array contains 0xFF, 0xFF because __at the bit level -1 and 255 are the exact same number__. For bytes anyway. Not so for all the other ones (char, short, int, long).

To recap:
```
byte x = (byte) 200;
byte x = (byte) 0xC8;
byte x = -56;
```

In all these cases, x ends up holding the bits `11001000`. __There is no way to tell the difference__. You can't ask the system: So, uh, is this x equal to 200, or 0xC8, or -56? What was used to set it? Because the computer does not know - the compiler translates all of the above code to the exact same end result, which is 11001000.

255 __is__ -1.

Draft saved

Draft discarded

Edit Summary*

Cancel

Add a comment |

How to Edit

Correct minor typos or mistakes
Clarify meaning without changing it
Add related resources or links
Always respect the author’s intent
Don’t use edits to reply to the author

How to Format

create code fences with backticks ` or tildes ~
```
like so
```
add language identifier to highlight code
```python
def function(foo):
print(foo)
```
put returns between paragraphs
for linebreak add 2 spaces at end
_italic_ or **bold**
indent code by 4 spaces
backtick escapes `like _so_`
quote by placing > at start of line
to make links (use https whenever possible)

<https://example.com>

[example](https://example.com)

<a href="https://example.com">example</a>

formatting help »
answering help »

How to Tag

A tag is a keyword or label that categorizes your question with other, similar questions. Choose one or more (up to 5) tags that will help answerers to find and interpret your question.

complete the sentence: my question is about...
use tags that describe things or concepts that are essential, not incidental to your question
favor using existing popular tags
read the descriptions that appear below the tag

If your question is primarily about a topic for which you can't find a tag:

combine multiple words into single-words with hyphens (e.g. python-3.x), up to a maximum of 35 characters
creating new tags is a privilege; if you can't yet create a tag you need, then post this question without it, then ask the community to create it for you

popular tags »

lang-java

CollectivesTM on Stack Overflow

JAVA and byte arrays

Answer*