/**@class java.lang.Integer
 implements java.lang.Comparable

@extends java.lang.Number

 The wrapper for the primitive type {@code int}.
 <p>
 Implementation note: The "bit twiddling" methods in this class use techniques
 described in <a href="http://www.hackersdelight.org/">Henry S. Warren,
 Jr.'s Hacker's Delight, (Addison Wesley, 2002)</a> and <a href=
 "http://graphics.stanford.edu/~seander/bithacks.html">Sean Anderson's
 Bit Twiddling Hacks.</a>

 @see java.lang.Long
 @since 1.0
*/
var Integer = {

/** Constant for the maximum {@code int} value, 2<sup>31</sup>-1.
*/
MAX_VALUE : "2147483647",
/** Constant for the minimum {@code int} value, -2<sup>31</sup>.
*/
MIN_VALUE : "-2147483648",
/** Constant for the number of bits needed to represent an {@code int} in
 two's complement form.

 @since 1.5
*/
SIZE : "32",
/** The {@link java.lang.Class} object that represents the primitive type {@code int}.
*/
TYPE : "null",
/**
*/
byteValue : function(  ) {},

/**Compares this object to the specified integer object to determine their
 relative order.
@param {Number} object
            the integer object to compare this object to.
@return {Number} a negative value if the value of this integer is less than the
         value of {@code object}; 0 if the value of this integer and the
         value of {@code object} are equal; a positive value if the value
         of this integer is greater than the value of {@code object}.
@see java.lang.Comparable
@since 1.2
*/
compareTo : function(  ) {},

/**Compares two {@code int} values.
@return {Number} 0 if lhs = rhs, less than 0 if lhs &lt; rhs, and greater than 0
         if lhs &gt; rhs.
@since 1.7
*/
compare : function(  ) {},

/**Parses the specified string and returns a {@code Integer} instance if the
 string can be decoded into an integer value. The string may be an
 optional sign character ("-" or "+") followed by a hexadecimal ("0x..."
 or "#..."), octal ("0..."), or decimal ("...") representation of an
 integer.
@param {String} string
            a string representation of an integer value.
@return {Number} an {@code Integer} containing the value represented by
         {@code string}.
@throws NumberFormatException
            if {@code string} cannot be parsed as an integer value.
*/
decode : function(  ) {},

/**
*/
doubleValue : function(  ) {},

/**Compares this instance with the specified object and indicates if they
 are equal. In order to be equal, {@code o} must be an instance of
 {@code Integer} and have the same integer value as this object.
@param {Object {Object}} o
            the object to compare this integer with.
@return {Boolean} {@code true} if the specified object is equal to this
         {@code Integer}; {@code false} otherwise.
*/
equals : function(  ) {},

/**
*/
floatValue : function(  ) {},

/**Returns the {@code Integer} value of the system property identified by
 {@code string}. Returns {@code null} if {@code string} is {@code null}
 or empty, if the property can not be found or if its value can not be
 parsed as an integer.
@param {String} string
            the name of the requested system property.
@return {Number} the requested property's value as an {@code Integer} or
         {@code null}.
*/
getInteger : function(  ) {},

/**Returns the {@code Integer} value of the system property identified by
 {@code string}. Returns the specified default value if {@code string} is
 {@code null} or empty, if the property can not be found or if its value
 can not be parsed as an integer.
@param {String} string
            the name of the requested system property.
@param {Number} defaultValue
            the default value that is returned if there is no integer
            system property with the requested name.
@return {Number} the requested property's value as an {@code Integer} or the
         default value.
*/
getInteger : function(  ) {},

/**Returns the {@code Integer} value of the system property identified by
 {@code string}. Returns the specified default value if {@code string} is
 {@code null} or empty, if the property can not be found or if its value
 can not be parsed as an integer.
@param {String} string
            the name of the requested system property.
@param {Number} defaultValue
            the default value that is returned if there is no integer
            system property with the requested name.
@return {Number} the requested property's value as an {@code Integer} or the
         default value.
*/
getInteger : function(  ) {},

/**
*/
hashCode : function(  ) {},

/**Gets the primitive value of this int.
@return {Number} this object's primitive value.
*/
intValue : function(  ) {},

/**
*/
longValue : function(  ) {},

/**Parses the specified string as a signed decimal integer value. The ASCII
 characters - ('-') and + ('+') are recognized as the minus and
 plus signs.
@param {String} string
            the string representation of an integer value.
@return {Number} the primitive integer value represented by {@code string}.
@throws NumberFormatException
             if {@code string} cannot be parsed as an integer value.
*/
parseInt : function(  ) {},

/**Parses the specified string as a signed integer value using the specified
 radix. The ASCII characters - ('-') and + ('+') are recognized
 as the minus and plus signs.
@param {String} string
            the string representation of an integer value.
@param {Number} radix
            the radix to use when parsing.
@return {Number} the primitive integer value represented by {@code string} using
         {@code radix}.
@throws NumberFormatException
             if {@code string} cannot be parsed as an integer value,
             or {@code radix < Character.MIN_RADIX ||
             radix > Character.MAX_RADIX}.
*/
parseInt : function(  ) {},

/**Equivalent to {@code parsePositiveInt(string, 10)}.
@see #parsePositiveInt(String, int)
@hide 
*/
parsePositiveInt : function(  ) {},

/**Parses the specified string as a positive integer value using the
 specified radix. 0 is considered a positive integer.
 <p>
 This method behaves the same as {@link #parseInt(String, int)} except
 that it disallows leading '+' and '-' characters. See that method for
 error conditions.
@see #parseInt(String, int)
@hide 
*/
parsePositiveInt : function(  ) {},

/**
*/
shortValue : function(  ) {},

/**Converts the specified integer into its binary string representation. The
 returned string is a concatenation of '0' and '1' characters.
@param {Number} i
            the integer to convert.
@return {String} the binary string representation of {@code i}.
*/
toBinaryString : function(  ) {},

/**Converts the specified integer into its hexadecimal string
 representation. The returned string is a concatenation of characters from
 '0' to '9' and 'a' to 'f'.
@param {Number} i
            the integer to convert.
@return {String} the hexadecimal string representation of {@code i}.
*/
toHexString : function(  ) {},

/**Converts the specified integer into its octal string representation. The
 returned string is a concatenation of characters from '0' to '7'.
@param {Number} i
            the integer to convert.
@return {String} the octal string representation of {@code i}.
*/
toOctalString : function(  ) {},

/**
*/
toString : function(  ) {},

/**Converts the specified integer into its decimal string representation.
 The returned string is a concatenation of a minus sign if the number is
 negative and characters from '0' to '9'.
@param {Number} i
            the integer to convert.
@return {String} the decimal string representation of {@code i}.
*/
toString : function(  ) {},

/**Converts the specified signed integer into a string representation based on the
 specified radix. The returned string is a concatenation of a minus sign
 if the number is negative and characters from '0' to '9' and 'a' to 'z',
 depending on the radix. If {@code radix} is not in the interval defined
 by {@code Character.MIN_RADIX} and {@code Character.MAX_RADIX} then 10 is
 used as the base for the conversion.

 <p>This method treats its argument as signed. If you want to convert an
 unsigned value to one of the common non-decimal bases, you may find
 {@link #toBinaryString}, {@code #toHexString}, or {@link #toOctalString}
 more convenient.
@param {Number} i
            the signed integer to convert.
@param {Number} radix
            the base to use for the conversion.
@return {String} the string representation of {@code i}.
*/
toString : function(  ) {},

/**Parses the specified string as a signed decimal integer value.
@param {String} string
            the string representation of an integer value.
@return {Number} an {@code Integer} instance containing the integer value
         represented by {@code string}.
@throws NumberFormatException
             if {@code string} cannot be parsed as an integer value.
@see #parseInt(String)
*/
valueOf : function(  ) {},

/**Parses the specified string as a signed integer value using the specified
 radix.
@param {String} string
            the string representation of an integer value.
@param {Number} radix
            the radix to use when parsing.
@return {Number} an {@code Integer} instance containing the integer value
         represented by {@code string} using {@code radix}.
@throws NumberFormatException
             if {@code string} cannot be parsed as an integer value, or
             {@code radix < Character.MIN_RADIX ||
             radix > Character.MAX_RADIX}.
@see #parseInt(String, int)
*/
valueOf : function(  ) {},

/**Determines the highest (leftmost) bit of the specified integer that is 1
 and returns the bit mask value for that bit. This is also referred to as
 the Most Significant 1 Bit. Returns zero if the specified integer is
 zero.
@param {Number} i
            the integer to examine.
@return {Number} the bit mask indicating the highest 1 bit in {@code i}.
@since 1.5
*/
highestOneBit : function(  ) {},

/**Determines the lowest (rightmost) bit of the specified integer that is 1
 and returns the bit mask value for that bit. This is also referred
 to as the Least Significant 1 Bit. Returns zero if the specified integer
 is zero.
@param {Number} i
            the integer to examine.
@return {Number} the bit mask indicating the lowest 1 bit in {@code i}.
@since 1.5
*/
lowestOneBit : function(  ) {},

/**Determines the number of leading zeros in the specified integer prior to
 the {@link #highestOneBit(int) highest one bit}.
@param {Number} i
            the integer to examine.
@return {Number} the number of leading zeros in {@code i}.
@since 1.5
*/
numberOfLeadingZeros : function(  ) {},

/**Determines the number of trailing zeros in the specified integer after
 the {@link #lowestOneBit(int) lowest one bit}.
@param {Number} i
            the integer to examine.
@return {Number} the number of trailing zeros in {@code i}.
@since 1.5
*/
numberOfTrailingZeros : function(  ) {},

/**Counts the number of 1 bits in the specified integer; this is also
 referred to as population count.
@param {Number} i
            the integer to examine.
@return {Number} the number of 1 bits in {@code i}.
@since 1.5
*/
bitCount : function(  ) {},

/**Rotates the bits of the specified integer to the left by the specified
 number of bits.
@param {Number} i
            the integer value to rotate left.
@param {Number} distance
            the number of bits to rotate.
@return {Number} the rotated value.
@since 1.5
*/
rotateLeft : function(  ) {},

/**Rotates the bits of the specified integer to the right by the specified
 number of bits.
@param {Number} i
            the integer value to rotate right.
@param {Number} distance
            the number of bits to rotate.
@return {Number} the rotated value.
@since 1.5
*/
rotateRight : function(  ) {},

/**Reverses the order of the bytes of the specified integer.
@param {Number} i
            the integer value for which to reverse the byte order.
@return {Number} the reversed value.
@since 1.5
*/
reverseBytes : function(  ) {},

/**Reverses the order of the bits of the specified integer.
@param {Number} i
            the integer value for which to reverse the bit order.
@return {Number} the reversed value.
@since 1.5
*/
reverse : function(  ) {},

/**Returns the value of the {@code signum} function for the specified
 integer.
@param {Number} i
            the integer value to check.
@return {Number} -1 if {@code i} is negative, 1 if {@code i} is positive, 0 if
         {@code i} is zero.
@since 1.5
*/
signum : function(  ) {},

/**Returns a {@code Integer} instance for the specified integer value.
 <p>
 If it is not necessary to get a new {@code Integer} instance, it is
 recommended to use this method instead of the constructor, since it
 maintains a cache of instances which may result in better performance.
@param {Number} i
            the integer value to store in the instance.
@return {Number} a {@code Integer} instance containing {@code i}.
@since 1.5
*/
valueOf : function(  ) {},


};