Java中的Integer类

常见对象(Integer类的概述和构造方法)

如果有两个需求：
需求:

1. 将100转换成二进制, 八进制, 十六进制

2. 判断一个数是否在int的范围内

当然，可以使用最基本的方法累除取余来求一个十进制数的其他进制形式，也可以根据是否在int型数据的范围来判断这个数是否在int的范围内，我们不能使用int型变量.方法来调用一些现成的方法，但是Java为了我们更方便的去操作基本数据类型，给我们提供与之对应的包装类型

基本类型	包装类型
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double
char	Character
boolean	Boolean

Integer类概述:
在Java中，可能会使用到int类型的数据，但可能会有所要求：比如只能使用引用数据类型，但是由于int类型是基本数据类型，无法直接使用，所以需要进行包装，这就引入了Integer类，其他基本数据类型的包装类也是这样

Integer 类在对象中包装了一个基本类型 int 的值,该类提供了多个方法，能在 int 类型和 String 类型之间互相转换，还提供了处理 int 类型时非常有用的其他一些常量和方法

用Integer类解决上述的两个需求：（省略主方法）

int num=100;
String string = Integer.toBinaryString(num);
String string1 = Integer.toOctalString(num);
String string2 = Integer.toHexString(num);

通过调用Integer类的静态方法可以直接将一个int型整数转换为相应的二进制、八进制以及十六进制并且返回结果的字符串形式，我们通过查阅API可以知道上面的静态方法的格式

1. static String toBinaryString(int i)， 以二进制（基数 2）无符号整数形式返回一个整数参数的字符串表示形式。
2. static String toHexString(int i)， 以十六进制（基数 16）无符号整数形式返回一个整数参数的字符串表示形式。
3. static String toOctalString(int i)，以八进制（基数 8）无符号整数形式返回一个整数参数的字符串表示形式。

通过查阅得到上面的方法的状态修饰符是static，所以这些方法都是静态方法，可以直接通过类名来调用

当然在Integer类中还存在一些常量，可以直接通过类来调用常量来判断一个数据是否在int的范围内

boolean b= 100000>=Integer.MIN_VALUE&& 100000<=Integer.MAX_VALUE?true:false;
System.out.println(b);

这里不再赘述

Integer类的构造方法

Integer( int value)，构造一个新分配的 Integer 对象，它表示指定的 int 值。
Integer(String s)，构造一个新分配的 Integer 对象，它表示 String 参数所指示的 int 值，这里需要一个字面上是数字的字符串

常见对象(String和int类型的相互转换)

int --> String

1. 和""（空字符串）进行拼接,在我之前的博客中使用打印方法时一直在这样使用

2. static String valueOf(int i)，String类中的静态方法，可以返回 int 参数的字符串表示形式。由于是静态方法，可以直接使用类名来调用

3. static String toString(int i) ，这是Integer类中的静态方法，可以返回一个表示指定整数的 String 对象。

String --> int

1. String --> Integer --> intValue();

2. static int parseInt(String s) ,将字符串参数作为有符号的十进制整数进行解析,返回一个和字面值一样的int型数据

上述讲解的代码实现：

int ----->String

int num=100;
String str=num+"";
String s1 = String.valueOf(num);
String s = new Integer(num).toString();

String ----->int （必须字符串的字面值是数字）

String str2="50";

方式1

Integer integer = new Integer(str2); //调用第二种构造方法
int i = integer.intValue();//将包装类型，转换成他所对应的基本类型
System.out.println(i+1);

方式2

int i1 = Integer.parseInt(str2);      //直接使用Integer中的静态方法，实现起来更加方便
System.out.println(i1);

常见对象(JDK5的新特性自动装箱和拆箱)

JDK5的新特性
自动装箱：把基本类型转换为包装类类型
自动拆箱：把包装类类型转换为基本类型
代码示例：

package org.westos.demo3;

/**
 * @Author: Administrator
 * @CreateTime: 2019-05-01 11:22
 */
public class MyTest {
    public static void main(String[] args) {
        Integer ii = 100;//自动装箱
        ii += 200;//自动拆箱。自动装箱

        Integer integer = new Integer(1000);
        int i = integer.intValue(); //手动拆箱

        Integer integer1 = Integer.valueOf(100);//手动装箱
        Integer integer2 = Integer.valueOf("10000");
    }
}

在上述代码中存在自动装箱、自动拆箱、手动装箱以及手动拆箱：

注意事项：
在使用时，Integer x = null;代码就会出现NullPointerException。
建议先判断是否为null，然后再使用。

常见对象(Integer的面试题)

A:Integer的面试题
	看程序写结果
	
	Integer i1 = new Integer(127);
	Integer i2 = new Integer(127);
	System.out.println(i1 == i2);
	System.out.println(i1.equals(i2));
	System.out.println("-----------");

	Integer i3 = new Integer(128);
	Integer i4 = new Integer(128);
	System.out.println(i3 == i4);
	System.out.println(i3.equals(i4));
	System.out.println("-----------");

	Integer i5 = 128;
	Integer i6 = 128;
	System.out.println(i5 == i6);
	System.out.println(i5.equals(i6));
	System.out.println("-----------");

	Integer i7 = 127;
	Integer i8 = 127;
	System.out.println(i7 == i8);
	System.out.println(i7.equals(i8));

1. 由于我们要经常使用Integer类，所以他会提前为int型创建-128~127一共256个对象，如果在自动装箱的时候给局部变量的int型值是在上面的范围之中，就会直接将之前创建好的对象的地址值赋给等号左边的局部变量，

2. 和new一个对象不同，如果new就会在堆内存开辟空间，new两次就开辟两段空间，两段空间地址值一定不一样，所以System.out.println(i1 == i2);的执行结果为false

 public boolean equals(Object obj) {
        if (obj instanceof Integer) {
            return value == ((Integer)obj).intValue();
        }
        return false;
 }

Integer类中的equals方法定义如上述代码所示，value是个成员变量，被final修饰，所以是个常量

private final int value;

参数为int型的构造方法如下面代码所示：

public Integer(int value) {
        this.value = value;
}

所以equals方法比较的是两个Integer类是对象的内容的大小，所以通过上面的讲解可以知道，在执行完System.out.println(i1.equals(i2));语句后，运行结果为true

3. 再来看一下第2条所提到的：如果new就会在堆内存开辟空间，new两次就开辟两段空间，两段空间地址值一定不一样，所以在执行完System.out.println(i3 == i4);语句后，肯定打印的是false，因为不在指向同一个对象了

4. 但是System.out.println(i3.equals(i4));执行结果依然为true，因为两个对象中所存储的内容的大小一样

System.out.println(i5 == i6);
System.out.println(i5.equals(i6));

在第一条中提到过，如果在自动装箱的时候给局部变量的int型值是在上面的范围之中，就会直接将之前创建好的对象的地址值赋给等号左边的局部变量，但是上述代码中在自动装箱时的int型值不在上述范围内，所以会重新new对象，既然会new，那么就不再指向同一个对象了，所以System.out.println(i5 == i6);执行结果为false；

因为内容一样，所以 System.out.println(i5.equals(i6));结果为true

6. 经过上述讲解可知最后两条语句执行结果都为true