Java SE-基本数据类型对应包装类

包装类 

Java是面向对象的编程语言，包装类的出现更好的体现这一思想。 

其次，包装类作为类是有属性有方法的，功能比基本数据类型要强大。

【八种基本数据类型的包装类】

　　byte ——Byte

　　short ——Short

　　int ——Integer

　　long——Long

　　float——Float

　　double——Double 

　　char——Character

　　boolean——Boolean

装箱与拆箱

装箱是指由基本数据类型向对应的包装类型转换。例如，int包装成Integer类的对象。 
拆箱是指有包装类转换成基本数据类型。例如，把Integer类的对象简化成int。

 

【基本数据类型变成对象包装类的好处】

　　可以将基本数据和字符串之间进行互相的转换。

　　如：int类型的取值范围是多少？ 

       这就应该去查  Integer —— Integer.MAX_VALUE ； 

　　基本数据类型包装类的主要作用： 进行基本数据类型和字符串之间的转换                                                                             

 

【基本类型数据转为字符串的三种方式】

1.  基本数据类型对象包装类中的方法 static String toString(基本类型);

2.  String类中的方法： static String valueOf(基本类型)

3.  基本类型数据 +“ ”；

 

【重点要掌握的就是：】

　　字符串---->基本类型数据。

　　返回值类型——>基本类型 ；参数——>字符串。

　　基本数据类型  变量名 = 基本数据类型包装类.parseXxx(XxxString)；

 

　　Long  l = Long.parseLong("4546545646546");
　　System.out.println(Integer.parseInt("23") + 1);

　　在八个基本类型对象包装类中只有一个对象没有parse方法，就是Character.

 

【类型转换错误】

　　NumberFormatException——数字格式异常——我碰到了，因为我多加了一个空格。

 

【Integer中要掌握的方法】涉及到一个进制转换的问题。

十进制-->其他进制。

二进制：static String toBinaryString(int);

16进制：static String toHexString(int);

八进制：static String toOctalString(int);

其他进制——>转成十进制；

Integer.toString(6 , 2); 将6转换为二进制。
parseInt(intString , radix);

System.out.println(Integer.parseInt("110") , 2);

 

【基本数据类型值  和 基本类型数据对象之间的转换】

使用构造函数——Integer（）；

即可以接受基本数值，也可以接收基本数值的字符串形式。

可以使用基本类型对象中的方法。 static Integer valueOf(int);

 

【基本类型的对象和基本数据类型数值】

   int intValue();

如：

    Integer i = new Integer(34);

    int num = i.intValue( );

    System.out.println(num);

 

【如果两数被封装成了对象该如何比较呢？】

基本数据类型的比较——用比较运算符； 引用数据类型使用compareTo进行比较。

　　int  compareTo( Integer anotherInteger ) 在数字上比较两个Integer对象。

　　在数值上比较两个Integer对象。以0 正数 负数 比较两个数的大小。

Integer a = new Integer(7);

Integer b = new Integer(5);
System.out.println(a.compareTo(b));

【重点】

对象想要进行比较，必须通过方法来完成，这个方法就是compareTo。
而很多对象都可以进行比较。所以这个方法定义在Comparable接口中。

想要对象具备比较功能，只要实现Comparable接口。

 

【基本数据类型对象包装类JDk1.5以后的新特性】——【自动拆箱，装箱】简化书写。

Integer i = new Integer(5);

基本数据类型对象包装类，对象创建的简化写法Integer i = 5;

1. Integer i = 5;(其实在内存中也是通过 new Integer(5)这种方式创建的！)

这种方式成为——自动装箱，Integer.valueOf(5)自动完成了对象创建的动作。

2. 在进行 i = i + 5，运算时——

= 右边的i 会先转成基本数据值（自动拆箱）i.intValue()，其实质为：

i = i.intValue() + 5 ；然后再和5进行加法运算。

= 右边运算完的结果，再次被自动装箱变成Integer对象赋给i.

一旦简化就有弊端：多具备一个值null. 使用自动装箱拆箱时，要进行null的健壮性判断。

【实例】

Integer x = null;

x = x.intValue() + 4;    x为null 不能调用方法，此时会发生：NullPointerException异常。

Boolean b = true; boolean b = true;的区别

答：前者：类类型变量指向一个对象，true为一个对象；

        后者：true为基本类型变量。

在JdK1.5的新特性自动装箱中，如果数值在byte类型范围内（-128 ~ 127）。如果该对象数值重复出现

多个引用其实是指向同一个Integer对象，节省空间！但是超出了byte范围，都会生产新的Integer对象。

