How does Java handle integer underflows and overflows and how would you check for it

Question

How does Java handle integer underflows and overflows   Leading on from that  how would you check test that this is occurring

User · Answer

static final int safeAdd int left  int right                   throws ArithmeticException     if  right  gt  0   left  gt  Integer MAX VALUE - right                   left  lt  Integer MIN VALUE - right        throw new ArithmeticException  Integer overflow          return left   right     static final int safeSubtract int left  int right                   throws ArithmeticException     if  right  gt  0   left  lt  Integer MIN VALUE   right                   left  gt  Integer MAX VALUE   right        throw new ArithmeticException  Integer overflow          return left - right     static final int safeMultiply int left  int right                   throws ArithmeticException     if  right  gt  0   left  gt  Integer MAX VALUE right                      left  lt  Integer MIN VALUE right                    right  lt  -1   left  gt  Integer MIN VALUE right                                    left  lt  Integer MAX VALUE right                                 right    -1                                  amp  amp  left    Integer MIN VALUE          throw new ArithmeticException  Integer overflow          return left   right     static final int safeDivide int left  int right                   throws ArithmeticException     if   left    Integer MIN VALUE   amp  amp   right    -1         throw new ArithmeticException  Integer overflow          return left   right     static final int safeNegate int a  throws ArithmeticException     if  a    Integer MIN VALUE        throw new ArithmeticException  Integer overflow          return -a    static final int safeAbs int a  throws ArithmeticException     if  a    Integer MIN VALUE        throw new ArithmeticException  Integer overflow          return Math abs a

User · Answer

If it overflows  it goes back to the minimum value and continues from there  If it underflows  it goes back to the maximum value and continues from there   You can check that beforehand as follows   public static boolean willAdditionOverflow int left  int right        if  right  lt  0  amp  amp  right    Integer MIN VALUE            return willSubtractionOverflow left  -right         else           return    left   right   amp   left    left   right     lt  0           public static boolean willSubtractionOverflow int left  int right        if  right  lt  0            return willAdditionOverflow left  -right         else           return   left   right   amp   left    left - right     lt  0             you can substitute int by long to perform the same checks for long   If you think that this may occur more than often  then consider using a datatype or object which can store larger values  e g  long or maybe java math BigInteger  The last one doesn t overflow  practically  the available JVM memory is the limit     If you happen to be on Java8 already  then you can make use of the new Math addExact   and Math subtractExact   methods which will throw an ArithmeticException on overflow   public static boolean willAdditionOverflow int left  int right        try           Math addExact left  right           return false        catch  ArithmeticException e            return true           public static boolean willSubtractionOverflow int left  int right        try           Math subtractExact left  right           return false        catch  ArithmeticException e            return true            The source code can be found here and here respectively   Of course  you could also just use them right away instead of hiding them in a boolean utility method

User · Answer

It wraps around   e g   public class Test        public static void main String   args            int i   Integer MAX VALUE          int j   Integer MIN VALUE           System out println i 1           System out println j-1             prints  -2147483648 2147483647

User · Answer

By default  Java s int and long math silently wrap around on overflow and underflow    Integer operations on other integer types are performed by first promoting the operands to int or long  per JLS 4 2 2    As of Java 8  java lang Math provides addExact  subtractExact  multiplyExact  incrementExact  decrementExact and negateExact static methods for both int and long arguments that perform the named operation  throwing ArithmeticException on overflow    There s no divideExact method -- you ll have to check the one special case  MIN VALUE   -1  yourself    As of Java 8  java lang Math also provides toIntExact to cast a long to an int  throwing ArithmeticException if the long s value does not fit in an int   This can be useful for e g  computing the sum of ints using unchecked long math  then using toIntExact to cast to int at the end  but be careful not to let your sum overflow    If you re still using an older version of Java  Google Guava provides IntMath and LongMath static methods for checked addition  subtraction  multiplication and exponentiation  throwing on overflow    These classes also provide methods to compute factorials and binomial coefficients that return MAX VALUE on overflow  which is less convenient to check    Guava s primitive utility classes  SignedBytes  UnsignedBytes  Shorts and Ints  provide checkedCast methods for narrowing larger types  throwing IllegalArgumentException on under overflow  not ArithmeticException   as well as saturatingCast methods that return MIN VALUE or MAX VALUE on overflow

