JAVA包装类

包装类的分类WrapperType.java

1.针对八种基本数据类型相应的引用类型一包装类

2.有了类的特点，就可以调用类中的方法

八种基本数据类型相应的包装类对应情况：如图

Boolean的继承关系图

Character的继承关系图

Byte Short Integer Long Float Double继承关系图 都是继承了Number类

包装类和基本数据的转换

演示：包装类和基本数据类型的相互转换，这里以int和Integer演示

1. jdk5前的手动装箱和拆箱方式，**装箱：**基本类型 --》包装类型，反之，拆箱
2. jdk5以后（包含jdk5）的自动装箱和拆箱方式
3. 自动装箱底层调用的是valueOf方法，比如Integer.valueOf()
4. 自动拆箱底层调用的是intValue方法，比如对象名.intValue()
5. 其它的包装类用法类似

package wrapper_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class Integer01 {
    public static void main(String[] args) {
        //jdk5以前是手动装箱和拆箱的
        //手动装箱
        int num1 = 88;
        //手动装箱有两种方式：一种是直接在new传入值，一种是调用valueOf(参数)
        //方式一：
        Integer integer = new Integer(num1);
        //方式二：
        Integer integer1 = Integer.valueOf(num1);
        //手动拆箱：需要调用intValue方法
        int i = integer.intValue();

        System.out.println("==========================");

        //jdk5以后（包含jdk5）:是自动装箱和自动拆箱
        //自动装箱：底层还是调用valueOf方法
        int num2 = 168;
        Integer integer2 = num2;
        //自动拆箱：底层还是调用intValue方法
        int i1 = integer2;
    }
}

**练习题目：**面试题

必须理解下面的代码：面试题

如下两个题目输出结果相同吗？各是多少
1.
Objext obj1 = true ? new Integer(1) : new Double(2.0);//三元运算符【是一个整体】
System.out.println(obj1);//输出是：1.0 【原因是new Double(2.0)会使精度提高】

2.
Object obj2;
if(true){
	obj2 = new Integer(1);
}else {
	obj2 = new Double(2.0);
}
System.out.println(obj2);//输出的结果是：1
原因是if-else是分开的不会使用精度提高

包装类型和String类型的相互转换

案例演示：以Integer和String转换为例，其它类似

package wrapper_;

/**
 * @author: 海康
 * @version: 1.0
 */
public class WrapperVsString {
    public static void main(String[] args) {
        //包装类（Integer）--》String
        Integer num1 = 100;//自动装箱
        //方式一：
        String str1 = num1 + "";
        //方式二：
        String str2 = num1.toString();
        //方式三：
        String str3 = String.valueOf(num1);


        //String --》包装类
        String number = "168";
        //方式一：调用parseInt方法
        int numb01 = Integer.parseInt(number);
        //方式二：构造器
        Integer numb02 = new Integer(number);
    }
}

Integer类和Character类的常用方法

Integer类和Character有些常用的方法

Integer类

字段
MIN_VALUE：返回最小值
MAX_VALUE：返回最大值

方法：
 public static int compare(int x, int y) {
        return (x < y) ? -1 : ((x == y) ? 0 : 1);
    }
    
  public int compareTo(Integer anotherInteger) {
        return compare(this.value, anotherInteger.value);
    }
    
  public static int parseInt(String s) throws NumberFormatException {
        return parseInt(s,10);
    }

Character类

方法：
  public static boolean isDigit(char ch) {
  //判断是不是数字
        return isDigit((int)ch);
    }
    
  public static boolean isLetter(char ch) {
  //判断是不是字母
        return isLetter((int)ch);
    }
    
    public static boolean isUpperCase(char ch) {
    //判断是不是大写
        return isUpperCase((int)ch);
    }
    
    public static boolean isLowerCase(char ch) {
    //判断是不是小写
        return isLowerCase((int)ch);
    }
    
    public static boolean isWhitespace(char ch) {
    //判断是不是空格
        return isWhitespace((int)ch);
    }
    
    public static char toUpperCase(char ch) {
    //转成大写
        return (char)toUpperCase((int)ch);
    }
    
    public static char toLowerCase(char ch) {
    //转成小写
        return (char)toLowerCase((int)ch);
    }

练习题目：面试题目必须掌握

看看下面代码，输出什么结果？为什么？
public void method1(){
	Integer i = new Integer(1);
	Integer j = new Integer(1);
	System.out.println(i==j);
	
	Integer m = 1;
	Integer n = 1;
	System.out.pintln(m==n);
	
	Integer x = 128;
	Integer y = 128;
	System.out.pintln(x==y);
}

valueOf源码：
public static Integer valueOf(int i) {
	//low：范围是：-128
	//high：范围是：127
    if (i >= IntegerCache.low && i <= IntegerCache.high)
        return IntegerCache.cache[i + (-IntegerCache.low)];
    return new Integer(i);
}

题目：

示例1：引用数据类型
Integer i1 = new Integer(127);
Integer i2 = new Integer(127);
System.out.println(i1==i2);//false

示例2：引用数据类型
Integer i3 = new Integer(128);
Integer i4 = new Integer(128);
System.out.println(i3==i4);//false

示例3：引用数据类型：底层调用了 Integer.valueOf();
Integer i5 = 127;
Integer i6 = 127;
System.out.println(i5==i6);//true

示例4：引用数据类型
Integer i7 = 128;
Integer i8 = 128;
System.out.println(i7==i8);//false

示例5：引用数据类型
Integer i9 = 127;
Integer i10 = new Integer(127);
System.out.println(i9==i10);//false

示例6：一个基本数据类型一个引用数据类型 == 号比较就是值
Integer i11 = 127;
int i12 = 127;
System.out.ptintln(i11==i12);//true

示例7：一个基本数据类型一个引用数据类型 == 号比较就是值
Integer i13 = 128;
int i14 = 128;
System.out.println(i13==14);//true

只要是基本数据类型，"=="号判断是值是否相等

只要是引用数据类型，"=="号判断是地址值是否相等

如果一个是基本数据类型，另一个是引用数据类型，则判断还是值是否相等