Integer i = 4; //自动装箱，会自动转换为以下形式：Integer i = new Integer(4);
i += 6; //先自动拆箱为int，后再自动装箱为Integer
System.out.println(i);//10。这里 i 仍为Integer，只不过会自动调用 i.toString() 方法

是否相等

// 十进制-->其他进制
System.out.println(Integer.toBinaryString(16));//2进制，10000
System.out.println(Integer.toOctalString(16));//8进制，20
System.out.println(Integer.toHexString(16));//16进制，10
System.out.println(Integer.toString(16, 2));//可转化为任意进制，10000
System.out.println("*******************************************");
// 某进制的字符串-->十进制数
System.out.println(Integer.parseInt("-06"));//-6，将十进制字符串转换为十进制数
System.out.println(Integer.parseInt("-10", 2));//-2，将二进制字符串转换为十进制数
System.out.println(Integer.parseInt("-10", 16));//-16，将16进制字符串转换为十进制数  

• 构造方法 Number()    
  
• byte byteValue() 以 byte 形式返回指定的数值。
  
• abstract  double doubleValue() 以 double 形式返回指定的数值。
  
• abstract  float floatValue() 以 float 形式返回指定的数值。
  
• abstract  int intValue() 以 int 形式返回指定的数值。
  
• abstract  long longValue() 以 long 形式返回指定的数值。
  
• short shortValue() 以 short 形式返回指定的数值。  
  

• Integer(int value)   构造一个新分配的 Integer 对象，它表示指定的 int 值。
  
• Integer(String s)   构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值。
  

