Java包装类
包装类与基本数据类型的异同
基本数据类型
Java语言提供了八种基本类型:六种数字类型(四个整数型,两个浮点型),一种字符型,还有一种布尔型。
1.整数型:int、 short、 byte、 long、初始值为0
2.浮点型:float、 double、 初始值为0.0
3.字符型:char、 初始值为空,即 " " ,如果输出,在Console上是看不到效果的
4.布尔型:boolean、 初始值为false
基本类型 | 大小 | 最小值 | 最大值 |
---|---|---|---|
boolean | ----- | ----- | ----- |
char | 16bit | Unicode 0 | Unicode 2^16-1 |
byte | 8bit | -128 | +127 |
short | 16bit | -2^15 | +2^15-1 |
int | 32bit | -2^31 | +2^31-1 |
long | 64bit | -2^63 | +2^63-1 |
float | 32bit | IEEE754 | IEEE754 |
double | 64bit | IEEE754 | IEEE754 |
void |
注意:Java采用Unicode编码,2个字节表示一个字符。
包装类
Java中的包装类包括:Integer、Long、Short、Byte、Character、Double、Float、Boolean、BigInteger、BigDecimal。其中BigInteger、BigDecimal没有对应的基本类型,主要应用于高精度的运算。BigInteger支持任意精度的整数,BigDecimal支持任意精度带小数点的运算。
基本类型与包装类型的异同
- 在Java中,一切皆对象,但八大基本类型却不是对象。
- 声明方式的不同,基本类型无需通过new关键字来创建,而包装类型需要new关键字 。
- 存储方式及位置不同,基本类型是直接存储变量的值保存在栈中,能高效的存取。包装类型需要通过引用指向实例,具体的实例保存在堆中。
- 初始值的不同,包装类型的初始值为null。基本类型的初始值视具体类型而定,比如int类型的初始值为0,Boolean类型 的初始值为 false
- 使用的方式不同,比如与集合类型合作使用时只能使用包装类。
Java中所有的包装类都存放在java.long包中,用final修饰,不允许被继承,没有子类。
数值类型包装类继承自number,字符型和布尔型继承自object
基本数据类型和包装类的转换
装箱:基本数据类型转化成包装类
拆箱:包装类转化成基本数据类型
//装箱:基本数据类型转化成包装类
//1.自动装箱
int a = 5;
Integer b = a;
//2.手动装箱
Integer c = new Integer(a);
//测试
System.out.println("int类型变量a="+a);
System.out.println("Integer类型变量b="+b);
System.out.println("Integer类型变量c="+c);
输出结果
int类型变量a=5
Integer类型变量b=5
Integer类型变量c=5
Process finished with exit code 0
拆箱
int a = 5;
Integer b = a;
//拆箱:把包装类转换成基本数据类型
//1.自动拆箱
int d = b;
//2.手动拆箱
int e = b.intValue();
double f = b.doubleValue();
//测试
System.out.println("Integer对象b="+b);
System.out.println("自动拆箱后int变量d="+d);
System.out.println("手动拆箱后int变量e="+e);
System.out.println("手动拆箱后转换成double变量f="+f);
输出结果
Integer对象b=5
自动拆箱后int变量d=5
手动拆箱后int变量e=5
手动拆箱后转换成double变量f=5.0
Process finished with exit code 0
基本数据类型和字符串的转换
//基本数据类型转换为字符串
int a = 6;
String b = Integer.toString(a);
System.out.println("int类型转换成字符串b="+b);
System.out.println("==========================");
//字符串转换成基本数据类型
//1.包装类的parse
int c = Integer.parseInt(b);
//2.包装类的valueOf,先将字符串转换成包装类,再通过自动拆箱转换成基本类型
int d = Integer.valueOf(b);
System.out.println("String类型转换为int类型c="+c);
System.out.println("String类型转换为int类型d="+d);
int类型转换成字符串b=6
==========================
String类型转换为int类型c=6
String类型转换为int类型d=6
Process finished with exit code 0
=================================
{
Integer one = new Integer(100);
Integer two = new Integer(100);
//Object equals;
System.out.println("one==two的结果"+(one==two));//false内存空间不同
//System.out.println("one==two的结果"+(one.equals(two)));
Integer three = 100;// 自动装箱
System.out.println("three==100的结果"+(three==100));//true,自动拆箱,比较的两个整数
Integer four = 100;
System.out.println("three==four的结果"+(three==four));
Integer five = 200;
System.out.println("five==200的结果"+(five==200));
Integer six = 200;
System.out.println("five==six的结果"+(five==six));
one==two的结果false
three==100的结果true
three==four的结果true
five==200的结果true
five==six的结果false
Process finished with exit code 0
包装类及常用方法简介
JAVA 是一种面向对象语言,JAVA 中的类把方法与数据连接在一起,构成了自包含式的处理单元。但在 JAVA 中不能定义基本类型(primitive type)对象,为了能将基本类型视为对象进行处理,并能连接相关的方法,JAVA 为每个基本类型都提供了包装类。如 int 型数值的包装类 Integer,boolean 型数值的包装类 Boolean 等,这样便可以把这些基本类型转换为对象来处理了。下面将介绍 JAVA 中提供的各种包装类。
一、Integer
java.lang 包中的 Integer 类、Long 类和 Short 类,分别将基本类型 int、 long 和 short 封装成一个类。由于这些类都是 Number 的子类,区别就是封装不同的数据类型,其包含的方法基本相同,下面以 Integer 类为例介绍:
Integer 类在对象中包装了一个基本类型 int 的值。该类的对象包含一个 int 类型的字段。此外,该类提供了多个方法,能在 int 类型和 String 类型之间互相转换,同时还提供了处理 int 类型时非常有用的其他一些常量和方法。
1、 构造方法有两种:
a) 以 int 型变量作为参数创建 Integer 对象,实例代码如下:
Integer number=new Integer(7);
b) 以 String 型变量作为参数创建 Integer 对象,实例代码如下:
Integer number=new Integer(“7”);
2、 常用方法:
Integer 类的常用方法
方法 | 返回值 | 功能描述 |
---|---|---|
– | – | – |
byteValue() | byte | 以 byte 类型反回该 Integer 的值 |
compareTo(Integer another Integer) | int | 在数字上比较两个 Integer 对象。如果这两个值相等,则返回 0;如果调用对象的数值小于 anotherInteger 的数值,则返回负值;如果调用对象的数值大于anotherInteger 的数值,则返回正值 |
equals(Object IntegerObj) | boolean | 比较此对象与指定对象是否相等 |
intValue() | int | 以 int 型返回此 Integer 对象 |
shortValue() | short | 以 short 型返回此 Integer 对象 |
toString() | String | 返回一个表示该 Integer 值的 String 对象 |
valueOf(String str) | Integer | 返回保存指定的 String 值的 Integer 对象 |
parseInt(String str) | int | 返回包含在由 str 指定的字符串中的数字的等价整数值 |
、 常用的常量:
a) MAX_VALUE: 表示 int 型可取的最大值
b) MIN_VALUE: 表示 int 型可取的最小值
c) SIZE:表示以二进制补码形式表示 int 值的位数
d) TYPE: 表示基本类型 Class 实例
示例如:
int maxint = Integer.MAX_VALUE;
int minint = Integer.MIN_VALUE;
int intsize = Integer.SIZE;
System.out.println("int 类型可取的最大值"+maxint);
System.out.println("int 类型可取的最小值"+minint);
System.out.println("int 类型的二进制位数"+intsize);
输出结果为
int类型可取的最大值2147483647
int类型可取的最小值-2147483648
int类型的二进制位数32
二、Boolean
Boolean 类将基本类型为 boolean 的值包装在一个对象中。一个 Boolean 类型的对象只包含一个类型为 boolean 的字段。此外,此类还为 boolean 和 String 的相互转换提供了许多方法,并提供了处理 boolean 时非常有用的其他一些常量和方法。
1、 构造方法:
e) 创建一个表示 value 参数的 boolean 对象,实例如下:
Boolean b = new Boolean(true);
f) 以 String 变量作为参数,创建 boolean 对象。此时,如果传入的字符串不为 null,且忽略大小写后的内容等于”true”,则生成 Boolean 对象值为 true,反之为 false.
示例如:
Boolean b1 = new Boolean("ok");
System.out.println(b1);
Boolean b2=new Boolean("TRUE");
System.out.println(b2);
输出结果为:
false
true
2、 常用方法:
Boolean 类的常用方法
方法 | 返回值 | 功能描述 |
---|---|---|
booleanValue() | boolean | 将 Boolean 对象的值以对应的boolean 值返回 |
equals(Object obj) | boolean | 判断调用该方法的对象与 obj 是否相等,当且仅当参数不是 null,而且与调用该方法的对象一样都表示同一个 boolean 值的 Boolean 对象时,才返回 true |
parseBoolean(String s) | boolean | 将字符串参数解析为 boolean 值 |
toString() | String | 返回表示该 boolean 值的 String 对象 |
valueOf(String s) | boolean | 返回一个用指定的字符串表示值的boolean 值 |
其中 booleanValue()的功能是:将 booleanValue 对象的值以对应的 boolean 值返回。
示例如:
Boolean b1 = new Boolean("OK");
Boolean b2 = new Boolean(false);
System.out.println("b1:"+b1.booleanValue());
System.out.println("b2:"+b2.booleanValue());
结果:
b1:false
b2:false
3、 常用的常量:
a) TRUE:对应基值 true 的 Boolean 对象;
b) FALSR:对应基值 false 的 Boolean 对象;
c) TYPE:表示基本类型 Class 实例
三、Byte
Byte 类将基本类型为 byte 的值包装在一个对象中,一个 byte 类型的对象只包含一个类型为 byte 的对象。此外,该类还为 byte 和 String 之间相互转换提供方法,并提供了一些处理 byte 时非常有用的常量。
1、 构造方法
Byte 类提供了两种构造方法的重载形式来创建 BYTE 类对象:
a) Byte(byte value) 通过这种方法创建的 byte 对象,可表示指定的 byte
值。
例: byte mybyte=45;
Byte b = new Byte(mybyte);
b) Byte(String str) 通过这种方法创建的 byte 对象,可表示 String 参数指定的 byte 值
例:Byte mybyte = new Byte(“12”)
2、 常用方法
Byte类的常用方法
方法 | 返回值 | 功能描述 |
---|---|---|
byteValue() | byte | 以一个byte值返回Byte对象 |
compareTo(Byte anotherByte) | int | 在数字上比较两个Byte对象 |
doubleValue() | double | 以一个double值返回此Byte值 |
parseByte(String str) | byte | 将String型参数解析成等价的字节 (byte)形式 |
toString() | String | 返回此Byte的值的String对象 |
valueOf(String str) | Byte | 返回一个保持指定String所输出的值的 Byte对象 |
equals(Object obj) | boolean | 将此对象与指定对象比较,如果调用该方 法的对象与obj相等,则返回true,否 则返回false |
3、 常用的常量
a) MIN_VALUE: 最小值 b) MAX_VALUE: 最大值 c) SIZE: 二进制 d) TYPE: 表示基本类型byte的class实例
四、Character
Character类在对象中包装一个基本类型为char的值。一个Character对 象包含类型为char的单个字段。
1、 构造方法
Character类的构造方法的语法如下:
Character(char value)
2、 常用方法
Character类的常用方法
方法 | 返回值 | 功能描述 |
---|---|---|
charvalue() | char | 返回此Character对象的值 |
compareTo (CharacteranotherChara cter) | int | 根据数字比较两个Character 对象,若这两个对象相等则返 回0 |
equals(Object obj) | Boolean | 将调用该方法的对象与指定 的对象相比较 |
toUpperCase(char ch) | char | 将字符参数转换为大写 |
toString() | String | 返回一个表示指定char值的 String对象 |
charValue() | char | 返回此Character对象的值 |
isUpperCase(char ch) | boolean | 判断指定字符是否是大写字 符 |
IsLowerCase(char ch) | boolean | 判断指定字符是否是小写字 符 |
示例如:
Character mychar1=new Character('A');
Character mychar2=new Character('a');
System.out.println(mychar1+"是大写字母吗 "+Character.isUpperCase(mychar1));
System.out.println(mychar2+"是小写字母吗 "+Character.isLowerCase(mychar2));
结果如下:
A是大写字母吗true
B是小写字母吗true
五、Double
Double 和Float包装类是对double、float基本类型的封装,他们都 是Number类的子类,又都是对小数进行操作,所以常用基本方法相同, Double类在对象中包装一个基本类型为double的值,每个double类都包 含一个double类型的字段。
1、 构造方法
2、 Double类提供了两种构造方法来获得Double类对象
a) Double(double value): 基于double参数创建Double类对象;
b) Double(String str): 构造一个新分配的Double对象,表示用字符串 表示的Double类型的浮点值
3、 常用方法
Double类的常用方法
方法 | 返回值 | 功能描述 |
---|---|---|
byteValue() | byte | 以byte形式返回Double对象值(通 过强制转换) |
compareTo(Double d) | int | 对两个Double对象进行数值比较。 如果两个值相等,则返回0;如果调 用对象的数值小于d的数值,则返回 负值;如果调用对象的数值大于d的数值,则返回正值 |
equals(Obj) | boolean | 将此对象与指定的对象相比较 |
intValue() | int | 以int形式返回Double值 |
isNaN() | boolean | 如果此double值是非数字(NaN) 值,则返回true;否则返回false |
toString() | string | 返回此Double对象的字符串表示形 式 |
valueOf(String str) | double | 返回保存参数字符串str表示的 double值的Double对象 |
doubleValue() | double | 以double形式返回此Double对象 |
longValue() | long | 以long形式返回double的值(通过强化转换为long类型) |
六、Number
抽象类Number是父类,Number的子类必须提供将表示的数值转换 成byte、double/float/long/int/short的方法。Number类的方法被 Number的各子类所实现,常用方法如下:
Number类的方法
方法 | 返回值 | 功能描述 |
---|---|---|
byteValue() | byte | 以byte形式返回指定的数值 |
intValue() | int | 以int形式返回指定的数值 |
floatValue() | float | 以float形式返回指定的数值 |
shortValue() | short | 以short形式返回指定的数值 |
longValue() | long | 以long形式返回指定的数值 |
doubleValue() | double | 以double形式返回指定的数值 |