Java基础Integer包装类

1、包装类存在的意义

• java中为8种基本数据类型又对应准备了8种包装类型。8种包装类属于引用数据类型，父类是Object。
• 思考：为什么要再提供8种包装类呢？
  • 因为8种基本数据类型不够用。
  • 所以SUN又提供对应的8种包装类型。

示例代码：

public class IntegerTest01 {
    public static void main(String[] args) {

        // 有没有这种需求：调用doSome()方法的时候需要传一个数字进去。
        // 但是数字属于基本数据类型，而doSome()方法参数的类型是Object。
        // 可见doSome()方法无法接收基本数据类型的数字。那怎么办呢？可以传一个数字对应的包装类进去。
        //创建实体类对象
        // 把100这个数字经过构造方法包装成对象。
        MyInt myInt = new MyInt(100);
        // doSome()方法虽然不能直接传100，但是可以传一个100对应的包装类型。
        doSome(myInt);
    }

    public static void doSome(Object obj){
        System.out.println(obj);
        //System.out.println(obj.toString());
    }
}

运行结果：

2、8种包装类，装箱和拆箱

• 8种基本数据类型对应的包装类型名是什么？
  基本数据类型 包装类型
  byte java.lang.Byte（父类Number）
  short java.lang.Short（父类Number）
  int java.lang.Integer（父类Number）
  long java.lang.Long（父类Number）
  float java.lang.Float（父类Number）
  double java.lang.Double（父类Number）
  boolean java.lang.Boolean（父类Object）
  char java.lang.Character（父类Object）

• 以上八种包装类中，重点以java.lang.Integer为代表进行学习，其它的类型照葫芦画瓢就行。

• 八种包装类中其中6个都是数字对应的包装类，他们的父类都是Number，可以先研究一下Number中公共的方法：
  Number是一个抽象类，无法实例化对象。
  Number类中有这样的方法：

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

这些方法其实所有的数字包装类的子类都有，这些方法是负责拆箱的。

示例代码：

public class IntegerTest02 {
    public static void main(String[] args) {

        // 123这个基本数据类型，进行构造方法的包装达到了：基本数据类型向引用数据类型的转换。
        //基本数据类型==》引用数据类型(装箱)
        Integer i = new Integer(123);

        float f = i.floatValue();
        System.out.println(f);//123.0

        //引用数据类型==》基本数据类型（拆箱）
        int i1 = i.intValue();
        System.out.println(i1);//123


    }
}

3、Integer构造方法和Double构造方法

示例代码：

public class IntegerTest03 {
    public static void main(String[] args) {
        //将基本数据100转换成包装类（int===》Integer）
        Integer i = new Integer(100);
        System.out.println(i);//100
        
        //只能转换数字的字符串，如：“1”,"2342"等等，不能转换 “a” 等等其他类型。
        //将引用数据类型的“abc”转换为包装类型（String====》Integer）
        //Integer s = new Integer("abc");//报错
        Integer s = new Integer("123");
        System.out.println(s);//123

        //double->Double
        Double d = new Double(12.5);
        System.out.println(d);//12.5

        //String->Float
        Float f = new Float("123");
        System.out.println(f);//123
    }
}

4、Integer通过常量获取类型最大值最小值

示例代码：

public class IntegerTest04 {
    public static void main(String[] args) {
        // 通过访问包装类的常量，来获取最大值和最小值
        System.out.println("int的最大值是：" + Integer.MAX_VALUE);
        System.out.println("int的最小值是：" + Integer.MIN_VALUE);
        System.out.println("byte的最大值是：" + Byte.MAX_VALUE);
        System.out.println("byte的最小值是："+ Byte.MIN_VALUE);
    }
}

运行结果：

5、自动装箱和自动拆箱

在java5之后，引入了一种新特性，自动装箱和自动拆箱

• 自动装箱：基本数据类型自动转换成包装类。

• 自动拆箱：包装类自动转换成基本数据类型。

• 有了自动拆箱之后，Number类中的方法就用不着了！

• 自动装箱和自动拆箱的好处？

  方便编程。

示例代码：

