java.math
public class BigInteger extends Number implements Comparable<BigInteger>
Modifier and Type | Field and Description |
---|---|
static BigInteger |
ONE
The constant one as a BigInteger.
|
static BigInteger |
TEN
The constant ten as a BigInteger.
|
static BigInteger |
ZERO
The constant zero as a BigInteger.
|
Constructor and Description |
---|
BigInteger(byte[] val) |
BigInteger(int signum,
byte[] magnitude) |
BigInteger(int bitLength,
int certainty,
Random rnd) |
BigInteger(int numBits,
Random rnd) |
BigInteger(String val) |
BigInteger(String s,
int radix) |
Modifier and Type | Method and Description |
---|---|
BigInteger |
abs() |
BigInteger |
add(BigInteger val) |
BigInteger |
and(BigInteger y)
Return the logical (bit-wise) "and" of two BigIntegers.
|
BigInteger |
andNot(BigInteger val) |
int |
bitCount()
Count one bits in a BigInteger.
|
int |
bitLength()
Calculates ceiling(log2(this < 0 ?
|
BigInteger |
clearBit(int n) |
int |
compareTo(BigInteger val)
Compares this object with another, and returns a numerical result based
on the comparison.
|
BigInteger |
divide(BigInteger val) |
BigInteger[] |
divideAndRemainder(BigInteger val) |
double |
doubleValue()
Return the value of this
Number as a float . |
boolean |
equals(Object obj)
Determine whether this Object is semantically equal
to another Object.
|
BigInteger |
flipBit(int n) |
float |
floatValue()
Return the value of this
Number as a float . |
BigInteger |
gcd(BigInteger y) |
int |
getLowestSetBit() |
int |
hashCode()
Get a value that represents this Object, as uniquely as
possible within the confines of an int.
|
int |
intValue()
Return the value of this
Number as an int . |
boolean |
isProbablePrime(int certainty)
Returns
true if this BigInteger is probably prime,
false if it's definitely composite. |
long |
longValue()
Return the value of this
Number as a long . |
BigInteger |
max(BigInteger val) |
BigInteger |
min(BigInteger val) |
BigInteger |
mod(BigInteger m) |
BigInteger |
modInverse(BigInteger y) |
BigInteger |
modPow(BigInteger exponent,
BigInteger m) |
BigInteger |
multiply(BigInteger y) |
BigInteger |
negate() |
BigInteger |
not()
Return the logical (bit-wise) negation of a BigInteger.
|
BigInteger |
or(BigInteger y)
Return the logical (bit-wise) "(inclusive) or" of two BigIntegers.
|
BigInteger |
pow(int exponent)
Calculate the integral power of a BigInteger.
|
static BigInteger |
probablePrime(int bitLength,
Random rnd)
Return a BigInteger that is bitLength bits long with a
probability < 2^-100 of being composite.
|
BigInteger |
remainder(BigInteger val) |
BigInteger |
setBit(int n) |
BigInteger |
shiftLeft(int n) |
BigInteger |
shiftRight(int n) |
int |
signum() |
BigInteger |
subtract(BigInteger val) |
boolean |
testBit(int n) |
byte[] |
toByteArray() |
String |
toString()
Convert this Object to a human-readable String.
|
String |
toString(int radix) |
static BigInteger |
valueOf(long val)
Return a (possibly-shared) BigInteger with a given long value.
|
BigInteger |
xor(BigInteger y)
Return the logical (bit-wise) "exclusive or" of two BigIntegers.
|
byteValue, shortValue
public static final BigInteger ZERO
public static final BigInteger ONE
public static final BigInteger TEN
public BigInteger(String s, int radix)
public BigInteger(String val)
public BigInteger(byte[] val)
public BigInteger(int signum, byte[] magnitude)
public BigInteger(int numBits, Random rnd)
public BigInteger(int bitLength, int certainty, Random rnd)
public static BigInteger probablePrime(int bitLength, Random rnd)
bitLength
- length in bits of resulting numberrnd
- random number generator to useArithmeticException
- if bitLength < 2public static BigInteger valueOf(long val)
public int signum()
public int compareTo(BigInteger val)
Comparable
o1.compareTo(o2) <op> 0
, where op
is one of <, <=, =, !=, >, or >=.
You must make sure that the comparison is mutual, ie.
sgn(x.compareTo(y)) == -sgn(y.compareTo(x))
(where sgn() is
defined as -1, 0, or 1 based on the sign). This includes throwing an
exception in either direction if the two are not comparable; hence,
compareTo(null)
should always throw an Exception.
You should also ensure transitivity, in two forms:
x.compareTo(y) > 0 && y.compareTo(z) > 0
implies
x.compareTo(z) > 0
; and x.compareTo(y) == 0
implies x.compareTo(z) == y.compareTo(z)
.
compareTo
in interface Comparable<BigInteger>
val
- the object to be comparedpublic BigInteger min(BigInteger val)
public BigInteger max(BigInteger val)
public BigInteger add(BigInteger val)
public BigInteger subtract(BigInteger val)
public BigInteger multiply(BigInteger y)
public BigInteger divide(BigInteger val)
public BigInteger remainder(BigInteger val)
public BigInteger[] divideAndRemainder(BigInteger val)
public BigInteger mod(BigInteger m)
public BigInteger pow(int exponent)
exponent
- the exponent (must be non-negative)public BigInteger modInverse(BigInteger y)
public BigInteger modPow(BigInteger exponent, BigInteger m)
public BigInteger gcd(BigInteger y)
public boolean isProbablePrime(int certainty)
Returns true
if this BigInteger is probably prime,
false
if it's definitely composite. If certainty
is <= 0
, true
is returned.
certainty
- a measure of the uncertainty that the caller is willing
to tolerate: if the call returns true
the probability that
this BigInteger is prime exceeds (1 - 1/2certainty)
.
The execution time of this method is proportional to the value of this
parameter.true
if this BigInteger is probably prime,
false
if it's definitely composite.public BigInteger shiftLeft(int n)
public BigInteger shiftRight(int n)
public String toString()
Object
System.out.println()
and such.
It is typical, but not required, to ensure that this method
never completes abruptly with a RuntimeException
.
This method will be called when performing string
concatenation with this object. If the result is
null
, string concatenation will instead
use "null"
.
The default implementation returns
getClass().getName() + "@" +
Integer.toHexString(hashCode())
.
toString
in class Object
Object.getClass()
,
Object.hashCode()
,
Class.getName()
,
Integer.toHexString(int)
public int intValue()
Number
Number
as an int
.public long longValue()
Number
Number
as a long
.public int hashCode()
Object
There are some requirements on this method which
subclasses must follow:
a.equals(b)
is true, then
a.hashCode() == b.hashCode()
must be as well.
However, the reverse is not necessarily true, and two
objects may have the same hashcode without being equal.Notice that since hashCode
is used in
Hashtable
and other hashing classes,
a poor implementation will degrade the performance of hashing
(so don't blindly implement it as returning a constant!). Also,
if calculating the hash is time-consuming, a class may consider
caching the results.
The default implementation returns
System.identityHashCode(this)
hashCode
in class Object
Object.equals(Object)
,
System.identityHashCode(Object)
public boolean equals(Object obj)
Object
There are some fairly strict requirements on this
method which subclasses must follow:
a.equals(b)
and
b.equals(c)
, then a.equals(c)
must be true as well.a.equals(b)
and
b.equals(a)
must have the same value.a.equals(a)
must
always be true.a.equals(null)
must be false.a.equals(b)
must imply
a.hashCode() == b.hashCode()
.
The reverse is not true; two objects that are not
equal may have the same hashcode, but that has
the potential to harm hashing performance.This is typically overridden to throw a ClassCastException
if the argument is not comparable to the class performing
the comparison, but that is not a requirement. It is legal
for a.equals(b)
to be true even though
a.getClass() != b.getClass()
. Also, it
is typical to never cause a NullPointerException
.
In general, the Collections API (java.util
) use the
equals
method rather than the ==
operator to compare objects. However, IdentityHashMap
is an exception to this rule, for its own good reasons.
The default implementation returns this == o
.
equals
in class Object
obj
- the Object to compare toObject.hashCode()
public double doubleValue()
Number
Number
as a float
.doubleValue
in class Number
public float floatValue()
Number
Number
as a float
.floatValue
in class Number
public BigInteger abs()
public BigInteger negate()
public int bitLength()
public byte[] toByteArray()
public BigInteger and(BigInteger y)
public BigInteger or(BigInteger y)
public BigInteger xor(BigInteger y)
public BigInteger not()
public BigInteger andNot(BigInteger val)
public BigInteger clearBit(int n)
public BigInteger setBit(int n)
public boolean testBit(int n)
public BigInteger flipBit(int n)
public int getLowestSetBit()
public int bitCount()