JAVA 包装类：教你如何理解JDK1.5新特性（自动装拆箱）String & int的相互转换和进制转换【内含面试题】

基本数据类型的包装类

相较于基本数据类型，他们的包装类可以使用相关的成员变量和成员方法，更易于使用

八大基本数据类型：byte short int long float double char boolean

对应的包装类：Byte Short Integer Long Float Double Character Boolean

1.构造方法

• public Integer(int value)
• public Integer(String s)
• 构造方法的参数输入必须是正数类型的

2.静态字段

	说明
static int MAX_VALUE	值为 231－1 的常量，它表示 int 类型能够表示的最大值
static int MIN_VALUE	值为 －231 的常量，它表示 int 类型能够表示的最小值
static int SIZE	用来以二进制补码形式表示 int 值的比特位数
static Class TYPE	表示基本类型 int 的 Class 实例，任何的数据类型都有一个属性,class属性

3.成员方法

	说明
public int intValue()	拆箱，将Integer转化为整型
public static int parseInt(String s)	将字符串转换为int类型
public static String toString(int i)	将整型转换为字符串
public static Integer valueOf(int i)	将整型装换为Integer类型
public static Integer valueOf(String s)	将字符串转换为Integer类型

4.String & int 相互转换

		// int -> String
		int i = 100;
		//int类型+String类型自动转换为字符串类型
		String s1 = i + "";
		//Xxx.valueOf都返回该该类型(***********)
		String s2 = String.valueOf(i);

		//int -> Integer -> String
		String s3 = Integer.valueOf(i).toString()
        //Integer构造方法 —> String
        String s4 = new Integer(i).toString();

		//String -> int
		//String s = "100";
		int i1 = new Integer(s).intValue();
		int i2 = Integer.valueOf(s).intValue();
		// (*****************)
		int i3 = Integer.parseInt(s);

5.自动拆装箱

自动拆装箱是JDK1.5之后引入的新特性

• 手动装箱依赖 Integer.valueOf

• 手动拆箱依赖 intValue

• 自动装箱: 编译器自动将基本数据类型转换成对应的包装类类型

• 自动拆箱: 编译器自动将包装类类型转换成对应的基本数据类型

• 注意: 以后包装类类型完全可以当做基本数据类型来使用

        public class IntegerDemo04 {
            public static void main(String[] args) {
                int i = 100;
                Student s = new Student();
                // s = i;
                // s += i;

                Integer ii = 200; // Integer ii = Integer.valueOf(200)
                int i2 = ii--; // int i2 = ii.intValue --
                if (ii >= 200) { // ii.intValue >= 200
                    System.out.println("haha");
                }

                ii += 30; // ii = ii + 30;
                // ii = Integer.valueOf(ii.intValue + 30);
            }
        }

        class Student {
            private String name;
            private Integer age;
        }

        //报错，，因为转化是null会空指针异常		
                Integer iii = null;
                if (iii != null) {//iii.intValue会报错
                    if (iii >= 0) {
                        System.out.println("true");
                    } else {
                        System.out.println("false");
                    }
                }

6.面试题

• Integer ii = new Integer(100);和public static Integer valueOf(int i)的区别?

  		//观察valueOf的源码
  	 							100
  		public static Integer valueOf(int i) {
  			if (i >= IntegerCache.low && i <= IntegerCache.high)
  			return IntegerCache.cache[i + (-IntegerCache.low)];
  			return new Integer(i);
  		}
  		//IntegerCache类就是将 -128,127之间的数据先初始化到cache数组中
  

          public class IntegerDemo05 {
              public static void main(String[] args) {
                  Integer i01 = Intege.valueOf(59);
                  int i02 = 59;
                  Integer i03 = Integer.valueOf(59);
                  Integer i04 = new Integer(59);
  
                  //i01引用类型和i02基本年数据类型，比较值，所以true
                  System.out.println("i01 == i02:" + (i01 == i02)); // true
                  //引用类型比较地址，在-128，127之间，不用new，所以相等
                  System.out.println("i01 == i03:" + (i01 == i03)); // true
                  //引用类型比较地址，i04是new出来的，地址和i03不一样
                  System.out.println("i03 == i04:" + (i03 == i04)); // false
                  //基本类型比引用类型，所以new影响的是地址，和值无关，
                  System.out.println("i02 == i04:" + (i02 == i04)); // true
  
                  Integer i01 = 130; // Integer i01 = Intege.valueOf(130);
                  int i02 = 130;
                  Integer i03 = Integer.valueOf(130);
                  Integer i04 = new Integer(130);
                  
                  System.out.println("i01 == i02:" + (i01 == i02)); // true
                //引用类型之间，比较地址，因为130不在-128，127之间，
                  //所以地址都是new的，不相等
                  System.out.println("i01 == i03:" + (i01 == i03)); // false
                  System.out.println("i03 == i04:" + (i03 == i04)); // false
                  System.out.println("i02 == i04:" + (i02 == i04)); // true
  
              }
          }
  

7.其他包装类

所有的包装类都有这么一个规律

• 1.都可以当做基本数据类型来使用
• 2.XXX.valueOf都可以获取该包装类对象
• 3.parseXXXX 可以将任意字符串类型转换成基本类型
• 4.xxxValue 可以将任意包装类类型转换成基本类型
• 5**.Byte Short Integer Long** 都是Number类的子类
• 它们都有如下方法

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

基本数据类型对应的包装类类型都可以实现类型转换

•  	​	Character这个包装类有很多字符相关的工具方法
  

8.进制转换

计算机只能够表示到36进制

• 十进制到其他进制
  • public static String toBinaryString(int i)
  • public static String toOctalString(int i)
  • public static String toHexString(int i)
  • public static String toString(int i,int radix)
• 其他进制到十进制
  • public static int parseInt(String s,int radix)

	// X进制到Y进制
	public static String convertRadix(String num, int xRadix, int yRadix) {
		// 将xRadix对应的num转换成十进制
		// int i = Integer.parseInt(num, xRadix);
		// 将十进制转换成其他yRadix进制
		// String result = Integer.toString(Integer.parseInt(num, xRadix), yRadix);
		return Integer.toString(Integer.parseInt(num, xRadix), yRadix);
	}

加粗样式