* code is simply its value.   *   * @return this Object's hash code   */  public int hashCode()  {    return value;  }  /**   * Returns <code>true</code> if <code>obj</code> is an instance of   * <code>Integer</code> and represents the same int value.   *   * @param obj the object to compare   * @return whether these Objects are semantically equal   */  public boolean equals(Object obj)  {    return obj instanceof Integer && value == ((Integer) obj).value;  }  /**   * Get the specified system property as an <code>Integer</code>. The   * <code>decode()</code> method will be used to interpret the value of   * the property.   *   * @param nm the name of the system property   * @return the system property as an <code>Integer</code>, or null if the   *         property is not found or cannot be decoded   * @throws SecurityException if accessing the system property is forbidden   * @see System#getProperty(String)   * @see #decode(String)   */  public static Integer getInteger(String nm)  {    return getInteger(nm, null);  }  /**   * Get the specified system property as an <code>Integer</code>, or use a   * default <code>int</code> value if the property is not found or is not   * decodable. The <code>decode()</code> method will be used to interpret   * the value of the property.   *   * @param nm the name of the system property   * @param val the default value   * @return the value of the system property, or the default   * @throws SecurityException if accessing the system property is forbidden   * @see System#getProperty(String)   * @see #decode(String)   */  public static Integer getInteger(String nm, int val)  {    Integer result = getInteger(nm, null);    return result == null ? new Integer(val) : result;  }  /**   * Get the specified system property as an <code>Integer</code>, or use a   * default <code>Integer</code> value if the property is not found or is   * not decodable. The <code>decode()</code> method will be used to   * interpret the value of the property.   *   * @param nm the name of the system property   * @param def the default value   * @return the value of the system property, or the default   * @throws SecurityException if accessing the system property is forbidden   * @see System#getProperty(String)   * @see #decode(String)   */  public static Integer getInteger(String nm, Integer def)  {    if (nm == null || "".equals(nm))      return def;    nm = System.getProperty(nm);    if (nm == null)      return def;    try      {        return decode(nm);      }    catch (NumberFormatException e)      {        return def;      }  }  /**   * Convert the specified <code>String</code> into an <code>Integer</code>.   * The <code>String</code> may represent decimal, hexadecimal, or   * octal numbers.   *   * <p>The extended BNF grammar is as follows:<br>   * <pre>   * <em>DecodableString</em>:   *      ( [ <code>-</code> ] <em>DecimalNumber</em> )   *    | ( [ <code>-</code> ] ( <code>0x</code> | <code>0X</code>   *              | <code>#</code> ) <em>HexDigit</em> { <em>HexDigit</em> } )   *    | ( [ <code>-</code> ] <code>0</code> { <em>OctalDigit</em> } )   * <em>DecimalNumber</em>:   *        <em>DecimalDigit except '0'</em> { <em>DecimalDigit</em> }   * <em>DecimalDigit</em>:   *        <em>Character.digit(d, 10) has value 0 to 9</em>   * <em>OctalDigit</em>:   *        <em>Character.digit(d, 8) has value 0 to 7</em>   * <em>DecimalDigit</em>:   *        <em>Character.digit(d, 16) has value 0 to 15</em>   * </pre>   * Finally, the value must be in the range <code>MIN_VALUE</code> to   * <code>MAX_VALUE</code>, or an exception is thrown.   *   * @param str the <code>String</code> to interpret   * @return the value of the String as an <code>Integer</code>   * @throws NumberFormatException if <code>s</code> cannot be parsed as a   *         <code>int</code>   * @throws NullPointerException if <code>s</code> is null   * @since 1.2   */  public static Integer decode(String str)  {    return new Integer(parseInt(str, 10, true));  }  /**   * Compare two Integers numerically by comparing their <code>int</code>   * values. The result is positive if the first is greater, negative if the   * second is greater, and 0 if the two are equal.   *   * @param i the Integer to compare   * @return the comparison   * @since 1.2   */  public int compareTo(Integer i)  {    if (value == i.value)      return 0;    // Returns just -1 or 1 on inequality; doing math might overflow.    return value > i.value ? 1 : -1;  }  /**   * Behaves like <code>compareTo(Integer)</code> unless the Object   * is not an <code>Integer</code>.   *   * @param o the object to compare   * @return the comparison   * @throws ClassCastException if the argument is not an <code>Integer</code>   * @see #compareTo(Integer)   * @see Comparable   * @since 1.2   */  public int compareTo(Object o)  {    return compareTo((Integer) o);  }  /**   * Return the number of bits set in x.   * @param x value to examine   * @since 1.5   */  public static int bitCount(int x)  {    // Successively collapse alternating bit groups into a sum.    x = ((x >> 1) & 0x55555555) + (x & 0x55555555);    x = ((x >> 2) & 0x33333333) + (x & 0x33333333);    x = ((x >> 4) & 0x0f0f0f0f) + (x & 0x0f0f0f0f);    x = ((x >> 8) & 0x00ff00ff) + (x & 0x00ff00ff);    return ((x >> 16) & 0x0000ffff) + (x & 0x0000ffff);  }  /**   * Rotate x to the left by distance bits.   * @param x the value to rotate   * @param distance the number of bits by which to rotate   * @since 1.5   */  public static int rotateLeft(int x, int distance)  {    // This trick works because the shift operators implicitly mask    // the shift count.    return (x << distance) | (x >>> - distance);  }  /**   * Rotate x to the right by distance bits.   * @param x the value to rotate   * @param distance the number of bits by which to rotate   * @since 1.5   */  public static int rotateRight(int x, int distance)  {    // This trick works because the shift operators implicitly mask    // the shift count.    return (x << - distance) | (x >>> distance);  }  /**   * Find the highest set bit in value, and return a new value   * with only that bit set.   * @param value the value to examine   * @since 1.5   */  public static int highestOneBit(int value)  {    value |= value >>> 1;    value |= value >>> 2;    value |= value >>> 4;    value |= value >>> 8;    value |= value >>> 16;    return value ^ (value >>> 1);  }  /**   * Return the number of leading zeros in value.   * @param value the value to examine   * @since 1.5   */  public static int numberOfLeadingZeros(int value)  {    value |= value >>> 1;    value |= value >>> 2;    value |= value >>> 4;    value |= value >>> 8;    value |= value >>> 16;    return bitCount(~value);  }  /**   * Find the lowest set bit in value, and return a new value   * with only that bit set.   * @param value the value to examine   * @since 1.5   */  public static int lowestOneBit(int value)  {    // Classic assembly trick.    return value & - value;  }  /**   * Find the number of trailing zeros in value.   * @param value the value to examine   * @since 1.5   */  public static int numberOfTrailingZeros(int value)  {    return bitCount((value & -value) - 1);  }  /**   * Return 1 if x is positive, -1 if it is negative, and 0 if it is   * zero.   * @param x the value to examine   * @since 1.5   */  public static int signum(int x)  {    return x < 0 ? -1 : (x > 0 ? 1 : 0);  }  /**   * Reverse the bytes in val.   * @since 1.5   */  public static int reverseBytes(int val)  {    return (  ((val >> 24) & 0xff)	    | ((val >> 8) & 0xff00)	    | ((val << 8) & 0xff0000)	    | ((val << 24) & 0xff000000));  }  /**   * Reverse the bits in val.   * @since 1.5   */  public static int reverse(int val)  {    // Successively swap alternating bit groups.    val = ((val >> 1) & 0x55555555) + ((val << 1) & ~0x55555555);    val = ((val >> 2) & 0x33333333) + ((val << 2) & ~0x33333333);    val = ((val >> 4) & 0x0f0f0f0f) + ((val << 4) & ~0x0f0f0f0f);    val = ((val >> 8) & 0x00ff00ff) + ((val << 8) & ~0x00ff00ff);    return ((val >> 16) & 0x0000ffff) + ((val << 16) & ~0x0000ffff);  }  /**   * Helper for converting unsigned numbers to String.   *   * @param num the number   * @param exp log2(digit) (ie. 1, 3, or 4 for binary, oct, hex)   */  // Package visible for use by Long.  static String toUnsignedString(int num, int exp)  {    // Use an array large enough for a binary number.    int mask = (1 << exp) - 1;    char[] buffer = new char[32];    int i = 32;    do      {        buffer[--i] = digits[num & mask];        num >>>= exp;      }    while (num != 0);    // Package constructor avoids an array copy.    return new String(buffer, i, 32 - i, true);  }  /**   * Helper for parsing ints, used by Integer, Short, and Byte.   *   * @param str the string to parse   * @param radix the radix to use, must be 10 if decode is true   * @param decode if called from decode   * @return the parsed int value   * @throws NumberFormatException if there is an error   * @throws NullPointerException if decode is true and str if null   * @see #parseInt(String, int)   * @see #decode(String)   * @see Byte#parseByte(String, int)   * @see Short#parseShort(String, int)   */  static int parseInt(String str, int radix, boolean decode)  {    if (! decode && str == null)      throw new NumberFormatException();    int index = 0;    int len = str.length();    boolean isNeg = false;    if (len == 0)      throw new NumberFormatException("string length is null");    int ch = str.charAt(index);    if (ch == '-')      {        if (len == 1)          throw new NumberFormatException("pure '-'");        isNeg = true;        ch = str.charAt(++index);      }    if (decode)      {        if (ch == '0')          {            if (++index == len)              return 0;            if ((str.charAt(index) & ~('x' ^ 'X')) == 'X')              {                radix = 16;                index++;              }            else              radix = 8;          }        else if (ch == '#')          {            radix = 16;            index++;          }      }    if (index == len)      throw new NumberFormatException("non terminated number: " + str);    int max = MAX_VALUE / radix;    // We can't directly write `max = (MAX_VALUE + 1) / radix'.    // So instead we fake it.    if (isNeg && MAX_VALUE % radix == radix - 1)      ++max;    int val = 0;    while (index < len)      {	if (val < 0 || val > max)	  throw new NumberFormatException("number overflow (pos=" + index + ") : " + str);        ch = Character.digit(str.charAt(index++), radix);        val = val * radix + ch;        if (ch < 0 || (val < 0 && (! isNeg || val != MIN_VALUE)))          throw new NumberFormatException("invalid character at position " + index + " in " + str);      }    return isNeg ? -val : val;  }}