【Java】常用类.包装类

文章目录

• ​​常用类.包装类​​

• ​​一、包装类型​​
• ​​二、Integer 类​​
• ​​三、Integer 中的常用方法​​
• ​​四、三种类型的转换​​
• ​​五、自动装箱、自动拆箱（jdk1.5及以后）​​

常用类.包装类

一、包装类型

1.所谓包装就是将基本数据类型封装成对象 。好处在于可以在对象中定义更多的功能方法操作该数据。

2.常用的操作之一：用于基本数据类型与字符串之间的转换。

public class IntegerTest01 {

  public static void m1(Object o){
    System.out.println(o);
  }
  
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub

    //要求：m1方法可以接受Java中任何一种数据类型
    //m1方法要想接受byte类型的数据，可以将byte类型先包装成java.lang.Byte;再传递参数
        
    //基本数据类型
    byte b = 10;
    String s = "中国";
    
    //引用类型
    Byte b1 = new Byte(b);
    m1(b1); //10
    String s1 = new String(s);
    m1(s1); //中国  
  }
}

10

​​返回顶部​​

二、Integer 类

以java.lang.Integer 为例,其他数据类型基本一致

public class IntegerTest02 {   
      /**
       * @param nums
       * @param target
       * @return
       */    
        public static void main(String[] args) {
            
        //获取int类型的最大值、最小值
        System.out.println("int类型的最大值："+Integer.MAX_VALUE);
        System.out.println("int类型的最小值："+Integer.MIN_VALUE);
          //获取byte类型的最大值、最小值
        System.out.println("byte类型的最大值："+Byte.MAX_VALUE);
        System.out.println("byte类型的最小值："+Byte.MIN_VALUE);
        
        //创建int类型对象
        Integer i1 = new Integer(10);
        Integer i2 = new Integer("456");
        System.out.println(i1); //10
        System.out.println(i2); //456
        
        //以下代码可以编译，但是运行时出现异常
        Integer i3 = new Integer("abc");
        System.out.println(i3); //java.lang.NumberFormatException 数字格式化异常
        
    }
}

​​返回顶部​​

三、Integer 中的常用方法

public class IntegerTest03 {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub

      //1.int intValue()  将 Integer的值作为 int 。 
    //int --> Integer
    //基本数据类型 --> 引用数据类型
    Integer i1 = new Integer(10);
    
    //Integer --> int
    //引用数据类型 --> 基本数据类型
    int i2 =  i1.intValue();
    System.out.println(i2+1); //11
    
    //2.static int parseInt(String s)  String --> int
    //将字符串参数解析为带符号的十进制整数。
    int age = Integer.parseInt("15");
    System.out.println(age+5); //20
    
    //3.static double parseDouble(String s) 
    //返回一个新 double初始化为指定的代表的值 String ，如通过执行 valueOf类的方法 Double 。 
    double a = Double.parseDouble("3.1415926");
    System.out.println(a+1); //4.1415926
    
    /*4.static String toBinaryString(int i) 
    在基数2中返回整数参数的字符串表示形式为无符号整数。  
    static String toHexString(int i) 
    返回整数参数的字符串表示形式，作为16位中的无符号整数。  
    static String toOctalString(int i) 
    在基数8中返回整数参数的字符串表示形式为无符号整数。  
        */
    String s1 = Integer.toBinaryString(10);
    System.out.println(s1); //1010 二进制
    String s2 = Integer.toHexString(10);
    System.out.println(s2); //a 十六进制
    String s3 = Integer.toOctalString(10);
    System.out.println(s3); //12 八进制
    
    //5.static Integer valueOf(int i) 
    //返回一个 Integer指定的 int值的 Integer实例。
    Integer i3 = Integer.valueOf(10);
    System.out.println(i3); 10
    //static Integer valueOf(String s)   
    //返回一个 Integer对象，保存指定的值为 String 。  
    Integer i4 = Integer.valueOf("10");
    System.out.println(i4); 10
  }
}

​​返回顶部​​

四、三种类型的转换

public class IntegerTest06 {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub

    //1.int --> Integer
    Integer i1 = Integer.valueOf(10);
    System.out.println(i1); //10 Integer
    
    //2.Integer --> int
    int i2 = i1.intValue();
    System.out.println(i2); //10 int类型
    
    //3.String --> Integer
    Integer i3 = Integer.valueOf("10");
    System.out.println(i3); //10 Integer
    
    //4.Integer --> String
    String s1 = i1.toString();
    System.out.println(s1); //"10" String类型
    
    //5.String --> int
    int i5 = Integer.parseInt("10");
    System.out.println(i5); //10 int类型
    
    //6.int --> String
    String s2 = 10 + "";
    System.out.println(s2); //"10" String类型
  }
}

​​返回顶部​​

五、自动装箱、自动拆箱（jdk1.5及以后）

1.自动装箱：把基本类型转换为包装类类型

2.自动拆箱：把包装类类型转换为基本类型

注意：

• 1.​​自动拆箱​​和​​自动装箱​​只是​​程序编译阶段​​的一个概念，和程序运行无关。
• 2.主要目的是​​方便程序员的程序编码​​。

public class IntegerTest05 {

  public static void m1(Object o){
    System.out.println(o);
  }
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub
  
    //JDK5.0之前
    //int --> Integer
    Integer i1 = new Integer(10); //装箱
    //Integer --> int
    int i2 = i1.intValue(); //拆箱
    System.out.println(i2); //10
    
    //JDK5.0之后
    Integer i3 = 10; //自动装箱
    int i4 = i3;
    System.out.println(i4); //10
    
    m1(123); //123  自动装箱
  }
}

对于自动装箱与自动拆箱的一个易错点：

public class IntegerTest04 {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // TODO Auto-generated method stub

    Integer i1 = new Integer(10);
    Integer i2 = new Integer(10);
    //这里不会自动装箱
    System.out.println(i1==i2); //false i1与i2的内存地址不同
    System.out.println(i1.equals(i2)); //true Integer已经重写了toString方法
    
    //重点：
    Integer i3 = 128;
    Integer i4 = 128;
    //等同于：
    //Integer i3 = new Integer(128);
    //Integer i4 = new Integer(128);
    System.out.println(i3==i4); //false
    
    Integer i5 = 127;
    Integer i6 = 127;
    System.out.println(i5==i6); //true
    
    Integer i7 = -128;
    Integer i8 = -128;
    System.out.println(i7==i8); //true
    
    Integer i9 = -129;
    Integer i10 = -129;
    System.out.println(i9==i10); //false
    
    //如果数据在-128-127之间，java中引入了一个整型常量池，类似于字符串常量池
  }
}

以下是 java.lang.Integer中对于整型常量池(缓存区)的定义：

​​返回顶部​​