基础类型对应的8个包装类

基础类型对应的8个包装类

8个包装类

Java中为8中基本数据类型有对应准备了8种包装类型。8种包装类属于引用数据类型，父类是Object

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)

8种包装类只需要学习Integer，其他和 Integer 同理

包装类的作用

因为8种基本数据类型不够用。所以sun公司有提供对应的8种包装类型

都属于引用数据类型

//有时候会有这种需求：调用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);
    }

//这种包装类作为测试  java已经提供了8种包装类型了 实际开发中不需要写
public class MyInt {
    private int value;

    public MyInt() {
    }

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

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

父类number的公共方法

8种包装类种有六个都是数字对应的包装类，他们的父类都是number，number中有这样的公共方法：

byte	byteValue()返回指定号码作为值 byte ，这可能涉及舍入或截断。
abstract double	doubleValue()返回指定数字的值为 double ，可能涉及四舍五入。
abstract float	floatValue()返回指定数字的值为 float ，可能涉及四舍五入。
abstract int	intValue()返回指定号码作为值 int ，这可能涉及舍入或截断。
abstract long	longValue()返回指定数字的值为 long ，可能涉及四舍五入或截断。
short	shortValue()返回指定号码作为值 short ，这可能涉及舍入或截断。

这些方法，所有的包装类的子类都有，这些方法都是负责拆箱的

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

        //将引用数据类型--（转换为）-->基本数据类型
        float v = integer.floatValue();
        System.out.println(v);//123.00

        //将引用数据类型--（转换为）-->基本数据类型（拆箱）
        int retValue = integer.intValue();
        System.out.println(retValue);//123

Integer的构造方法

Integer(int)

Integer(String)

double同理

		//将数字转换成Integer包装类型（int --> Integer）
        Integer x = new Integer(100);
        System.out.println(x);

        //将String类型的数字，转换成Integer包装类型（String --> Integer）
        Integer y = new Integer("123");
        System.out.println(y);

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

        //String浮点数 --> Double
        Double e = new Double("1.23");
        System.out.println(e);

通过访问包装类的常量，来获取最大值和最小值

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);

自动装箱与自动拆箱

在JDK1.5之后 支持自动装箱与自动拆箱了

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

自动拆箱：包装类自动转换为基本数据类型

有了自动拆箱之后 number类中的方法就用不着了

/*
在JDK1.5之后  支持自动装箱和自动拆箱了

 */
public class IntegerTest05 {
    public static void main(String[] args) {
        //自动装箱
        //x是包装类型
        //int类型--（自动转换）-->Integer
        Integer x = 100;
        System.out.println(x);

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

        //z是一个引用，z是一个变量，z还是保存了一个对象的内存地址。
        Integer z = 1000;//等同于 Integer z = new Integer(1000)
        // + 两边要求是基本数据类型，z是包装类，不属于基本数据类型。
        // 这里会进行自动拆箱，将z转换成基本数据类型
        System.out.println(z + 1);//自动拆箱机制


        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

        System.out.println(a.equals(b));//因为是对象  这里可以使用equals方法
    }
}

注意点&面试题

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

在Integer这个类加载的时候就初始化这个整数型常量池：256个对象

Integer a = 128;
        Integer b = 128;

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

        //x保存的内存地址和y变量中保存的内存地址是一样的
        Integer x = 127;
        Integer y = 127;
        System.out.println(x == y);//true

常用方法

1. （掌握）int intValue() 将 Integer的值作为 int 返回。

   //手动装箱
           Integer x = new Integer(1000);
   
           //手动拆箱
           int y = x.intValue();
           System.out.println(y);
   

2. （掌握）int intValue(String s) s必须是数字字符串

   Integer a = new Integer("123");
   //java.lang.NumberFormatException  数字格式异常 要求是数字型的字符串 
           int b = a.intValue();
           System.out.println(b);
   

3. （掌握）static int parseInt(String s, int radix) 将字符串参数解析为第二个参数指定的基数中的有符号整数 其他同理 parseFloat parseDouble等

   //网页上文本框中输入的233实际上是“233”字符串，后台数据库中要求存储233数字，此时java程序需要将“233”转换成233数字
   int i = Integer.parseInt("223");
           System.out.println(i);//223
   

4. （了解）static String toBinaryString(int i) 把一个数字转换为二进制字符串

   String s = Integer.toBinaryString(125);
           System.out.println(s);//1111101
   

5. （了解）static String toHexString(int i) 16进制

   String d = Integer.toHexString(125);
           System.out.println(d);//7d
   

   public String toString() {
           return getClass().getName() + "@" + Integer.toHexString(hashCode());
       }
   //这是Object类默认的toString方法 它在后面调用了Integer.toHexString方法 返回的地址就是一个十六进制的数字
   

6. （了解）static String toOctalString(int i) 8进制

   String s1 = Integer.toOctalString(125);
           System.out.println(s1);//175
   

7. （了解）static Integer valueOf(int i) int–>Integer

   static Integer valueOf(String s) String–>Integer

         	Integer i1 = Integer.valueOf(100);
           System.out.println(i1);
   
           Integer i2 = Integer.valueOf("100");
           System.out.println(i2);
   

各类型之间的转换

		//String --> int
        String s3 = "123";
        int x1 = Integer.parseInt(s3);
        System.out.println(s3+1);
        //int --> String
        String s1 = String.valueOf(123);
        //int --> Integer
        Integer x = 1;
        //Integer --> int
        int y = x;
        //String --> Integer
        Integer k = Integer.valueOf("256");
        //Integer --> String
        String s2 = String.valueOf(k);