Does BigInteger ever overflows?

Question

The API docs says

All of the details in the Spec concerning overflow are ignored, as BigIntegers are made as large as necessary to accommodate the r

Answer 1

If so why do we let some "type" overflow and some don't?

That entirely depends on how it is backed. If it's backed by for example a plain vanilla primitive int, then it will obviously overflow at Integer.MAX_VALUE. Primitives have clear overflow borders, while those for Objects depends on how they're backed/programmed.

Answer 2

BigInteger will never overflow assuming you have enough memory to handle it.

To answer your question of why we let some types overflow and not others:

BigInteger is not really a type. It's a class. It's a wrapper class designed to give you the same functionality as an int, but allows you to use numbers as big as you need without the worry of overflow.

Types do overflow because they are simply a couple of bytes (exact amount depends on the type) of memory, and once that small amount of memory overflows, so do the numbers.

No class "overflows" unless it is specifically designed to do so (or if you run out of resources). A class is defined with enough memory for everything it contains, which would mostly be references to other classes or other data structures.

Answer 3

Correct, BigInteger never overflows, it uses software operations and dynamic allocation to store arbitrarily sized numbers.

As with all things in computing, "arbitrarily sized" is anothe way of saying "until you run out of resources on the underlying system".

Answer 4

BigInteger never overflows! It's of an arbitrary size, so it can accomodate a number as large as your memory (and Java heap) can accomodate.

Answer 5

You read it right, it will never overflow. Although, it won't create more RAM for you :)

Semantics of arithmetic operations exactly mimic those of Java's integer arithmetic operators, as defined in The Java Language Specification. For example, division by zero throws an ArithmeticException, and division of a negative by a positive yields a negative (or zero) remainder. All of the details in the Spec concerning overflow are ignored, as BigIntegers are made as large as necessary to accommodate the results of an operation.