static int bitCount(int i)     返回指定 int 值的二进制补码表示形式的 1 位的数量。 
static Integer getInteger(String nm)     确定具有指定名称的系统属性的整数值。 
static Integer getInteger(String nm, int val)     确定具有指定名称的系统属性的整数值。 
static Integer getInteger(String nm, Integer val)     返回具有指定名称的系统属性的整数值。 
static int signum(int i)     返回指定 int 值的符号函数。 
static int highestOneBit(int i)     返回具有至多单个 1 位的 int 值，在指定的 int 值中最高位（最左边）的 1 位的位置。
static int lowestOneBit(int i)     返回具有至多单个 1 位的 int 值，在指定的 int 值中最低位（最右边）的 1 位的位置。 
static int numberOfLeadingZeros(int i)     在指定 int 值的二进制补码表示形式中最高位（最左边）的 1 位之前，返回零位的数量。 
static int numberOfTrailingZeros(int i)     返回指定的 int 值的二进制补码表示形式中最低（“最右边”）的为 1 的位后面的零位个数。 
static Integer decode(String nm)     将 String 解码为 Integer
跟在（可选）负号和/或基数说明符（“0x”、“0X”、“#”或前导零）后面的字符序列是使用指示的基数（10、16 或 8）通过 Integer.parseInt 方法解析的。字符序列必须表示一个正值，否则会抛出 NumberFormatException。如果指定的 String 的第一个字符是减号，则对结果求反。String 中不允许出现空白字符。
static int parseInt(String s)     将字符串参数作为有符号的十进制整数进行解析
除了第一个字符可以是用来表示负值的 ASCII 减号 ‘-‘ ( ‘\u002D‘) 外，字符串中的字符都必须是十进制数字。返回得到的整数值，就好像将该参数和基数 10 作为参数赋予 parseInt(String, int) 方法一样。
参数：s - 包含要解析的 int 表示形式的 String。
返回：用十进制参数表示的整数值。
如果字符串不包含可解析的整数，NumberFormatException 
static int parseInt(String s, int radix)     使用第二个参数指定的基数，将字符串参数解析为有符号的整数
除了第一个字符可以是用来表示负值的 ASCII 减号 ‘-‘ ( ‘\u002D’)外，字符串中的字符必须都是指定基数的数字（通过 Character.digit(char, int) 是否返回一个负值确定）。返回得到的整数值。
如果发生以下任意一种情况，则抛出一个 NumberFormatException 类型的异常：
1、第一个参数为 null 或一个长度为零的字符串。
2、基数小于 Character.MIN_RADIX 或者大于 Character.MAX_RADIX。
3、假如字符串的长度超过 1，那么除了第一个字符可以是减号 ‘-‘ (‘u002D’) 外，字符串中存在任意不是由指定基数的数字表示的字符。
4、字符串表示的值不是 int 类型的值。
参数：radix - 解析 s 时使用的基数。
返回：使用指定基数的字符串参数表示的整数。
static int reverse(int i)     返回通过反转指定 int 值的二进制补码表示形式中位的顺序而获得的值。 
static int reverseBytes(int i)     返回通过反转指定 int 值的二进制补码表示形式中字节的顺序而获得的值。 
static int rotateLeft(int i, int distance)     返回根据指定的位数循环左移指定的 int 值的二进制补码表示形式而得到的值。 
static int rotateRight(int i, int distance)     返回根据指定的位数循环右移指定的 int 值的二进制补码表示形式而得到的值。 
static String toBinaryString(int i)     以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。 
static String toHexString(int i)     以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。 
static String toOctalString(int i)     以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。 
static String toString(int i)     返回一个表示指定整数的 String 对象。 
将该参数转换为有符号的十进制表示形式，以字符串形式返回它，就好像将参数和基数 10 作为参数赋予 toString(int, int) 方法。
static String toString(int i, int radix)     返回用第二个参数指定基数表示的第一个参数的字符串表示形式。 
如果基数radix小于 Character.MIN_RADIX 或者大于 Character.MAX_RADIX，则改用基数 10。
如果第一个参数为负，则结果中的第一个元素为 ASCII 的减号 ‘-‘ (‘\u002D‘)。如果第一个参数为非负，则没有符号字符出现在结果中。
结果中的剩余字符表示第一个参数的大小。如果大小为零，则用一个零字符 ‘0‘ (‘\u0030‘) 表示；否则，大小的表示形式中的第一个字符将不是零字符。
用以下 ASCII 字符作为数字：0123456789abcdefghijklmnopqrstuvwxyz。其范围是从 ‘\u0030‘ 到 ‘\u0039‘ 和从 ‘\u0061‘ 到 ‘\u007A‘。
如果 radix 为 N, 则按照所示顺序，使用这些字符中的前 N 个作为其数字。因此，十六进制（基数为 16）的数字是 0123456789abcdef。
static Integer valueOf(int i)     返回一个表示指定的 int 值的 Integer 实例。 
如果不需要新的 Integer 实例，则通常应优先使用该方法，而不是构造方法 Integer(int)，因为该方法有可能通过缓存经常请求的值而显著提高空间和时间性能。
static Integer valueOf(String s)     返回保存指定的 String 的值的 Integer 对象。 
将该参数解释为表示一个有符号的十进制整数, 就好像将该参数赋予 parseInt(String) 方法一样。结果是一个表示字符串指定的整数值的 Integer 对象。
该方法返回一个等于以下值的 Integer 对象：new Integer(Integer.parseInt(s))
static Integer valueOf(String s, int radix)     返回一个 Integer 对象，该对象中保存了用第二个参数提供的基数进行解析时从指定的 String 中提取的值。 
该方法返回一个等于以下值的 Integer 对象：new Integer(Integer.parseInt(s, radix))

普通方法
int compareTo(Integer anotherInteger)     在数字上比较两个 Integer 对象。 
boolean equals(Object obj)     比较此对象与指定对象。 
int hashCode()     返回此 Integer 的哈希码。 
byte byteValue()     以 byte 类型返回该 Integer 的值。 
double doubleValue()     以 double 类型返回该 Integer 的值。 
float floatValue()     以 float 类型返回该 Integer 的值。 int intValue()     以 int 类型返回该 Integer 的值。 
long longValue()     以 long 类型返回该 Integer 的值。 
short shortValue()     以 short 类型返回该 Integer 的值。 
String toString()     返回一个表示该 Integer 值的 String 对象。 

java.util.Random extends java.lang.Object Number implements Serializable
直接已知子类：SecureRandom

• Random()    创建一个新的随机数生成器。
  
• 此构造方法将随机数生成器的种子设置为某个值，该值与此构造方法的所有其他调用所用的值完全不同。
• Random(long seed)    使用单个 long 种子创建一个新的随机数生成器。  参数：seed - 初始种子
• 该种子是伪随机数生成器的内部状态的初始值，该生成器可通过方法 next(int) 维护。
• 调用 new Random(seed) 等效于： Random r = new Random();   r.setSeed(seed);

