基本数据类型对象包装。

为了方便操作基本数据类型值，将其封装成了对象，在对象中定义了属性和行为丰富了该数据的操作。
用于描述该对象的类就成为基本数据类型对象包装类。

byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean

该包装对象主要用基本类型和字符串之间的转换。

基本类型---->字符串
1.使用包装类中的静态方法 xxx parseXxx("xxx类型的字符串")
int parseInt("intstring")
long parseLong("longstring")
boolean parseBoolean("booleanstring")
2.如果字符串被Integer进行对象的封装。
可使用另一个非静态的方法，intValue()
将一个Integer对象转成基本数据类型值

public class WrapperDemo {

    public static void main(String[] args) {

        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.toBinaryString(6));
        
        int num=4;
        Integer i=new Integer(5);
        
        int x=Integer.parseInt("123");
        System.out.println(x+1);
        
        Integer t=new Integer("123");
        System.out.println(t.intValue()+1);
        
    /*  
        整数具备不同的进制体现。
        
        十进制-->其他进制
            toBinaryString
            toOctalString
            toHexString
            
        其他进制-->十进制
            parseInt("string",radix)
        */  
        
//      十进制-->其他进制
        System.out.println(Integer.toBinaryString(60));
        System.out.println(Integer.toOctalString(60));
        System.out.println(Integer.toHexString(60));
        
        System.out.println(Integer.toString(60,16));
        
//      其他进制-->十进制
        System.out.println(Integer.parseInt("3c",16));
        
        Integer a=new Integer("89");
        Integer b=new Integer(300);
        
        System.out.println(a==b);
        
        System.out.println(a.equals(b));
        
        System.out.println(a.compareTo(b));
    }
}

自动装箱和自动拆箱

public class WrapperDemo_2 {

    public static void main(String[] args) {
        
        int num=4;
        num=num+5;
        
        Integer i=4;//i=new Integer(4);自动装箱，简化书写
        i=i+6;//i=new Integer(i/intValue()+6);//i.intValue()自动拆箱
        
//      show(55);
        
        Integer a=new Integer(128);
        Integer b=new Integer(128);
        
        System.out.println(a==b);
        System.out.println(a.equals(b));
        
        Integer x=127;
        Integer y=127;
        System.out.println(x==y);//jdk1.5以后，自动装箱，如果装箱的是一个字节，那么该数据会被共享不会重新开辟空间.适用范围：-127-127
        System.out.println(x.equals(y));

    }

    public static void show(Object a) {//Object a=new Integer(55)
        System.out.println("a="+a);     
    }
}

对一个字符串的数值进行从小到大的排序。

"20 78 9 -7 88 36 29"

思路：
1.用空格来对数值进行分割，用字符串对象的切割方法将大串切成多个小串
2.数值变成小字符串后，用包装类将其变成一个int数。

public class WrapperTest {
    
    private static final String space_separator=" ";

    public static void main(String[] args) {
        
        String numStr="20 78 9 -7 88 36 29";
        
        System.out.println(numStr);
        numStr=sortStringNumber(numStr);
        System.out.println(numStr);

    }

    public static String sortStringNumber(String numStr) {

//      1.将字符串变成字符串数组
        String[] str_arr=stringToArray(numStr);
        
//      2.将字符串数组变成int
        int[] num_arr=toIntArray(str_arr);
        
//      3.对int数组排序
        mySortArray(num_arr);
        
//      4.将排序后的int数组变成字符串
        String temp=arrayToString(num_arr);
        
        return temp;
    }

    public static String arrayToString(int[] num_arr) {
        StringBuilder sb=new StringBuilder();
        for(int x=0;x<num_arr.length;x++){
            if(x!=num_arr.length-1)
                sb.append(num_arr[x]+space_separator);
            else
                sb.append(num_arr[x]);
        }
        return sb.toString();
    }

    public static void mySortArray(int[] num_arr) {
        Arrays.sort(num_arr);
        
    }

    public static int[] toIntArray(String[] str_arr) {
        
        int[] arr=new int[str_arr.length];
        
        for(int i=0;i<arr.length;i++){
            arr[i]=Integer.parseInt(str_arr[i]);
        }
        return arr;
    }

    public static String[] stringToArray(String numStr) {
        
        String[] str_arr=numStr.split(space_separator);
        
        return str_arr;
    }
}