static void checkBounds (int off, int len, int size) {/ / package-private
if ((off | len | (off + len) | (size - (off + len))) <0)
throw new IndexOutOfBoundsException ();
}
It is used to check whether the array bounds , quilt class as the ByteBuffer get, put the method call :
public ByteBuffer get (byte [] dst, int offset, int length) {
checkBounds (offset, length, dst.length);
if (length> remaining ())
throw new BufferUnderflowException ();
int end = offset + length;
for (int i = offset; i
return this;
}
My question is : checkBounds method that determines what is meant by the statement expression ( bit operation itself I have done to understand ) is off, len, (off + len) these expressions greater than 0 mean? Find doubts
------ Solution ------------------------------------ --------
mean that as long as there is a less than zero condition is established , enter judgment, an exception is thrown
only when several conditions are greater than 0 , the only condition is not satisfied , do not enter judgment not throw
------ Solution ------------- -------------------------------
If this is meant , then the "off + len" This expression is not redundant it?
off + len subscript prevent overflow , is critical
If off + len <0, then off, len at least one is negative , the conditions will be met in front of the (off <0 | | len <0), so I think this condition is redundant
integer range is -2 ^ 31 to 2 ^ 31-1 , you feel such as the sum of two 2 ^ 31-1 , the result will be positive digital ?
int off = Integer.MAX_VALUE, len = Integer.MAX_VALUE;
System.out.println(off);
System.out.println(len);
System.out.println(off + len);
output
2147483647
2147483647
-2
------ For reference only -------------------------------- -------
fact, and if (off <0 | | len <0 | | (off + len) < ; 0 | | (size - (off + len)) <0) similar results
The only difference is that logical or , just get a true stop immediately , does not check behind things, like if len <0, then checked off <0, len <0 immediately went to throw the exception , instead of continuing to check the condition of the back
The bit or is a calculation , you need to have or what the value of the four , only to judge whether < 0 , even if len <0, or will have completed all to judge
------ For reference only ---------------------------------------
If this is meant , then the "off + len" This expression is not redundant it?
------ For reference only -------------------------------------- -
If this is meant , then the "off + len" This expression is not redundant it?
off + len is to prevent subscript overflow is critical
------ For reference only --------------------- ------------------
If this is meant , then the "off + len" This expression is not redundant it?
off + len subscript prevent overflow , is critical
If off + len <0, then off, len at least one is negative , the conditions will be met in front of the (off <0 | | len <0), so I think this condition is redundant
------ For reference only --------------------- ------------------
If this is meant , then the "off + len" This expression is not redundant it?
off + len subscript prevent overflow , is critical
If off + len <0, then off, len at least one is negative , the conditions will be met in front of the (off <0 | | len <0), so I think this condition is redundant
integer range is -2 ^ 31 to 2 ^ 31-1 , you feel such as the sum of two 2 ^ 31-1 , the result will be positive digital ?
int off = Integer.MAX_VALUE, len = Integer.MAX_VALUE;
System.out.println(off);
System.out.println(len);
System.out.println(off + len);
output
2147483647
2147483647
-2
shocked ! The original play this role ah
------ For reference only ------------------------------- --------
it seems , can not have a mathematical way of thinking , but also a thinking computer. Although the points have been given , but still would like to take this post down , this type int overflow Why will certainly become negative out?
------ For reference only -------------------------------------- -
this representation about int , int is 4 bytes from 0x00000000 ~ 0xFFFFFFFF, originally from 0 to 2 ^ 32-1 , but we must work to express a negative moment, most of the Language requirements from 0x00000000 ~ 0x7FFFFFFF is positive , ie, 0 to 2 ^ 31-1 , and from 0x80000000 to 0xFFFFFFFF start is negative , that is -2 ^ 31 to -1.
In an example above , Integer.MAX_VALUE is 0x7FFFFFFF,
0x7FFFFFFF +0 x7FFFFFFF = 0xFFFFFFFE
The 0xFFFFFFFE said -2
------ For reference only ----------------------------- ----------
this representation about int , int is 4 bytes from 0x00000000 ~ 0xFFFFFFFF, originally from 0 to 2 ^ 32-1 , but said negative going to work a little , most of the provisions from 0x00000000 ~ 0x7FFFFFFF language is positive , ie, 0 to 2 ^ 31-1 , and from 0x80000000 to 0xFFFFFFFF start is negative , that is -2 ^ 31 to -1.
In an example above , Integer.MAX_VALUE is 0x7FFFFFFF,
0x7FFFFFFF +0 x7FFFFFFF = 0xFFFFFFFE
The 0xFFFFFFFE said -2
learning , thank you for your patience Reply
------ For reference only ---------------------------------- -----
int type is 4 bytes , then you can represent 2 ^ 32 numbers, but no C + +, Java unsigned integer in them, so this is 2 ^ 32 digits necessary to represent negative numbers , but also represents a positive number , it took half of 2 ^ 32 is negative , half positive and 0 are non-negative , so the number of positive numbers is 2 ^ 31-1 , a negative number is 2 ^ 31 , so add up to exactly 2 ^ 32 th data type int .
highest bit is 0 and a positive , negative, the highest bit is 1, the result is a negative number after the spill , to look at the most significant bit is 0 after an overflow or 1 , it will not mean a positive spillover is negative
The following statement outputs would not be negative, but a positive number
System.out.println (Integer.MAX_VALUE * 5); results for 2147483643
------ For reference only ---------------------------------- -----
Well , int overflow necessarily negative, in the case of additive, multiplicative not necessarily
没有评论:
发表评论