In addition, this class provides several methods for converting * an {@code int} to a {@code String} and a {@code String} to an * {@code int}, as well as other constants and methods useful when * dealing with an {@code int}. * *
Implementation note: The implementations of the "bit twiddling"
* methods (such as {@link #highestOneBit(int) highestOneBit} and
* {@link #numberOfTrailingZeros(int) numberOfTrailingZeros}) are
* based on material from Henry S. Warren, Jr.'s Hacker's
* Delight, (Addison Wesley, 2002).
*
* @author Lee Boynton
* @author Arthur van Hoff
* @author Josh Bloch
* @author Joseph D. Darcy
* @since JDK1.0
*/
public final class Integer extends Number implements Comparable
If the radix is smaller than {@code Character.MIN_RADIX} * or larger than {@code Character.MAX_RADIX}, then the radix * {@code 10} is used instead. * *
If the first argument is negative, the first element of the * result is the ASCII minus character {@code '-'} * ({@code '\u005Cu002D'}). If the first argument is not * negative, no sign character appears in the result. * *
The remaining characters of the result represent the magnitude * of the first argument. If the magnitude is zero, it is * represented by a single zero character {@code '0'} * ({@code '\u005Cu0030'}); otherwise, the first character of * the representation of the magnitude will not be the zero * character. The following ASCII characters are used as digits: * *
* {@code 0123456789abcdefghijklmnopqrstuvwxyz} ** * These are {@code '\u005Cu0030'} through * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through * {@code '\u005Cu007A'}. If {@code radix} is * N, then the first N of these characters * are used as radix-N digits in the order shown. Thus, * the digits for hexadecimal (radix 16) are * {@code 0123456789abcdef}. If uppercase letters are * desired, the {@link java.lang.String#toUpperCase()} method may * be called on the result: * *
* {@code Integer.toString(n, 16).toUpperCase()} ** * @param i an integer to be converted to a string. * @param radix the radix to use in the string representation. * @return a string representation of the argument in the specified radix. * @see java.lang.Character#MAX_RADIX * @see java.lang.Character#MIN_RADIX */ public static String toString(int i, int radix) { if (radix < Character.MIN_RADIX || radix > Character.MAX_RADIX) radix = 10; /* Use the faster version */ if (radix == 10) { return toString(i); } char buf[] = new char[33]; boolean negative = (i < 0); int charPos = 32; if (!negative) { i = -i; } while (i <= -radix) { buf[charPos--] = digits[-(i % radix)]; i = i / radix; } buf[charPos] = digits[-i]; if (negative) { buf[--charPos] = '-'; } return new String(buf, charPos, (33 - charPos)); } /** * Returns a string representation of the first argument as an * unsigned integer value in the radix specified by the second * argument. * *
If the radix is smaller than {@code Character.MIN_RADIX} * or larger than {@code Character.MAX_RADIX}, then the radix * {@code 10} is used instead. * *
Note that since the first argument is treated as an unsigned * value, no leading sign character is printed. * *
If the magnitude is zero, it is represented by a single zero * character {@code '0'} ({@code '\u005Cu0030'}); otherwise, * the first character of the representation of the magnitude will * not be the zero character. * *
The behavior of radixes and the characters used as digits * are the same as {@link #toString(int, int) toString}. * * @param i an integer to be converted to an unsigned string. * @param radix the radix to use in the string representation. * @return an unsigned string representation of the argument in the specified radix. * @see #toString(int, int) * @since 1.8 */ public static String toUnsignedString(int i, int radix) { return Long.toUnsignedString(toUnsignedLong(i), radix); } /** * Returns a string representation of the integer argument as an * unsigned integer in base 16. * *
The unsigned integer value is the argument plus 232 * if the argument is negative; otherwise, it is equal to the * argument. This value is converted to a string of ASCII digits * in hexadecimal (base 16) with no extra leading * {@code 0}s. * *
The value of the argument can be recovered from the returned * string {@code s} by calling {@link * Integer#parseUnsignedInt(String, int) * Integer.parseUnsignedInt(s, 16)}. * *
If the unsigned magnitude is zero, it is represented by a * single zero character {@code '0'} ({@code '\u005Cu0030'}); * otherwise, the first character of the representation of the * unsigned magnitude will not be the zero character. The * following characters are used as hexadecimal digits: * *
* {@code 0123456789abcdef} ** * These are the characters {@code '\u005Cu0030'} through * {@code '\u005Cu0039'} and {@code '\u005Cu0061'} through * {@code '\u005Cu0066'}. If uppercase letters are * desired, the {@link java.lang.String#toUpperCase()} method may * be called on the result: * *
* {@code Integer.toHexString(n).toUpperCase()} ** * @param i an integer to be converted to a string. * @return the string representation of the unsigned integer value * represented by the argument in hexadecimal (base 16). * @see #parseUnsignedInt(String, int) * @see #toUnsignedString(int, int) * @since JDK1.0.2 */ public static String toHexString(int i) { return toUnsignedString0(i, 4); } /** * Returns a string representation of the integer argument as an * unsigned integer in base 8. * *
The unsigned integer value is the argument plus 232 * if the argument is negative; otherwise, it is equal to the * argument. This value is converted to a string of ASCII digits * in octal (base 8) with no extra leading {@code 0}s. * *
The value of the argument can be recovered from the returned * string {@code s} by calling {@link * Integer#parseUnsignedInt(String, int) * Integer.parseUnsignedInt(s, 8)}. * *
If the unsigned magnitude is zero, it is represented by a * single zero character {@code '0'} ({@code '\u005Cu0030'}); * otherwise, the first character of the representation of the * unsigned magnitude will not be the zero character. The * following characters are used as octal digits: * *
* {@code 01234567} ** * These are the characters {@code '\u005Cu0030'} through * {@code '\u005Cu0037'}. * * @param i an integer to be converted to a string. * @return the string representation of the unsigned integer value * represented by the argument in octal (base 8). * @see #parseUnsignedInt(String, int) * @see #toUnsignedString(int, int) * @since JDK1.0.2 */ public static String toOctalString(int i) { return toUnsignedString0(i, 3); } /** * Returns a string representation of the integer argument as an * unsigned integer in base 2. * *
The unsigned integer value is the argument plus 232 * if the argument is negative; otherwise it is equal to the * argument. This value is converted to a string of ASCII digits * in binary (base 2) with no extra leading {@code 0}s. * *
The value of the argument can be recovered from the returned * string {@code s} by calling {@link * Integer#parseUnsignedInt(String, int) * Integer.parseUnsignedInt(s, 2)}. * *
If the unsigned magnitude is zero, it is represented by a * single zero character {@code '0'} ({@code '\u005Cu0030'}); * otherwise, the first character of the representation of the * unsigned magnitude will not be the zero character. The * characters {@code '0'} ({@code '\u005Cu0030'}) and {@code * '1'} ({@code '\u005Cu0031'}) are used as binary digits. * * @param i an integer to be converted to a string. * @return the string representation of the unsigned integer value * represented by the argument in binary (base 2). * @see #parseUnsignedInt(String, int) * @see #toUnsignedString(int, int) * @since JDK1.0.2 */ public static String toBinaryString(int i) { return toUnsignedString0(i, 1); } /** * Convert the integer to an unsigned number. */ private static String toUnsignedString0(int val, int shift) { // assert shift > 0 && shift <=5 : "Illegal shift value"; int mag = Integer.SIZE - Integer.numberOfLeadingZeros(val); int chars = Math.max(((mag + (shift - 1)) / shift), 1); char[] buf = new char[chars]; formatUnsignedInt(val, shift, buf, 0, chars); // Use special constructor which takes over "buf". return new String(buf, true); } /** * Format a long (treated as unsigned) into a character buffer. * @param val the unsigned int to format * @param shift the log2 of the base to format in (4 for hex, 3 for octal, 1 for binary) * @param buf the character buffer to write to * @param offset the offset in the destination buffer to start at * @param len the number of characters to write * @return the lowest character location used */ static int formatUnsignedInt(int val, int shift, char[] buf, int offset, int len) { int charPos = len; int radix = 1 << shift; int mask = radix - 1; do { buf[offset + --charPos] = Integer.digits[val & mask]; val >>>= shift; } while (val != 0 && charPos > 0); return charPos; } final static char [] DigitTens = { '0', '0', '0', '0', '0', '0', '0', '0', '0', '0', '1', '1', '1', '1', '1', '1', '1', '1', '1', '1', '2', '2', '2', '2', '2', '2', '2', '2', '2', '2', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '4', '4', '4', '4', '4', '4', '4', '4', '4', '4', '5', '5', '5', '5', '5', '5', '5', '5', '5', '5', '6', '6', '6', '6', '6', '6', '6', '6', '6', '6', '7', '7', '7', '7', '7', '7', '7', '7', '7', '7', '8', '8', '8', '8', '8', '8', '8', '8', '8', '8', '9', '9', '9', '9', '9', '9', '9', '9', '9', '9', } ; final static char [] DigitOnes = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', } ; // I use the "invariant division by multiplication" trick to // accelerate Integer.toString. In particular we want to // avoid division by 10. // // The "trick" has roughly the same performance characteristics // as the "classic" Integer.toString code on a non-JIT VM. // The trick avoids .rem and .div calls but has a longer code // path and is thus dominated by dispatch overhead. In the // JIT case the dispatch overhead doesn't exist and the // "trick" is considerably faster than the classic code. // // TODO-FIXME: convert (x * 52429) into the equiv shift-add // sequence. // // RE: Division by Invariant Integers using Multiplication // T Gralund, P Montgomery // ACM PLDI 1994 // /** * Returns a {@code String} object representing the * specified integer. The argument is converted to signed decimal * representation and returned as a string, exactly as if the * argument and radix 10 were given as arguments to the {@link * #toString(int, int)} method. * * @param i an integer to be converted. * @return a string representation of the argument in base 10. */ public static String toString(int i) { if (i == Integer.MIN_VALUE) return "-2147483648"; int size = (i < 0) ? stringSize(-i) + 1 : stringSize(i); char[] buf = new char[size]; getChars(i, size, buf); return new String(buf, true); } /** * Returns a string representation of the argument as an unsigned * decimal value. * * The argument is converted to unsigned decimal representation * and returned as a string exactly as if the argument and radix * 10 were given as arguments to the {@link #toUnsignedString(int, * int)} method. * * @param i an integer to be converted to an unsigned string. * @return an unsigned string representation of the argument. * @see #toUnsignedString(int, int) * @since 1.8 */ public static String toUnsignedString(int i) { return Long.toString(toUnsignedLong(i)); } /** * Places characters representing the integer i into the * character array buf. The characters are placed into * the buffer backwards starting with the least significant * digit at the specified index (exclusive), and working * backwards from there. * * Will fail if i == Integer.MIN_VALUE */ static void getChars(int i, int index, char[] buf) { int q, r; int charPos = index; char sign = 0; if (i < 0) { sign = '-'; i = -i; } // Generate two digits per iteration while (i >= 65536) { q = i / 100; // really: r = i - (q * 100); r = i - ((q << 6) + (q << 5) + (q << 2)); i = q; buf [--charPos] = DigitOnes[r]; buf [--charPos] = DigitTens[r]; } // Fall thru to fast mode for smaller numbers // assert(i <= 65536, i); for (;;) { q = (i * 52429) >>> (16+3); r = i - ((q << 3) + (q << 1)); // r = i-(q*10) ... buf [--charPos] = digits [r]; i = q; if (i == 0) break; } if (sign != 0) { buf [--charPos] = sign; } } final static int [] sizeTable = { 9, 99, 999, 9999, 99999, 999999, 9999999, 99999999, 999999999, Integer.MAX_VALUE }; // Requires positive x static int stringSize(int x) { for (int i=0; ; i++) if (x <= sizeTable[i]) return i+1; } /** * Parses the string argument as a signed integer in the radix * specified by the second argument. The characters in the string * must all be digits of the specified radix (as determined by * whether {@link java.lang.Character#digit(char, int)} returns a * nonnegative value), except that the first character may be an * ASCII minus sign {@code '-'} ({@code '\u005Cu002D'}) to * indicate a negative value or an ASCII plus sign {@code '+'} * ({@code '\u005Cu002B'}) to indicate a positive value. The * resulting integer value is returned. * *
An exception of type {@code NumberFormatException} is * thrown if any of the following situations occurs: *
Examples: *
* parseInt("0", 10) returns 0
* parseInt("473", 10) returns 473
* parseInt("+42", 10) returns 42
* parseInt("-0", 10) returns 0
* parseInt("-FF", 16) returns -255
* parseInt("1100110", 2) returns 102
* parseInt("2147483647", 10) returns 2147483647
* parseInt("-2147483648", 10) returns -2147483648
* parseInt("2147483648", 10) throws a NumberFormatException
* parseInt("99", 8) throws a NumberFormatException
* parseInt("Kona", 10) throws a NumberFormatException
* parseInt("Kona", 27) returns 411787
* An exception of type {@code NumberFormatException} is * thrown if any of the following situations occurs: *
In other words, this method returns an {@code Integer} * object equal to the value of: * *
* {@code new Integer(Integer.parseInt(s, radix))} ** * @param s the string to be parsed. * @param radix the radix to be used in interpreting {@code s} * @return an {@code Integer} object holding the value * represented by the string argument in the specified * radix. * @exception NumberFormatException if the {@code String} * does not contain a parsable {@code int}. */ public static Integer valueOf(String s, int radix) throws NumberFormatException { return Integer.valueOf(parseInt(s,radix)); } /** * Returns an {@code Integer} object holding the * value of the specified {@code String}. The argument is * interpreted as representing a signed decimal integer, exactly * as if the argument were given to the {@link * #parseInt(java.lang.String)} method. The result is an * {@code Integer} object that represents the integer value * specified by the string. * *
In other words, this method returns an {@code Integer} * object equal to the value of: * *
* {@code new Integer(Integer.parseInt(s))} ** * @param s the string to be parsed. * @return an {@code Integer} object holding the value * represented by the string argument. * @exception NumberFormatException if the string cannot be parsed * as an integer. */ public static Integer valueOf(String s) throws NumberFormatException { return Integer.valueOf(parseInt(s, 10)); } /** * Cache to support the object identity semantics of autoboxing for values between * -128 and 127 (inclusive) as required by JLS. * * The cache is initialized on first usage. The size of the cache * may be controlled by the {@code -XX:AutoBoxCacheMax=
The first argument is treated as the name of a system * property. System properties are accessible through the {@link * java.lang.System#getProperty(java.lang.String)} method. The * string value of this property is then interpreted as an integer * value using the grammar supported by {@link Integer#decode decode} and * an {@code Integer} object representing this value is returned. * *
If there is no property with the specified name, if the * specified name is empty or {@code null}, or if the property * does not have the correct numeric format, then {@code null} is * returned. * *
In other words, this method returns an {@code Integer} * object equal to the value of: * *
* {@code getInteger(nm, null)} ** * @param nm property name. * @return the {@code Integer} value of the property. * @throws SecurityException for the same reasons as * {@link System#getProperty(String) System.getProperty} * @see java.lang.System#getProperty(java.lang.String) * @see java.lang.System#getProperty(java.lang.String, java.lang.String) */ public static Integer getInteger(String nm) { return getInteger(nm, null); } /** * Determines the integer value of the system property with the * specified name. * *
The first argument is treated as the name of a system * property. System properties are accessible through the {@link * java.lang.System#getProperty(java.lang.String)} method. The * string value of this property is then interpreted as an integer * value using the grammar supported by {@link Integer#decode decode} and * an {@code Integer} object representing this value is returned. * *
The second argument is the default value. An {@code Integer} object * that represents the value of the second argument is returned if there * is no property of the specified name, if the property does not have * the correct numeric format, or if the specified name is empty or * {@code null}. * *
In other words, this method returns an {@code Integer} object * equal to the value of: * *
* {@code getInteger(nm, new Integer(val))} ** * but in practice it may be implemented in a manner such as: * *
* Integer result = getInteger(nm, null);
* return (result == null) ? new Integer(val) : result;
* The second argument is the default value. The default value is * returned if there is no property of the specified name, if the * property does not have the correct numeric format, or if the * specified name is empty or {@code null}. * * @param nm property name. * @param val default value. * @return the {@code Integer} value of the property. * @throws SecurityException for the same reasons as * {@link System#getProperty(String) System.getProperty} * @see System#getProperty(java.lang.String) * @see System#getProperty(java.lang.String, java.lang.String) */ public static Integer getInteger(String nm, Integer val) { String v = null; try { v = System.getProperty(nm); } catch (IllegalArgumentException | NullPointerException e) { } if (v != null) { try { return Integer.decode(v); } catch (NumberFormatException e) { } } return val; } /** * Decodes a {@code String} into an {@code Integer}. * Accepts decimal, hexadecimal, and octal numbers given * by the following grammar: * *
** * DecimalNumeral, HexDigits, and OctalDigits * are as defined in section 3.10.1 of * The Java™ Language Specification, * except that underscores are not accepted between digits. * **
*- DecodableString: *
- Signopt DecimalNumeral *
- Signopt {@code 0x} HexDigits *
- Signopt {@code 0X} HexDigits *
- Signopt {@code #} HexDigits *
- Signopt {@code 0} OctalDigits * *
- Sign: *
- {@code -} *
- {@code +} *
The sequence of characters following an optional * sign and/or radix specifier ("{@code 0x}", "{@code 0X}", * "{@code #}", or leading zero) is parsed as by the {@code * Integer.parseInt} method with the indicated radix (10, 16, or * 8). This sequence of characters must represent a positive * value or a {@link NumberFormatException} will be thrown. The * result is negated if first character of the specified {@code * String} is the minus sign. No whitespace characters are * permitted in the {@code String}. * * @param nm the {@code String} to decode. * @return an {@code Integer} object holding the {@code int} * value represented by {@code nm} * @exception NumberFormatException if the {@code String} does not * contain a parsable integer. * @see java.lang.Integer#parseInt(java.lang.String, int) */ public static Integer decode(String nm) throws NumberFormatException { int radix = 10; int index = 0; boolean negative = false; Integer result; if (nm.length() == 0) throw new NumberFormatException("Zero length string"); char firstChar = nm.charAt(0); // Handle sign, if present if (firstChar == '-') { negative = true; index++; } else if (firstChar == '+') index++; // Handle radix specifier, if present if (nm.startsWith("0x", index) || nm.startsWith("0X", index)) { index += 2; radix = 16; } else if (nm.startsWith("#", index)) { index ++; radix = 16; } else if (nm.startsWith("0", index) && nm.length() > 1 + index) { index ++; radix = 8; } if (nm.startsWith("-", index) || nm.startsWith("+", index)) throw new NumberFormatException("Sign character in wrong position"); try { result = Integer.valueOf(nm.substring(index), radix); result = negative ? Integer.valueOf(-result.intValue()) : result; } catch (NumberFormatException e) { // If number is Integer.MIN_VALUE, we'll end up here. The next line // handles this case, and causes any genuine format error to be // rethrown. String constant = negative ? ("-" + nm.substring(index)) : nm.substring(index); result = Integer.valueOf(constant, radix); } return result; } /** * Compares two {@code Integer} objects numerically. * * @param anotherInteger the {@code Integer} to be compared. * @return the value {@code 0} if this {@code Integer} is * equal to the argument {@code Integer}; a value less than * {@code 0} if this {@code Integer} is numerically less * than the argument {@code Integer}; and a value greater * than {@code 0} if this {@code Integer} is numerically * greater than the argument {@code Integer} (signed * comparison). * @since 1.2 */ public int compareTo(Integer anotherInteger) { return compare(this.value, anotherInteger.value); } /** * Compares two {@code int} values numerically. * The value returned is identical to what would be returned by: *
* Integer.valueOf(x).compareTo(Integer.valueOf(y))
*
*
* @param x the first {@code int} to compare
* @param y the second {@code int} to compare
* @return the value {@code 0} if {@code x == y};
* a value less than {@code 0} if {@code x < y}; and
* a value greater than {@code 0} if {@code x > y}
* @since 1.7
*/
public static int compare(int x, int y) {
return (x < y) ? -1 : ((x == y) ? 0 : 1);
}
/**
* Compares two {@code int} values numerically treating the values
* as unsigned.
*
* @param x the first {@code int} to compare
* @param y the second {@code int} to compare
* @return the value {@code 0} if {@code x == y}; a value less
* than {@code 0} if {@code x < y} as unsigned values; and
* a value greater than {@code 0} if {@code x > y} as
* unsigned values
* @since 1.8
*/
public static int compareUnsigned(int x, int y) {
return compare(x + MIN_VALUE, y + MIN_VALUE);
}
/**
* Converts the argument to a {@code long} by an unsigned
* conversion. In an unsigned conversion to a {@code long}, the
* high-order 32 bits of the {@code long} are zero and the
* low-order 32 bits are equal to the bits of the integer
* argument.
*
* Consequently, zero and positive {@code int} values are mapped
* to a numerically equal {@code long} value and negative {@code
* int} values are mapped to a {@code long} value equal to the
* input plus 232.
*
* @param x the value to convert to an unsigned {@code long}
* @return the argument converted to {@code long} by an unsigned
* conversion
* @since 1.8
*/
public static long toUnsignedLong(int x) {
return ((long) x) & 0xffffffffL;
}
/**
* Returns the unsigned quotient of dividing the first argument by
* the second where each argument and the result is interpreted as
* an unsigned value.
*
* Note that in two's complement arithmetic, the three other * basic arithmetic operations of add, subtract, and multiply are * bit-wise identical if the two operands are regarded as both * being signed or both being unsigned. Therefore separate {@code * addUnsigned}, etc. methods are not provided. * * @param dividend the value to be divided * @param divisor the value doing the dividing * @return the unsigned quotient of the first argument divided by * the second argument * @see #remainderUnsigned * @since 1.8 */ public static int divideUnsigned(int dividend, int divisor) { // In lieu of tricky code, for now just use long arithmetic. return (int)(toUnsignedLong(dividend) / toUnsignedLong(divisor)); } /** * Returns the unsigned remainder from dividing the first argument * by the second where each argument and the result is interpreted * as an unsigned value. * * @param dividend the value to be divided * @param divisor the value doing the dividing * @return the unsigned remainder of the first argument divided by * the second argument * @see #divideUnsigned * @since 1.8 */ public static int remainderUnsigned(int dividend, int divisor) { // In lieu of tricky code, for now just use long arithmetic. return (int)(toUnsignedLong(dividend) % toUnsignedLong(divisor)); } // Bit twiddling /** * The number of bits used to represent an {@code int} value in two's * complement binary form. * * @since 1.5 */ @Native public static final int SIZE = 32; /** * The number of bytes used to represent a {@code int} value in two's * complement binary form. * * @since 1.8 */ public static final int BYTES = SIZE / Byte.SIZE; /** * Returns an {@code int} value with at most a single one-bit, in the * position of the highest-order ("leftmost") one-bit in the specified * {@code int} value. Returns zero if the specified value has no * one-bits in its two's complement binary representation, that is, if it * is equal to zero. * * @param i the value whose highest one bit is to be computed * @return an {@code int} value with a single one-bit, in the position * of the highest-order one-bit in the specified value, or zero if * the specified value is itself equal to zero. * @since 1.5 */ public static int highestOneBit(int i) { // HD, Figure 3-1 i |= (i >> 1); i |= (i >> 2); i |= (i >> 4); i |= (i >> 8); i |= (i >> 16); return i - (i >>> 1); } /** * Returns an {@code int} value with at most a single one-bit, in the * position of the lowest-order ("rightmost") one-bit in the specified * {@code int} value. Returns zero if the specified value has no * one-bits in its two's complement binary representation, that is, if it * is equal to zero. * * @param i the value whose lowest one bit is to be computed * @return an {@code int} value with a single one-bit, in the position * of the lowest-order one-bit in the specified value, or zero if * the specified value is itself equal to zero. * @since 1.5 */ public static int lowestOneBit(int i) { // HD, Section 2-1 return i & -i; } /** * Returns the number of zero bits preceding the highest-order * ("leftmost") one-bit in the two's complement binary representation * of the specified {@code int} value. Returns 32 if the * specified value has no one-bits in its two's complement representation, * in other words if it is equal to zero. * *
Note that this method is closely related to the logarithm base 2. * For all positive {@code int} values x: *
Note that left rotation with a negative distance is equivalent to * right rotation: {@code rotateLeft(val, -distance) == rotateRight(val, * distance)}. Note also that rotation by any multiple of 32 is a * no-op, so all but the last five bits of the rotation distance can be * ignored, even if the distance is negative: {@code rotateLeft(val, * distance) == rotateLeft(val, distance & 0x1F)}. * * @param i the value whose bits are to be rotated left * @param distance the number of bit positions to rotate left * @return the value obtained by rotating the two's complement binary * representation of the specified {@code int} value left by the * specified number of bits. * @since 1.5 */ public static int rotateLeft(int i, int distance) { return (i << distance) | (i >>> -distance); } /** * Returns the value obtained by rotating the two's complement binary * representation of the specified {@code int} value right by the * specified number of bits. (Bits shifted out of the right hand, or * low-order, side reenter on the left, or high-order.) * *
Note that right rotation with a negative distance is equivalent to * left rotation: {@code rotateRight(val, -distance) == rotateLeft(val, * distance)}. Note also that rotation by any multiple of 32 is a * no-op, so all but the last five bits of the rotation distance can be * ignored, even if the distance is negative: {@code rotateRight(val, * distance) == rotateRight(val, distance & 0x1F)}. * * @param i the value whose bits are to be rotated right * @param distance the number of bit positions to rotate right * @return the value obtained by rotating the two's complement binary * representation of the specified {@code int} value right by the * specified number of bits. * @since 1.5 */ public static int rotateRight(int i, int distance) { return (i >>> distance) | (i << -distance); } /** * Returns the value obtained by reversing the order of the bits in the * two's complement binary representation of the specified {@code int} * value. * * @param i the value to be reversed * @return the value obtained by reversing order of the bits in the * specified {@code int} value. * @since 1.5 */ public static int reverse(int i) { // HD, Figure 7-1 i = (i & 0x55555555) << 1 | (i >>> 1) & 0x55555555; i = (i & 0x33333333) << 2 | (i >>> 2) & 0x33333333; i = (i & 0x0f0f0f0f) << 4 | (i >>> 4) & 0x0f0f0f0f; i = (i << 24) | ((i & 0xff00) << 8) | ((i >>> 8) & 0xff00) | (i >>> 24); return i; } /** * Returns the signum function of the specified {@code int} value. (The * return value is -1 if the specified value is negative; 0 if the * specified value is zero; and 1 if the specified value is positive.) * * @param i the value whose signum is to be computed * @return the signum function of the specified {@code int} value. * @since 1.5 */ public static int signum(int i) { // HD, Section 2-7 return (i >> 31) | (-i >>> 31); } /** * Returns the value obtained by reversing the order of the bytes in the * two's complement representation of the specified {@code int} value. * * @param i the value whose bytes are to be reversed * @return the value obtained by reversing the bytes in the specified * {@code int} value. * @since 1.5 */ public static int reverseBytes(int i) { return ((i >>> 24) ) | ((i >> 8) & 0xFF00) | ((i << 8) & 0xFF0000) | ((i << 24)); } /** * Adds two integers together as per the + operator. * * @param a the first operand * @param b the second operand * @return the sum of {@code a} and {@code b} * @see java.util.function.BinaryOperator * @since 1.8 */ public static int sum(int a, int b) { return a + b; } /** * Returns the greater of two {@code int} values * as if by calling {@link Math#max(int, int) Math.max}. * * @param a the first operand * @param b the second operand * @return the greater of {@code a} and {@code b} * @see java.util.function.BinaryOperator * @since 1.8 */ public static int max(int a, int b) { return Math.max(a, b); } /** * Returns the smaller of two {@code int} values * as if by calling {@link Math#min(int, int) Math.min}. * * @param a the first operand * @param b the second operand * @return the smaller of {@code a} and {@code b} * @see java.util.function.BinaryOperator * @since 1.8 */ public static int min(int a, int b) { return Math.min(a, b); } /** use serialVersionUID from JDK 1.0.2 for interoperability */ @Native private static final long serialVersionUID = 1360826667806852920L; }