public class IntegerTest05 {
    public static void main(String[] args) {
        // x是包装类型
        // 基本数据类型 --(自动转换)--> 包装类型：自动装箱
        Integer i = 100;
        System.out.println(i);//100

        // x是包装类型
        // y是基本数据类型
        // 包装类型 --(自动转换)--> 基本数据类型：自动拆箱
        int x = i;
        System.out.println(x);//100

        // z是一个引用，z是一个变量，z还是保存了一个对象的内存地址。
        Integer z = 100;//等同于Integer z = new Integer();
        //分析为什么这个没有报错呢？
        // +两边要求是基本数据类型的数字，z是包装类，不属于基本数据类型，这里会进行自动拆箱。将z转换成基本数据类型
        // 在java5之前你这样写肯定编译器报错。
        System.out.println(z + 1);//101

        Integer a = 1000;// Integer a = new Integer(1000); a是个引用，保存内存地址指向对象。
        Integer b = 1000;// Integer b = new Integer(1000); b是个引用，保存内存地址指向对象。
        // == 比较的是对象的内存地址，a和b两个引用中保存的对象内存地址不同。
        // == 这个运算符不会触发自动拆箱机制。（只有+ - * /等运算的时候才会。）
        System.out.println(a == b);//false
    }
}

6、Integer包装类高频面试题

示例代码：

public class IntegerTest06 {
    public static void main(String[] args) {

        Integer a = 128;
        Integer b = 128;
        System.out.println(a == b);//false

        /*
           java中为了提高程序的执行效率，将[-128到127]之间所有的包装对象提前创建好
           放到了一个方法区的“整数型常量池”当中了，目的是只要用这个区间的数据不需要
           在new了，直接从整数型常量池中取出来

           原理：x变量中保存的对象的内存地址和y变量中保存的对象的内存地址是一样的。
        */
        Integer x = 127;
        Integer y = 127;
        // == 永远判断的都是两个对象的内存地址是否相同
        System.out.println(x == y);//true
    }
}

内存分析图：

7、Integer常用方法

总结一下之前所学的经典异常？

• 空指针异常：NullPointerException
• 类型转换异常：ClassCastException
• 数组下标越界异常：ArrayIndexOutOfBoundsException
• 数字格式化异常：NumberFormatException

示例代码：

public class IntegerTest07 {

    public static void main(String[] args) {
        //手动装箱
        Integer i = new Integer(123);
        System.out.println(i);

        //手动拆箱
        int i1 = i.intValue();
        System.out.println(i1);

        //编译的时候没问题，一切符合java语法，运行时会不会出问题呢？
        //不是一个“数字”可以包装成Integer吗？不能。运行时出现异常
        //java.lang.NumberFormatException
        //Integer x = new Integer("中文");

        //重点方法
        //static int partInt(String s)
        //静态方法，传参String，返回int
        //网页上文本框中输入的100实际上是“100”字符串。后台数据库中要求存储100数字，此时java程序需要将“100”转换成100
        int reValue = Integer.parseInt("123");//String --> int
        //int reValue01 = Integer.partInt("中文");//NumberFormatException
        System.out.println(reValue + 10);//133

        double reValue2 = Double.parseDouble("3.14");
        System.out.println(reValue2 + 1);//4.140000000000001(精度问题)

        float reValue3 = Float.parseFloat("2.0");
        System.out.println(reValue3 + 1);//3.0

        //----------------------------以下内容作为了解，不需要掌握---------------------
        //static String toBinaryString(int i)
        //静态的：将十进制转换成二进制字符串
        String s = Integer.toBinaryString(3);
        System.out.println(s);//“11”二进制字符串

        //static String toHexString(int i)
        //十六进制：0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a
        String s1 = Integer.toHexString(16);
        System.out.println(s1);//"10"

        String s2 = Integer.toHexString(17);
        System.out.println(s2);//"11"

        //static String toOctalString(int i)
        //静态的：将十进制转换成八进制字符串
        String s3 = Integer.toOctalString(8);
        System.out.println(s3);//"10"

        System.out.println(new Object());//java.lang.Object@4554617c

    }
}