Integer m = 127;

Integer n = 127;

System.out.println( m == n); //true

System.out.println(m.equals(n));  //true

Object x = 5；Object x 接受到了一个Integer对象,自动装箱。

然而 Object不可以接受基本数据类型。

 

【基本类型优于包装类型，注意合理使用包装类型】

　　说明：Java有两种类型，基本类型（Primitive type）和引用类型（Reference type）。基本类型如boolean,int, double，引用类型如String,List。每一种基本类型都有其对应的包装类型（Wrapper classes），如对应int的是Integer。

　　很多情况下基本类型优于装箱基本类型，因为：

　　1、在JDK 1.5以及之后的版本中增加了自动装箱和拆箱的特性。但是，不恰当的并行使用基本类型和包装类型，可能带来大量隐含的装箱和拆箱的操作。如下面的for语句中，由于循环变量是基本类型，而sum是包装类型，会导致频繁的自动装箱和拆箱操作，导致性能下降。

Long sum = 0L; 
for (long i=0; i<Integer.MAX_VALUE; i++){ 
　　sum += i; 
} 
System.out.println(sum);

　　2、对于包装类型，使用“==”比较可能无法得到预期的结果。如：new Integer(42) ==new Integer(42) 将返回false。应该使用equals方法做装箱类型的比较。

 　　使用包装类型合理的场景有：

1、作为集合中的元素、键和值

2、泛型，必须使用包装类型，如List<Integer>

3、进行反射的方法调用时

【面试题】——"34 9 -7 67 25"要求对这个字符串中的数值进行从小到大的排序，生成一个数值有序的字符串。

【思路】

1. 把其中的数拿出来，——对字符串进行切割。

2. 对数进行排序

3. 再追加成字符串。

步骤：

　　1.字符串>>>字符串数组（split）

       2.定义一个int数组，将字符串数组>>>int数组（Integer.parseInt(））

       3.对int数组排序；

       4. 将int数组转成字符串数组。

【代码】

package testjava;

import java.util.Arrays;

public class WrapperTest {

    private static final String SPACE = " ";

    /**
     * @param args
     */
    public static void main(String[] args) {

        /*
         * 综合练习： "34 9 -7 12 67 25"要求对这个字符串中的数值进行从小到大的排序， 然后生成一个数值有序的字符串。
         * 
         * 思路： 1，看到排序，就想要到了数组 2，那数组中的元素怎么获取呢？数值都在字符串中。 3，先从字符串中获取到这些具体的数值。怎么获取呢？
         * 4，发现这个字符串居然有规律。数值之间都是由空格隔开的。 可以对字符串进行切割。
         * 5，将获取的数据存储到数组中并排序，在将数组转成字符就可以了。哦了。
         * 
         * 
         * 步骤： 1，将字符串切割成字符串数组。split。 2，定义一个int数组将字符串数组中的元素转成整数存储到int数组中。
         * 3，对int数组排序。 4，将int数组排序后转成一个字符串。
         */

        String str = "34 9 -7 12 67 25";

        str = sortStringNumber(str);
        System.out.println(str);
    }

    public static String sortStringNumber(String str) {

        // 1，将字符串中的数值通过指定的规则进行切割获取字符串数组。
        String[] str_nums = toStringArray(str);

        // 2，将字符串数组转成int数组。
        int[] nums = toIntArray(str_nums);

        // 3，对int数组排序;
        sortIntArray(nums);

        // 4，将int数组变成字符串。
        return arrayToString(nums);
    }

    /*
     * 将int数组变成字符串。
     */
    private static String arrayToString(int[] nums) {
        // 1，创建字符串缓冲区。
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < nums.length; i++) {
            if (i != nums.length - 1)
                sb.append(nums[i] + SPACE);
            else
                sb.append(nums[i]);
        }

        return sb.toString();
    }

    /*
     * 对int数组排序。
     */
    private static void sortIntArray(int[] nums) {
        Arrays.sort(nums);
    }

    /*
     * 将字符串数组转成int数组。
     */
    private static int[] toIntArray(String[] str_nums) {
        // 1,先定义一个int数组。
        int[] arr = new int[str_nums.length];

        // 2,对字符串数组进行遍历。
        for (int i = 0; i < str_nums.length; i++) {
            // 将数组格式的字符串转成整数。存储到arr数组中。
            arr[i] = Integer.parseInt(str_nums[i]);
        }

        return arr;
    }

    /*
     * 将字符串转成字符串数组。
     */
    private static String[] toStringArray(String str) {

        return str.split(SPACE);
    }

}