Binary operations between different integral types are performed within a “common” type defined by so called usual arithmetic conversions (see the language specification, 6.3.1.8). In your case the “common” type is unsigned int. This means that int operand (your b) will get converted to unsigned int before the comparison, as well as for the purpose … Read more
It is actually possible to get rid of the if statement and the addition if you do it like this. byte[] foobar = ..; int value = (foobar[10] & 0xff); This way Java doesn’t interpret the byte as a negative number and flip the sign bit on the integer also.
Something like this? int x = -1; long y = x & 0x00000000ffffffffL; Or am I missing something? public static long getUnsignedInt(int x) { return x & 0x00000000ffffffffL; }
You can’t, really. Java doesn’t have any unsigned data types, except char. Admittedly you could use char – it’s a 16-bit unsigned type – but that would be horrible in my view, as char is clearly meant to be for text: when code uses char, I expect it to be using it for UTF-16 code … Read more
Because typical floating point formats don’t support unsigned numbers. See, for instance, this list of IEEE 754 formats. Adding a numerical format that isn’t supported by common hardware just makes life difficult for compiler writers, and is probably not considered worth the effort.
Signed variables, such as signed integers will allow you to represent numbers both in the positive and negative ranges. Unsigned variables, such as unsigned integers, will only allow you to represent numbers in the positive and zero. Unsigned and signed variables of the same type (such as int and byte) both have the same range … Read more
What you’ve come across is some peculiar behavior that arises in C when handling expressions that contain both signed and unsigned quantities. When an operation is performed where one operand is signed and the other is unsigned, C will implicitly convert the signed argument to unsigned and perform the operations assuming the numbers are nonnegative. … Read more
It’s all in your things.size() type. It isn’t int, but size_t (it exists in C++, not in C) which equals to some “usual” unsigned type, i.e. unsigned int for x86_32. Operator “less” (<) cannot be applied to two operands of different sign. There’s just no such opcodes, and standard doesn’t specify, whether compiler can make … Read more
Division by powers of 2 is faster with unsigned int, because it can be optimized into a single shift instruction. With signed int, it usually requires more machine instructions, because division rounds towards zero, but shifting to the right rounds down. Example: int foo(int x, unsigned y) { x /= 8; y /= 8; return … Read more
For the official answer – Section 4.7 conv.integral “If the destination type is unsigned, the resulting value is the least unsigned integer congruent to the source integer (modulo 2n where n is the number of bits used to represent the unsigned type). [ Note: In a two’s complement representation, this conversion is conceptual and there … Read more