• protected  int next(int bits)    生成下一个伪随机数。当被所有其他方法使用时，子类应该重写此方法。
• next 的常规协定是，返回一个 int 值，如果参数 bits 位处于 [ 1 , 32 ] 之间，那么返回值的多数低位都将（大致）是单独选择的位值，每个位值是 0 或 1 的机会（大致）相等。
• 参数：bits - 随机位。
• 返回：随机数生成器序列的下一个伪随机值。
• void setSeed(long seed)    使用单个 long 种子设置此随机数生成器的种子。
  
• setSeed 的常规协定是它更改此随机数生成器对象的状态，使其状态好像是刚刚使用参数 seed 作为种子创建它的状态一样。
• 通过将种子自动更新为 (seed ^ 0x5DEECE66DL) & ((1L << 48) - 1) 并清除 nextGaussian() 使用的 haveNextNextGaussian 标志， Random 类可实现 setSeed 方法。
• Random 类实现的 setSeed 恰好只使用 48 位的给定种子。但是，通常重写方法可能使用 long 参数的所有 64 位作为种子值。

• boolean nextBoolean()    返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 boolean 值。
• nextBoolean 的常规协定是，伪随机地生成并返回一个 boolean 值。值 true 和 false 的生成概率（大致）相同。
• Random 类按如下方式实现 nextBoolean 方法： public boolean nextBoolean() {  return next(1) != 0; }
• void nextBytes(byte[] bytes)    生成随机字节并将其置于用户提供的 byte 数组中。
• 所生成的随机字节数等于该 byte 数组的长度。
• 参数：bytes - 用随机字节填充的 byte 数组
• double nextDouble()    返回下一个伪随机数，它是取自此随机数生成器序列的、在 [ 0.0 , 1.0 ) 之间均匀分布的 double 值。
  
• nextDouble 的常规协定是，伪随机地生成并返回一个从 0.0d（包括）到 1.0d（不包括）范围内均匀选择（大致）的 double 值。
• Random 类按如下方式实现 nextDouble 方法： public double nextDouble() { return (((long)next(26) << 27) + next(27)) / (double)(1L << 53); }
• float nextFloat()    返回下一个伪随机数，它是取自此随机数生成器序列的、在 [ 0.0 , 1.0 ] 之间均匀分布的 float 值。
  
• nextFloat 的常规协定是，伪随机地生成并返回一个从 0.0f（包括）到 1.0f（包括）范围内均匀选择（大致）的 float 值。所有可能的 2^24 个 float 值（其形式为 m x 2^-24，其中 m 是一个小于 2^24 的正整数）的生成概率（大致）相同。
• Random 类按如下方式实现 nextFloat 方法： public float nextFloat() {  return next(24) / ((float)(1 << 24)); }
• double nextGaussian()    返回下一个伪随机数，它是取自此随机数生成器序列的、呈高斯（“正态”）分布的 double 值，其平均值是 0.0，标准差是 1.0。
  
• nextGaussian 的常规协定是，伪随机地生成并返回一个 double 值，该值从（大致）具有平均值 0.0 和标准差 1.0 的标准正态分布中选择。
• int nextInt()    返回下一个伪随机数，它是此随机数生成器的序列中均匀分布的 int 值。
  
• nextInt 的常规协定是，伪随机地生成并返回一个 int 值。所有 2^32 个可能 int 值的生成概率（大致）相同。
• Random 类按如下方式实现 nextInt 方法： public int nextInt() { return next(32);  }
• int nextInt(int n)    返回一个伪随机数，它是取自此随机数生成器序列的、在 [ 0 , 指定值 ) 之间均匀分布的 int 值。
  
• nextInt 的常规协定是，伪随机地生成并返回指定范围中的一个 int 值。所有可能的 n 个 int 值的生成概率（大致）相同。
• n 必须为正数，否则抛出IllegalArgumentException
• long nextLong()    返回下一个伪随机数，它是取自此随机数生成器序列的均匀分布的 long 值。
• Random 类按如下方式实现 nextLong 方法： public long nextLong() { return ((long)next(32) << 32) + next(32);  }
• 因为 Random 类使用只以 48 位表示的种子，所以此算法不会返回所有可能的 long 值。