321 lines
7.9 KiB
Java
321 lines
7.9 KiB
Java
package java.lang;
|
|
|
|
import java.lang.DecimalDigits;
|
|
|
|
public final class Integer
|
|
extends Number
|
|
implements Comparable<Integer> {
|
|
|
|
public static final int MAX_VALUE = 2147483647;
|
|
|
|
public static final int MIN_VALUE = -2147483648;
|
|
|
|
public static final int SIZE = 32;
|
|
|
|
private final int value;
|
|
|
|
public Integer(int value) {
|
|
this.value = value;
|
|
}
|
|
|
|
public Integer(String s)
|
|
throws NumberFormatException {
|
|
this.value = parseInt(s, 10);
|
|
}
|
|
|
|
public static int bitCount(int i) {
|
|
int c;
|
|
i = i - ((i >> 1) & 0x55555555);
|
|
i = (i & 0x33333333) + ((i >> 2) & 0x33333333);
|
|
c = ((i + (i >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
|
|
return c;
|
|
}
|
|
|
|
public byte byteValue() {
|
|
return (byte)value;
|
|
}
|
|
|
|
public int compareTo(Integer anotherInteger) {
|
|
if (value == anotherInteger.value)
|
|
return 0;
|
|
if (value < anotherInteger.value)
|
|
return -1;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
public static Integer decode(String nm)
|
|
throws NumberFormatException {
|
|
int length = nm.length();
|
|
if (length == 0)
|
|
throw new NumberFormatException(nm);
|
|
int index = 0;
|
|
char c;
|
|
c = nm.charAt(index);
|
|
if (c == '-' || c == '+')
|
|
index += 1;
|
|
boolean negative = (c == '-');
|
|
int n;
|
|
if (index >= length)
|
|
throw new NumberFormatException(nm);
|
|
c = nm.charAt(index);
|
|
|
|
if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) {
|
|
String s = nm.substring(index + 2);
|
|
n = parseInt(s, 16);
|
|
} else if (c == '#') {
|
|
String s = nm.substring(index + 1);
|
|
n = parseInt(s, 16);
|
|
} else if (c == '0') {
|
|
String s = nm.substring(index + 1);
|
|
n = parseInt(s, 8);
|
|
} else {
|
|
n = parseInt(nm, 10);
|
|
}
|
|
if (negative)
|
|
n = -n;
|
|
return new Integer(n);
|
|
}
|
|
|
|
public double doubleValue() {
|
|
return (double)value;
|
|
}
|
|
|
|
public boolean equals(Object obj) {
|
|
return obj instanceof Integer && value == ((Integer)obj).value;
|
|
}
|
|
|
|
public float floatValue() {
|
|
return (float)value;
|
|
}
|
|
|
|
public int hashCode() {
|
|
return value;
|
|
}
|
|
|
|
public static int highestOneBit(int i) {
|
|
i |= i >>> 1;
|
|
i |= i >>> 2;
|
|
i |= i >>> 4;
|
|
i |= i >>> 8;
|
|
i |= i >>> 16;
|
|
return i ^ (i >>> 1);
|
|
}
|
|
|
|
public int intValue() {
|
|
return value;
|
|
}
|
|
|
|
public long longValue() {
|
|
return (long)value;
|
|
}
|
|
|
|
public static int lowestOneBit(int value) {
|
|
return value & (-value);
|
|
}
|
|
|
|
public static int numberOfLeadingZeros(int i) {
|
|
int c = 0;
|
|
if (i <= 0x0000ffff) { c += 16; i <<= 16; }
|
|
if (i <= 0x00ffffff) { c += 8 ; i <<= 8 ; }
|
|
if (i <= 0x0fffffff) { c += 4 ; i <<= 4 ; }
|
|
if (i <= 0x3fffffff) { c += 2 ; i <<= 2 ; }
|
|
if (i <= 0x7fffffff) { c += 1 ; }
|
|
return c;
|
|
}
|
|
|
|
public static int numberOfTrailingZeros(int i) {
|
|
int c = 32;
|
|
i &= -i;
|
|
if (i != 0) c--;
|
|
if ((i & 0x0000FFFF) != 0) c -= 16;
|
|
if ((i & 0x00FF00FF) != 0) c -= 8;
|
|
if ((i & 0x0F0F0F0F) != 0) c -= 4;
|
|
if ((i & 0x33333333) != 0) c -= 2;
|
|
if ((i & 0x55555555) != 0) c -= 1;
|
|
return c;
|
|
}
|
|
|
|
public static int parseInt(String s)
|
|
throws NumberFormatException {
|
|
return parseInt(s, 10);
|
|
}
|
|
|
|
public static int parseInt(String s, int radix)
|
|
throws NumberFormatException {
|
|
int length = s.length();
|
|
if (length == 0)
|
|
throw new NumberFormatException(s);
|
|
int index = 0;
|
|
char c = s.charAt(index);
|
|
if (c == '-' || c == '+')
|
|
index += 1;
|
|
boolean negative = (c == '-');
|
|
if (index >= length)
|
|
throw new NumberFormatException(s);
|
|
if (length - index > 10)
|
|
throw new NumberFormatException(s);
|
|
int n = 0;
|
|
while (index < length) {
|
|
int value = Character.digit(s.charAt(index), radix);
|
|
if (value < 0)
|
|
throw new NumberFormatException(s);
|
|
n *= radix;
|
|
n += value;
|
|
index += 1;
|
|
}
|
|
if (n < 0) // overflow
|
|
throw new NumberFormatException(s);
|
|
if (negative)
|
|
n = -n;
|
|
return n;
|
|
}
|
|
|
|
public static int reverse(int i) {
|
|
i = ((i >> 1) & 0x55555555) | ((i & 0x55555555) << 1);
|
|
i = ((i >> 2) & 0x33333333) | ((i & 0x33333333) << 2);
|
|
i = ((i >> 4) & 0x0F0F0F0F) | ((i & 0x0F0F0F0F) << 4);
|
|
i = ((i >> 8) & 0x00FF00FF) | ((i & 0x00FF00FF) << 8);
|
|
i = ( i >> 16 ) | ( i << 16);
|
|
return i;
|
|
}
|
|
|
|
public static int reverseBytes(int i) {
|
|
return (((i >> 24) & 0x000000ff) |
|
|
((i >> 8 ) & 0x0000ff00) |
|
|
((i << 8 ) & 0x00ff0000) |
|
|
((i << 24) & 0xff000000));
|
|
}
|
|
|
|
public static int rotateLeft(int i, int distance) {
|
|
return (i << distance) | (i >>> (-distance));
|
|
}
|
|
|
|
public static int rotateRight(int i, int distance) {
|
|
return (i << (-distance)) | (i >>> distance);
|
|
}
|
|
|
|
public short shortValue() {
|
|
return (short)value;
|
|
}
|
|
|
|
public static int signum(int i) {
|
|
return (i >> 31) | ((-i) >>> 31);
|
|
}
|
|
|
|
public static String toBinaryString(int i) {
|
|
return toString(i, 2);
|
|
}
|
|
|
|
public static String toHexString(int i) {
|
|
return toString(i, 16);
|
|
}
|
|
|
|
public static String toOctalString(int i) {
|
|
return toString(i, 8);
|
|
}
|
|
|
|
private static int stringSize(int n) {
|
|
int sign_digits = 0;
|
|
if (n < 0) {
|
|
sign_digits = 1;
|
|
n = -n;
|
|
}
|
|
int digits = 1;
|
|
int cmp = 10;
|
|
for (int i = 0; i < 9; i++) {
|
|
if (n < cmp)
|
|
return digits + sign_digits;
|
|
digits += 1;
|
|
cmp *= 10;
|
|
}
|
|
return 10 + sign_digits;
|
|
}
|
|
|
|
public String toString()
|
|
{
|
|
return toString(value);
|
|
}
|
|
|
|
public static String toString(int i) {
|
|
if (i == 0)
|
|
return "0";
|
|
if (i == MIN_VALUE)
|
|
return "-2147483648";
|
|
|
|
int pos = stringSize(i);
|
|
byte[] buf = new byte[pos];
|
|
|
|
boolean sign = i < 0;
|
|
if (sign) {
|
|
i = -i;
|
|
}
|
|
|
|
while (i >= 10) {
|
|
int div = i / 100;
|
|
int mod = i - (div * 100);
|
|
|
|
short digits = DecimalDigits.DIGITS[mod];
|
|
pos -= 2;
|
|
buf[pos] = (byte)(digits >> 8);
|
|
buf[pos+1] = (byte)(digits);
|
|
|
|
i = div;
|
|
}
|
|
|
|
if (i != 0) {
|
|
pos -= 1;
|
|
buf[pos] = (byte)('0' + i);
|
|
}
|
|
|
|
if (sign) {
|
|
pos -= 1;
|
|
buf[pos] = (byte)'-';
|
|
}
|
|
return new String(buf);
|
|
}
|
|
|
|
public static String toString(int i, int radix) {
|
|
if (i == 0)
|
|
return "0";
|
|
if (radix == 10)
|
|
return toString(i);
|
|
int pos = 32;
|
|
byte[] buf = new byte[32];
|
|
|
|
boolean sign = i < 0;
|
|
if (sign) {
|
|
i = -i;
|
|
}
|
|
|
|
while (i != 0) {
|
|
int div = i / radix;
|
|
int mod = i - (div * radix);
|
|
char digit = Character.forDigit(mod, radix);
|
|
pos -= 1;
|
|
buf[pos] = (byte)digit;
|
|
i = div;
|
|
}
|
|
|
|
if (sign) {
|
|
pos -= 1;
|
|
buf[pos] = (byte)'-';
|
|
}
|
|
return new String(buf, pos, 32 - pos);
|
|
}
|
|
|
|
public static Integer valueOf(int i) {
|
|
return new Integer(i);
|
|
}
|
|
|
|
public static Integer valueOf(String s)
|
|
throws NumberFormatException {
|
|
return new Integer(Integer.parseInt(s));
|
|
}
|
|
|
|
public static Integer valueOf(String s, int radix)
|
|
throws NumberFormatException {
|
|
return new Integer(Integer.parseInt(s, radix));
|
|
}
|
|
}
|