Java八大基本类型详解与包装类

Java是面向对象的编程语言，但它也包含了8种基本数据类型。这8种数据类型不支持面向对象的编程机制，基本数据类型的数据也不具备“对象”的特性：没有成员变量、方法可以被调用。这8种数据类型带来了一定的方便性，例如可以进行简单、有效的常规数据处理。但在某些时候，基本数据类型会有一些制约，例如所有引用类型变量都继承了Object类，都可以当成Object类型变量使用。但基本数据类型的变量就不可以。为了解决8种基本数据类型的变量不能当成Object类型变量使用的问题，Java提供了包装类的概念，为8种基本数据类型分别定义了相应的引用类型，并称之为基本数据的包装类。

一：八大基本类型

1：

除了int和char有点例外之外，其他基本数据类型对应的包装类都是将其首字母大写即可。

在JDK1.5以前，把基本数据类型变量变成包装类需要通过对应包装类的构造器来实现。

2：字符串类型的值转换为基本类型的值

 1): 利用包装类提供的parseXxx(String s)静态方法（除了Character之外所有包装类都提供了该方法）。

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

String str = "56";

      intnumber =Integer.parseInt(str);

      System.out.println(str);   

   }输出：56；

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      String str = "3.6";

      //特定字符串转小数。

      Float number =Float.parseFloat(str);

      System.out.println(str);   

   }

}输出：3.6.

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      inti= 101;

      //数字转字符

      String str=String.valueOf(i);

      System.out.println(str);   

   }

}输出：101

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      //把一个boolean变量转换成String变量

        String boolStr = String.valueOf(true);

        System.out.println(boolStr);

   }

}输出：true.

3):最简单的

将基本类型变量和“”进行了连接运算，系统会自动把基本类型变量转换成字符串。

代码：

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      String str = 5+"";

        System.out.println(str); 

   }

}输出：5.

二：包装类

   1):装箱

Integer i =Integer.valueOf(5);这就是Java的自动装箱。可以简化为Integer i = 5;

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

       intx = 30 ;        // 基本数据类型 

       Integer h = new Integer(30) ;

       Integer i = new Integer(x) ;    // 装箱：将基本数据类型变为包装类 

       Integer i1 = x;//自动装箱，系统给提供

        inttemp = i.intValue() ;// 拆箱：将一个包装类变为基本数据类型 

        inttemp1 =h;

       System.out.println("基本数据类型"+x);

       System.out.println("手动装箱"+i);

       System.out.println("自动装箱"+i1);

       System.out.println("手动拆箱"+temp);

       System.out.println("自动拆箱"+temp1);

   }

}

基本数据类型30

手动装箱30

自动装箱30      手动拆箱30      自动拆箱30

2)缓存区

   1:int型

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      Integer number1 =30;

      Integer number2 =30;

      Integer number4 =128;

      Integer number3 =128;

      System.out.println(number1 == number2);//true

      System.out.println(number3 == number4);//fase

   }

}

系统把一个-128~127之间的整数自动装箱成Integer实例，并放入了一个名为cache的数组中缓存起来。如果以后把一个-128~127之间的整数自动装箱成一个Integer实例时，实例实际直接指向对应的数组元素，因此-128~127之间的同一个整数自动装箱成Integer实例时，永远是引用cache数组的同一个数组元素，所以它们全部都相等；但每次把一个不再-128~127范围内的整数自动装箱成Integer实例时，系统总是创建一个Integer实例，所以出现程序中的运行结果。

   2：double与float型

import java.lang.*;

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      Double number1 =30.3;

      Double number2 =30.3;

      Double number4 =128.8;

      Double number3 =128.8;

      System.out.println(number1 == number2);//false

      System.out.println(number3 == number4);//false

   }

}

在某个范围内的整型数值的个数是有限的，而浮点数却不是。

注意，Integer、Short、Byte、Character、Long这几个类的valueOf方法的实现是类似的。Double、Float的valueOf方法的实现是类似的。

         3:Boolean型

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      Boolean i1 = false; 

       Boolean i2 = false; 

       Boolean i3 = true; 

        Boolean i4 = true;            

        System.out.println(i1==i2); //true

        System.out.println(i3==i4);  //true

   }

}

这个我也不懂………………..

   4:例题

publicclass Wrapper {

   publicstaticvoid main(String[] args) {

      Integer a = 1; 

        Integer b = 2; 

        Integer c = 3; 

        Integer d = 3; 

        Integer e = 321; 

        Integer f = 321; 

        Long g = 3L; 

        Long h = 2L;            

        System.out.println(c==d); 

        System.out.println(e==f); 

        System.out.println(c==(a+b)); 

        System.out.println(c.equals(a+b)); 

        System.out.println(g==(a+b)); 

        System.out.println(g.equals(a+b)); 

        System.out.println(g.equals(a+h)); 

   }

}

true

false

true

true

true

false

true

这里面需要注意的是：当"=="运算符的两个操作数都是包装器类型的引用，则是比较指向的是否是同一个对象，而如果其中有一个操作数是表达式（即包含算术运算）则比较的是数值（即会触发自动拆箱的过程）。另外，对于包装器类型，equals方法并不会进行类型转换而是指它输出的内容是否相同。明白了这2点之后，上面的输出结果便一目了然：

第一个和第二个输出结果没有什么疑问。第三句由于  a+b包含了算术运算，因此会触发自动拆箱过程（会调用intValue方法），因此它们比较的是数值是否相等。而对于c.equals(a+b)会先触发自动拆箱过程，再触发自动装箱过程，也就是说a+b，会先各自调用intValue方法，得到了加法运算后的数值之后，便调用Integer.valueOf方法，再进行equals比较。同理对于后面的也是这样，不过要注意倒数第二个和最后一个输出的结果（如果数值是int类型的，装箱过程调用的是Integer.valueOf；如果是long类型的，装箱调用的Long.valueOf方法）。