User · Answer

Having just kinda run into this problem myself  here s my solution  for both multiplication and addition    static boolean wouldOverflowOccurwhenMultiplying int a  int b           If either a or b are Integer MIN VALUE  then multiplying by anything other than 0 or 1 will result in overflow     if  a    0    b    0            return false        else if  a  gt  0  amp  amp  b  gt  0       both positive  non zero         return a  gt  Integer MAX VALUE   b        else if  b  lt  0  amp  amp  a  lt  0       both negative  non zero         return a  lt  Integer MAX VALUE   b        else      exactly one of a b is negative and one is positive  neither are zero         if  b  gt  0       this last if statements protects against Integer MIN VALUE   -1  which in itself causes overflow              return a  lt  Integer MIN VALUE   b            else      a  gt  0             return b  lt  Integer MIN VALUE   a                     boolean wouldOverflowOccurWhenAdding int a  int b        if  a  gt  0  amp  amp  b  gt  0            return a  gt  Integer MAX VALUE - b        else if  a  lt  0  amp  amp  b  lt  0            return a  lt  Integer MIN VALUE - b            return false      feel free to correct if wrong or if can be simplified  I ve done some testing with the multiplication method  mostly edge cases  but it could still be wrong

User · Answer

There is one case  that is not mentioned above   int res   1  while  res    0        res    2     System out println res     will produce   0   This case was discussed here  Integer overflow produces Zero

User · Answer

Well  as far as primitive integer types go  Java doesnt handle Over Underflow at all  for float and double the behaviour is different  it will flush to   - infinity just as IEEE-754 mandates    When adding two int s  you will get no indication when an overflow occurs  A simple method to check for overflow is to use the next bigger type to actually perform the operation and check if the result is still in range for the source type   public int addWithOverflowCheck int a  int b           the cast of a is required  to make the   work with long precision         if we just added  a   b  the addition would use int precision and        the result would be cast to long afterwards      long result     long  a    b      if  result  gt  Integer MAX VALUE             throw new RuntimeException  Overflow occured          else if  result  lt  Integer MIN VALUE             throw new RuntimeException  Underflow occured                 at this point we can safely cast back to int  we checked before        that the value will be withing int s limits     return  int  result      What you would do in place of the throw clauses  depends on your applications requirements  throw  flush to min max or just log whatever   If you want to detect overflow on long operations  you re out of luck with primitives  use BigInteger instead     Edit  2014-05-21   Since this question seems to be referred to quite frequently and I had to solve the same problem myself  its quite easy to evaluate the overflow condition by the same method a CPU would calculate its V flag   Its basically a boolean expression that involves the sign of both operands as well as the result           Add two int s with overflow detection  r   s   d      public static int add final int s  final int d  throws ArithmeticException       int r   s   d      if    s  amp  d  amp   r      s  amp   d  amp  r    lt  0          throw new ArithmeticException  int overflow add     s          d                 return r      In java its simpler to apply the expression  in the if  to the entire 32 bits  and check the result using  lt  0  this will effectively test the sign bit   The principle works exactly the same for all integer primitive types  changing all declarations in above method to long makes it work for long   For smaller types  due to the implicit conversion to int  see the JLS for bitwise operations for details   instead of checking  lt  0  the check needs to mask the sign bit explicitly  0x8000 for short operands  0x80 for byte operands  adjust casts and parameter declaration appropiately           Subtract two short s with overflow detection  r   d - s      public static short sub final short d  final short s  throws ArithmeticException       int r   d - s      if      s  amp  d  amp   r     s  amp   d  amp  r    amp  0x8000     0          throw new ArithmeticException  short overflow sub     s          d             return  short  r       Note that above example uses the expression need for subtract overflow detection     So how why do these boolean expressions work  First  some logical thinking reveals that an overflow can only occur if the signs of both arguments are the same  Because  if one argument is negative and one positive  the result  of add  must be closer to zero  or in the extreme case one argument is zero  the same as the other argument  Since the arguments by themselves can t create an overflow condition  their sum can t create an overflow either   So what happens if both arguments have the same sign  Lets take a look at the case both are positive  adding two arguments that create a sum larger than the types MAX VALUE  will always yield a negative value  so an overflow occurs if arg1   arg2   MAX VALUE  Now the maximum value that could result would be MAX VALUE   MAX VALUE  the extreme case both arguments are MAX VALUE   For a byte  example  that would mean 127   127   254  Looking at the bit representations of all values that can result from adding two positive values  one finds that those that overflow  128 to 254  all have bit 7 set  while all that do not overflow  0 to 127  have bit 7  topmost  sign  cleared  Thats exactly what the first  right  part of the expression checks   if    s  amp  d  amp   r      s  amp   d  amp  r    lt  0      s  amp   d  amp  r  becomes true  only if  both operands  s  d  are positive and the result  r  is negative  the expression works on all 32 bits  but the only bit we re interested in is the topmost  sign  bit  which is checked against by the  lt  0    Now if both arguments are negative  their sum can never be closer to zero than any of the arguments  the sum must be closer to minus infinity  The most extreme value we can produce is MIN VALUE   MIN VALUE  which  again for byte example  shows that for any in range value  -1 to -128  the sign bit is set  while any possible overflowing value  -129 to -256  has the sign bit cleared  So the sign of the result again reveals the overflow condition  Thats what the left half  s  amp  d  amp   r  checks for the case where both arguments  s  d  are negative and a result that is positive  The logic is largely equivalent to the positive case  all bit patterns that can result from adding two negative values will have the sign bit cleared if and only if an underflow occured

