一、Java的基本类型
Java语言中提供了八种基本类型,包括六种数字类型(四个整数型,两个浮点型),一种字符类型,还有一种布尔型。
整数型,包括byte、short、int、long,默认初始值是0;
浮点型,包括float、double,默认初始值是0.0;
字符型,char型,默认值是'',注意跟“”的区别,''是字符的引号,“”是字符串的引号,两者不同。
布尔型,boolean,默认初始值是false。
注意:如果不初始化一个char类型的变量,将它输出在console的时候你看不到任何结果。Java中,字符型并不是用ASCII码来存储的,而是用16位的Unicode字符集来存储,它的范围就是字符集的范围,默认值是u000000。
二、包装类
包装类把基本类型转换为对象,每个基本类型在java.lang包中都有一个相应的包装类,包括有:
基本类型包装类型
byte
Byte
short
Short
int
Integer
long
Long
float
Float
double
Double
char
Character
boolean
Boolean
此外,在java.math包中还有两个用于数字计算的类型,分别是BigInteger、BigDecimal。它们无对应的基本类型,主要应用于高精度的运算,其中BigInteger 支持任意精度的整数运算,BigDecimal支持任意精度带小数点的运算,可以用于避免使用基本类型时产生的精度损失等问题。
三、包装类的用法
这里只讨论六种数字基本类型对应的包装类,因为它们是使用最频繁的,这些类中常用的方法可分为两类:一种是本类型与其它基本类型之间的转换,另一种是字符串与本类型和基本类型之间的转换。如下图,是Integer类中的一些常用方法:
其中的前五个,都是属于第一种,即与其它基本类型之间的转换。下面的三个则属于第二种,是字符串与本类型及基本类型之间的转换。
A、本类型与其它类型转换
示例如下:
1 Integer temp1 = new Integer(45);2 int temp2 = 45;3
4 byte t1 = temp1.byteValue(); //包装类的转换
5 byte t2 = (byte)temp2; //基本数据类型的强制类型转换
B、本类型和对应基本类型转换
JDK1.5引入了自动装箱和拆箱的机制,那么什么是装箱和拆箱呢?
装箱就是将基本类型转换成包装类,分为自动装箱和手动装箱。同样地,拆箱就是将包装类型转换成基本类型,也分为自动拆箱和手动拆箱。
示例如下:
1 int a1=4;2
3 //手动装箱
4 Integer aI1 = newInteger(a1);5 //自动装箱
6 Integer aI2 =a1;7
8 //手动拆箱
9 int ai1 =aI1.intValue();10 //自动拆箱
11 int ai2 = aI2;
C、字符串和基本类型转换
c1.基本类型转换成字符串类型
c1a. 包装类 的toString()方法
c1b. String 类的valueOf()方法
c1c. 空字符串加一个基本类型变量
1 //基本类型转换成字符串类型有三种方法
2 int b = 1;3 String b1 =Integer.toString(b);4 String b2 =String.valueOf(b);5 String b3 = b+"";6 System.out.println("b1: "+b1+"b2: "+b2+"b3: "+b3);
c2.字符串转换成基本类型
c2a. 包装类的parse***()静态方法
c2b. 包装类的valueOf()方法
//字符串转换成基本类型的方法有两种String b= "121";int c1 =Integer.parseInt(b);int c2 = Integer.valueOf(b);
四、基本类型和包装类的异同
4.1 在Java中,一切皆对象,但八大基本类型却不是对象。
4.2 声明方式的不同,基本类型无需通过new关键字来创建,而包装类型需new关键字。
4.3 存储方式及位置的不同,基本类型是直接存储变量的值保存在堆栈中,能高效的存取,包装类型需要通过引用指向实例,具体的实例保存在堆中。
4.4 初始值的不同,包装类型的初始值为null,基本类型的的初始值视具体的类型而定。
4.5 使用方式的不同,如与集合类合作使用时只能使用包装类型。
五、Integer与int数据的比较
在Java中,因为有自动装箱/拆箱操作,所以int与Integer类型在比较大小时基本是没有差别的。
利用一段程序验证如下:
public classTestInteger {public static voidmain(String[] args) {int t1 = 46;int t2 = 46;
Integer t3= 46;
Integer t4= new Integer(46);
Integer t5=t1;
Integer t6= newInteger(t2);
System.out.println("t1 == t2 " + (t1 ==t2));
System.out.println("t1 == t3 " + (t1 ==t3));
System.out.println("t1 == t4 " + (t1 ==t4));
System.out.println("t1 == t5 " + (t1 ==t5));
System.out.println("t1 == t6 " + (t1 ==t6));
System.out.println("t4 == t2 " + (t4 ==t2));
System.out.println("t5 == t2 " + (t5 ==t2));
System.out.println("t6 == t2 " + (t6 ==t2));
System.out.println("t4 == t3 " + (t4 ==t3));
System.out.println("t5 == t3 " + (t5 ==t3));
System.out.println("t6 == t3 " + (t6 ==t3));
System.out.println("t3 equals t4 " +(t3.equals(t4)));
System.out.println("t3 equals t5 " +(t3.equals(t5)));
System.out.println("t3 equals t6 " +(t3.equals(t6)));
System.out.println("t3 equals t4 " +(t3.equals(t4)));
System.out.println("t4 equals t5 " +(t4.equals(t5)));
System.out.println("t4 equals t6 " +(t4.equals(t6)));
System.out.println("t5 equals t6 " +(t5.equals(t6)));
}
}
上面的程序中,分别利用针对变量和具体数字的两种装箱方式定义了四个Integer类的变量,
在后续的测试代码中分别使用了==和equals两种方式进行比较,其输出结果为:
t1 == t2 true
t1 == t3 true
t1 == t4 true
t1 == t5 true
t1 == t6 true
t4 == t2 true
t5 == t2 true
t6 == t2 true
t4 == t3 false
t5 == t3 true
t6 == t3 false
t3 equals t4 true
t3 equals t5 true
t3 equals t6 true
t3 equals t4 true
t4 equals t5 true
t4 equals t6 true
t5 equals t6 true
使用equals方式的比较中,所有的结果都是true。Integer类中的equals方法具体是:
1 public booleanequals(Object obj) {2 if (obj instanceofInteger) {3 return value ==((Integer)obj).intValue();4 }5 return false;6 }
从代码可以看出,两个Integer类的equals方法最终比较的是,其各自所包装的intValue的值是否相等,因此,所有的输出结果都是true。
在使用==比较的时候,输出结果中有两个是false,都是在两个Integer类比较时产生的。因为当==比较的一个Integer类和一个int变量时,自动装箱/拆箱会对其进行处理,最终比较的是数值结果。当面对两个Integer类时,==所比较的是两个引用所指的是否为同一对象。而在上面的程序中,t4和t6都是通过new创建出的新对象,因此它们与前面的t3是完全不同的引用,所以结果是false。
值得注意的是t3和t5的比较结果,针对数值46和int变量t1的自动装箱结果指向的是同一个Integer对象,这说明在这段程序中,没有使用new来显式创建新对象时,虚拟机只会将引用指向已经存在的结果。