User · Answer

Java doesn t do anything with integer overflow for either int or long primitive types and ignores overflow with positive and negative integers    This answer first describes the of integer overflow  gives an example of how it can happen  even with intermediate values in expression evaluation  and then gives links to resources that give detailed techniques for preventing and detecting integer overflow    Integer arithmetic and expressions reslulting in unexpected or undetected overflow are a common programming error  Unexpected or undetected integer overflow is also a well-known exploitable security issue  especially as it affects array  stack and list objects    Overflow can occur in either a positive or negative direction where the positive or negative value would be beyond the maximum or minimum values for the primitive type in question  Overflow can occur in an intermediate value during expression or operation evaluation and affect the outcome of an expression or operation where the final value would be expected to be within range    Sometimes negative overflow is mistakenly called underflow  Underflow is what happens when a value would be closer to zero than the representation allows  Underflow occurs in integer arithmetic and is expected  Integer underflow happens when an integer evaluation would be between -1 and 0 or 0 and 1  What would be a fractional result truncates to 0  This is normal and expected with integer arithmetic and not considered an error  However  it can lead to code throwing an exception  One example is an  ArithmeticException    by zero  exception if the result of integer underflow is used as a divisor in an expression    Consider the following code   int bigValue   Integer MAX VALUE  int x   bigValue   2   5  int y   bigValue   x    which results in x being assigned 0 and the subsequent evaluation of bigValue   x throws an exception   ArithmeticException    by zero   i e  divide by zero   instead of y being assigned the value 2    The expected result for x would be 858 993 458 which is less than the maximum int value of 2 147 483 647  However  the intermediate result from evaluating Integer MAX Value   2  would be 4 294 967 294  which exceeds the maximum int value and is -2 in accordance with 2s complement integer representations  The subsequent evaluation of -2   5 evaluates to 0 which gets assigned to x    Rearranging the expression for computing x to an expression that  when evaluated  divides before multiplying  the following code   int bigValue   Integer MAX VALUE  int x   bigValue   5   2  int y   bigValue   x    results in x being assigned 858 993 458 and y being assigned 2  which is expected   The intermediate result from bigValue   5 is 429 496 729 which does not exceed the maximum value for an int  Subsequent evaluation of 429 496 729   2 doesn t exceed the maximum value for an int and the expected result gets assigned to x  The evaluation for y then does not divide by zero  The evaluations for x and y work as expected   Java integer values are stored as and behave in accordance with 2s complement signed integer representations  When a resulting value would be larger or smaller than the maximum or minimum integer values  a 2 s complement integer value results instead  In situations not expressly designed to use 2s complement behavior  which is most ordinary integer arithmetic situations  the resulting 2s complement value will cause a programming logic or computation error as was shown in the example above  An excellent Wikipedia article describes 2s compliment binary integers here  Two s complement - Wikipedia  There are techniques for avoiding unintentional integer overflow  Techinques may be categorized as using pre-condition testing  upcasting and BigInteger    Pre-condition testing comprises examining the values going into an arithmetic operation or expression to ensure that an overflow won t occur with those values  Programming and design will need to create testing that ensures input values won t cause overflow and then determine what to do if input values occur that will cause overflow    Upcasting comprises using a larger primitive type to perform the arithmetic operation or expression and then determining if the resulting value is beyond the maximum or minimum values for an integer  Even with upcasting  it is still possible that the value or some intermediate value in an operation or expression will be beyond the maximum or minimum values for the upcast type and cause overflow  which will also not be detected and will cause unexpected and undesired results  Through analysis or pre-conditions  it may be possible to prevent overflow with upcasting when prevention without upcasting is not possible or practical  If the integers in question are already long primitive types  then upcasting is not possible with primitive types in Java   The BigInteger technique comprises using BigInteger for the arithmetic operation or expression using library methods that use BigInteger  BigInteger does not overflow  It will use all available memory  if necessary  Its arithmetic methods are normally only slightly less efficient than integer operations  It is still possible that a result using BigInteger may be beyond the maximum or minimum values for an integer  however  overflow will not occur in the arithmetic leading to the result  Programming and design will still need to determine what to do if a BigInteger result is beyond the maximum or minimum values for the desired primitive result type  e g   int or long    The Carnegie Mellon Software Engineering Institute s CERT program and Oracle have created a set of standards for secure Java programming  Included in the standards are techniques for preventing and detecting integer overflow  The standard is published as a freely accessible online resource here  The CERT Oracle Secure Coding Standard for Java  The standard s section that describes and contains practical examples of coding techniques for preventing or detecting integer overflow is here  NUM00-J  Detect or prevent integer overflow  Book form and PDF form of The CERT Oracle Secure Coding Standard for Java are also available

User · Answer

There are libraries that provide safe arithmetic operations  which check integer overflow underflow   For example  Guava s IntMath checkedAdd int a  int b  returns the sum of a and b  provided it does not overflow  and throws ArithmeticException if a   b overflows in signed int arithmetic

User · Answer

I think you should use something like this and it is called Upcasting   public int multiplyBy2 int x  throws ArithmeticException       long result   2    long  x          if  result  gt  Integer MAX VALUE    result  lt  Integer MIN VALUE           throw new ArithmeticException  Integer overflow              return  int  result      You can read further here  Detect or prevent integer overflow  It is quite reliable source

User · Answer

I think this should be fine   static boolean addWillOverFlow int a  int b        return  Integer signum a     Integer signum b    amp  amp                Integer signum a     Integer signum a b

User · Answer

It doesn t do anything -- the under overflow just happens   A  -1  that is the result of a computation that overflowed is no different from the  -1  that resulted from any other information  So you can t tell via some status or by inspecting just a value whether it s overflowed   But you can be smart about your computations in order to avoid overflow  if it matters  or at least know when it will happen  What s your situation

[java] How does Java handle integer underflows and overflows and how would you check for it?

Examples related to java

Examples related to integer

Examples related to integer-overflow