简介
在Java当中不可以定义基本类型对象,但是为了将基本类型视为对象处理,并且连接相关方法,Java为每个基本类型提供了包装类,比如int类型数值的包装类为Integer,boolean型数值的包装类为Boolean。通过这样的方式,便可以把基本类型转换成对象来处理。
包装类,装箱和拆箱
Java是一门面向对象的语言,在Java的设计种提倡一种思想,以切皆对象。但是从数据类型划分种,Java的数据类型分为基本数据类型和引用数据类型,但是基本数据类型不能称作为对象,所以Java通过为基本数据类型设计对应的包装类,来获取基本数据类型的对象。
包装类
如下:
基本数据类型 | 包装类 |
---|---|
byte | Byte |
short | Short |
int | Integer |
long | Long |
char | Character |
float | Float |
double | Double |
boolean | Boolean |
装箱和拆箱
- 装箱:基本数据类型转换为包装类的过程叫做装箱
- 拆箱:包装类转换为基本数据类型的过程叫做拆箱
注意:
在Java1.5之后可以自动装箱和拆箱
代码演示:
public class Demo01 {
public static void main(String[] args) {
int m = 500;
Integer M = m; // 自动装箱
int m1 = M; // 自动拆箱
System.out.println("m1 = " + m1);
Integer N = 500;
System.out.println(M == N); // 比较的是M和N的内存地址 结果为false
System.out.println(M.equals(N)); // 比较的是M和N的内容 结果为true
}
}
运行结果如下:
m1 = 500
false
true
包装类用法
1.int和Integer的相互转换
public class Demo02 {
public static void main(String[] args) {
int m = 500;
Integer obj = new Integer(m); // 手动装箱
int n = obj.intValue(); // 手动拆箱
System.out.println(m == n);
Integer obj_01 = 500;
System.out.println(obj.equals(obj_01));
}
}
运行结果:
true
true
2.将字符串转换为数值类型
将字符串转换成数值类型,前提是字符串必须由数字构成。
在Integer和Float类当中有如下方法可以实现:
- Integer类(String转int型)
-
int parseInt(String s);
-
- Float类(String转float型)
-
float parseFloat(String s);
-
代码演示:
public class Demo03 {
public static void main(String[] args) {
String str1 = "123456";
String str2 = "123456.00";
int num1 = Integer.parseInt(str1);
float num2 = Float.parseFloat(str2);
System.out.println("str1:" + num1);
System.out.println("str2:" + num2);
}
}
运行结果:
str1:123456
str2:123456.0
3.将整数转换为字符串
Integer类拥有一个toString()方法,可以将整数转换为字符串
public class Demo04 {
public static void main(String[] args) {
int num1 = 100;
String str1 = Integer.toString(num1);
System.out.println(str1); // 100
}
}
Object类(爹类)
Object类是所有类的父类。也就是说,所有的类都默认继承Object类,那么就符合多态,所有类型的对象都可以赋值给Object类型的变量。
Object类当中的产常用方法如下表
方法 | 作用 |
---|---|
Object clone() | 创建与该对象的类相同的新对象 |
boolean equals(Object) | 比较两对象是否相等(注意与==区别,equals方法比较的是俩对象的内容,==比较的是内存地址) |
Class getClass() | 返回一个对象运行时的实例类 |
int hashCode() | 返回该对象的散列码值 |
String toString() | 返回该对象的字符串表示 |
void notify() | 激活等待在该对象的监视器上的一个线程 |
void notifyAll() | 激活等待在该对象的监视器上的全部线程 |
void wait() | 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前,导致当前线程等待 |
toString()方法
toString()方法返回该对象的字符串。Object 类的 toString() 方法返回“运行时类名@十六进制哈希码”格式的字符串。
注意:当输出对象的时候,一定会调用Object类的toString()方法打印内容。所以说通过toString方法可以获取对象的信息。
如果在子类当中重写 toString()方法,那么输出对象时则会调用子类被重写的方法 。
代码演示:
public class Demo05 {
String name;
int age;
public Demo05(String name,int age) {
this.name = name;
this.age = age;
}
public String toString() {
return "姓名:" + this.name + "\n年龄:" + this.age;
}
public static void main(String[] args) {
Demo05 person = new Demo05("shuyv",20);
System.out.println("person对象信息" + person);
}
}
执行结果如下
person对象信息姓名:shuyv
年龄:20
所以说,重写toString方法也完全满足继承机制。
equals()方法
- equals()方法是用来比较俩个对象的内容是否相同,通常字符串的比较只关注内容。
- ==连等号运算符是比较l俩个引用变量是否指向同一个实例,比较的是内存地址。
使用格式:
boolean result = obj.equals(Object o);
其中,obj 表示要进行比较的一个对象,o 表示另一个对象。
getClass()方法
getClass()方法返回对象所属的那个类,返回一个Class对象。通过Class对象我们可以获取到该类的信息,包括类名、父类、已经它所实现的接口名等等。
代码演示如何获取类信息:
public class Demo06 {
public static void printClassInfo(Object object) {
// 获取类名
System.out.println("类名:" + object.getClass().getName());
// 获取父类名
System.out.println("父类:" + object.getClass().getSuperclass().getName());
// 获取实现的接口
System.out.println("实现的接口如下:");
for (int i = 0; i < object.getClass().getInterfaces().length; i++) {
System.out.println(object.getClass().getInterfaces()[i]);
}
}
public static void main(String[] args) {
String str = new String();
printClassInfo(str);
}
}
执行结果如下:
类名:java.lang.String
父类:java.lang.Object
实现的接口如下:
interface java.io.Serializable
interface java.lang.Comparable
interface java.lang.CharSequence
interface java.lang.constant.Constable
interface java.lang.constant.ConstantDesc
补充
Object类不光是所有类的父类,它还是接口的父类,接口本身属于引用数据类型,所以可以进行向上转型操作。所以说Object也可以接受一个数组。
Integer类
Integer类的对象当中拥有一个基本类型int值。并且Integer类提供了多个方法,可以在int类型和String类型之间相互转换,还提供了处理int类型时非常有用的其它一些常量和方法。
Integer类当中的构造方法
Integer当中有俩个个构造方法:
- Integer(int value):构造对象,表示指定的int值
- Integer(String s):构造对象,表示String参数指定的int值
使用构造方法获取对象如下:
Integer integer1 = new Integer(100); // 以 int 型变量作为参数创建 Integer 对象
Integer integer2 = new Integer("100"); // 以 String 型变量作为参数创建 Integer 对象
Integer类当中常用的方法
如下表
方法 | 返回值 | 功能 |
---|---|---|
toString() | String | 返回一个表示该 Integer 值的 String 对象 |
parseInt(String s) | int | 将数字字符串转换为 int 数值 |
equals(Object obj) | boolean | 比较此对象与指定对象是否相等 |
intValue() | int | 以 int 类型返回该 Integer 的值 |
shortValue() | short | 以 short 类型返回该 Integer 的值 |
byteValue() | byte | 以 byte 类型返回该 Integer 的值 |
compareTo(Integer anotherlnteger) | int | 在数字上比较两个 Integer 对象,如相等,则返回 0;如调用对象的数值小于 anotherlnteger 的数值,则返回负值;如调用对象的数值大于 anotherlnteger 的数值,则返回正值 |
valueOf(String s) | Integer | 返回保存指定的 String 值的 Integer 对象 |
前三种方法在实际编程中,经常使用。
public class Demo07 {
public static void main(String[] args) {
// 以 int 型变量作为参数创建 Integer 对象
Integer integer1 = new Integer(100);
System.out.println(integer1); // 100
// 以 String 型变量作为参数创建 Integer 对象
Integer integer2 = new Integer("200");
System.out.println(integer2); // 200
String str1 = Integer.toString(integer1);
System.out.println(str1); // 100
String str2 = "300";
int num = Integer.parseInt(str2);
System.out.println(num); // 300
}
}
Integer类中的常量
Integer类中有四个常量:
- 1.MAX_VALUE:值为 231-1 的常量,它表示 int 类型能够表示的最大值。
- 2.MIN_VALUE:值为 -231 的常量,它表示 int 类型能够表示的最小值。
- 3.SIZE:用来以二进制补码形式表示 int 值的比特位数。
- 4.TYPE:表示基本类型 int 的 Class 实例。
代码演示:
public class Demo08 {
public static void main(String[] args) {
// 获取 int 类型可取的最大值
int max_value = Integer.MAX_VALUE;
System.out.println(max_value);
// 获取 int 类型可取的最小值
int min_value = Integer.MIN_VALUE;
System.out.println(min_value);
// 获取 int 类型的二进制位
int size = Integer.SIZE;
System.out.println(size);
// 获取基本类型 int 的 Class 实例
Class c = Integer.TYPE;
System.out.println(c);
}
}
执行结果如下:
2147483647
-2147483648
32
int
Float类
Float类当中的构造方法
Float类当中拥有三个构造方法:
- 1.Float(double value):构造一个新分配的 Float 对象,它表示转换为 float 类型的参数。
- 2.Float(float value):构造一个新分配的 Float 对象,它表示基本的 float 参数。
- 3.Float(String s):构造一个新分配的 Float 对象,它表示 String 参数所指示的 float 值。
使用构造方法获取对象如下:
Float float1 = new Float(3.14145); // 以 double 类型的变量作为参数创建 Float 对象
Float float2 = new Float(6.5); // 以 float 类型的变量作为参数创建 Float 对象
Float float3 = new Float("3.1415"); // 以 String 类型的变量作为参数创建 Float 对象
Float类当中常用的方法
如下表:
方法 | 返回值 | 功能 |
---|---|---|
toString() | String | 返回一个表示该 Float 值的 String 对象 |
parseFloat(String s) | float | 将数字字符串转换为 float 数值 |
byteValue() | byte | 以 byte 类型返回该 Float 的值 |
doubleValue() | double | 以 double 类型返回该 Float 的值 |
floatValue() | float | 以 float 类型返回该 Float 的值 |
intValue() | int | 以 int 类型返回该 Float 的值(强制转换为 int 类型) |
longValue() | long | 以 long 类型返回该 Float 的值(强制转换为 long 类型) |
shortValue() | short | 以 short 类型返回该 Float 的值(强制转换为 short 类型) |
isNaN() | boolean | 如果此 Float 值是一个非数字值,则返回 true,否则返回 false |
isNaN(float v) | boolean | 如果指定的参数是一个非数字值,则返回 true,否则返回 false |
valueOf(String s) | Float | 返回保存指定的 String 值的 Float 对象 |
代码演示:
public class Demo09 {
public static void main(String[] args) {
String str = "250";
// 将字符串转换为 float 类型的数值
float num = Float.parseFloat(str);
System.out.println(num); // 250.0
// 将 float 类型的数值转换为字符串
float f = 250.0f;
String s = Float.toString(f);
System.out.println(s); // 250.0
}
}
Float当中的常量
Float 类中包含了很多常量,其中较为常用的常量如下:
- 1.MAX_VALUE:值为 1.4E38 的常量,它表示 float 类型能够表示的最大值。
- 2.MIN_VALUE:值为 3.4E-45 的常量,它表示 float 类型能够表示的最小值。
- 3.MAX_EXPONENT:有限 float 变量可能具有的最大指数。
- 4.MIN_EXPONENT:标准化 float 变量可能具有的最小指数。
- 5.MIN_NORMAL:保存 float 类型数值的最小标准值的常量,即 2-126。
- 6.NaN:保存 float 类型的非数字值的常量。
- 7.SIZE:用来以二进制补码形式表示 float 值的比特位数。
- 8.TYPE:表示基本类型 float 的 Class 实例。
代码演示:
public class Demo10 {
public static void main(String[] args) {
// 获取 float 类型可取的最大值
float max_value = Float.MAX_VALUE;
System.out.println(max_value);
// 获取 float 类型可取的最小值
float min_value = Float.MIN_VALUE;
System.out.println(min_value);
// 获取 float 类型可取的最小标准值
float min_normal = Float.MIN_NORMAL;
System.out.println(min_normal);
// 获取 float 类型的二进制位
float size = Float.SIZE;
System.out.println(size);
}
}
执行结果如下:
3.4028235E38
1.4E-45
1.17549435E-38
32.0
Double类
Double类当中的构造方法
- Double(double value):构造一个新分配的 Double 对象,它表示转换为 double 类型的参数。
- Double(String s):构造一个新分配的 Double 对象,它表示 String 参数所指示的 double 值。
使用构造方法获取对象用法如下:
Double double1 = new Double(5.456); // 以 double 类型的变量作为参数创建 Double 对象
Double double2 = new Double("5.456"); // 以 String 类型的变量作为参数创建 Double 对象
Double类当中常用的方法
如下表:
方法 | 返回值 | 功能 |
---|---|---|
toString() | String | 返回一个表示该 Double 值的 String 对象 |
parseDouble(String s) | double | 将数字字符串转换为 Double 数值 |
byteValue() | byte | 以 byte 类型返回该 Double 的值 |
doubleValue() | double | 以 double 类型返回该 Double 的值 |
floatValue() | float | 以 float 类型返回该 Double 的值 |
intValue() | int | 以 int 类型返回该 Double 的值(强制转换为 int 类型) |
longValue() | long | 以 long 类型返回该 Double 的值(强制转换为 long 类型) |
shortValue() | short | 以 short 类型返回该 Double 的值(强制转换为 short 类型) |
isNaN() | boolean | 如果此 Double 值是一个非数字值,则返回 true,否则返回 false |
isNaN(double v) | boolean | 如果指定的参数是一个非数字值,则返回 true,否则返回 false |
valueOf(String s) | Double | 返回保存指定的 String 值的 Double 对象 |
代码演示:
public class Demo11 {
public static void main(String[] args) {
double d = 12.3456;
double D = Double.valueOf(d);
System.out.println(D); // 12.3456
Double price = 250.00d;
System.out.println(price.doubleValue()); // 250.0
System.out.println(price.floatValue()); // 250.0
System.out.println(price.intValue()); // 250
System.out.println(price.longValue()); // 250
System.out.println(price.byteValue()); // -6
System.out.println(price.isNaN()); // false
}
}
Double类当中的常量
常用的常量如下:
- 1.MAX_VALUE:值为 1.8E308 的常量,它表示 double 类型的最大正有限值的常量。
- 2.MIN_VALUE:值为 4.9E-324 的常量,它表示 double 类型数据能够保持的最小正非零值的常量。
- 3.NaN:保存 double 类型的非数字值的常量。
- 4.NEGATIVE_INFINITY:保持 double 类型的负无穷大的常量。
- 5.POSITIVE_INFINITY:保持 double 类型的正无穷大的常量。
- 6.SIZE:用秦以二进制补码形式表示 double 值的比特位数。
- 7.TYPE:表示基本类型 double 的 Class 实例。
Number类
Number类是一个抽象类(abstract),也是一个超类(即父类)。所有的包装类(Double、Float、Byte、Short、Integer、Long)都是抽象类Number的子类。
既然是抽象类,就不可以直接实例化,必须实例化它的子类。
Number类当中的方法
常用方法如下表:
方法 | 说明 |
---|---|
byte byteValue(); | 返回 byte 类型的值 |
double doubleValue(); | 返回 double 类型的值 |
float floatValue(); | 返回 float 类型的值 |
int intValue(); | 返回 int 类型的值 |
long longValue(); | 返回 long 类型的值 |
short shortValue(); | 返回 short 类型的值 |
代码演示:
public class Demo12 {
public static void main(String[] args) {
Number num = new Double(12.5);
System.out.println("返回 double 类型的值:" + num.doubleValue());
System.out.println("返回 int 类型的值:" + num.intValue());
System.out.println("返回 float 类型的值:" + num.floatValue());
}
}
运行结果如下:
返回 double 类型的值:12.5
返回 int 类型的值:12
返回 float 类型的值:12.5
Character类
Character类是char类型的包装类,Character类的对象包含类型为char的单个字段,这样便可把基本数据类型当作对象来处理。
Character类当中的方法
常用方法如下表:
方法 | 功能 |
---|---|
void Character(char value) | 构造一个新分配的 Character 对象,用以表示指定的 char 值 |
char charValue() | 返回此 Character 对象的值,此对象表示基本 char 值 |
int compareTo(Character anotherCharacter) | 根据数字比较两个 Character 对象 |
boolean equals(Character anotherCharacter) | 将此对象与指定对象比较,当且仅当参数不是 null,而 是一个与此对象包含相同 char 值的 Character 对象时, 结果才是 true |
boolean isDigit(char ch) | 确定指定字符是否为数字,如果通过 Character. getType(ch) 提供的字符的常规类别类型为 DECIMAL_DIGIT_NUMBER,则字符为数字 |
boolean isLetter(int codePoint) | 确定指定字符(Unicode 代码点)是否为字母 |
boolean isLetterOrDigit(int codePoint) | 确定指定字符(Unicode 代码点)是否为字母或数字 |
boolean isLowerCase(char ch) | 确定指定字符是否为小写字母 |
boolean isUpperCase(char ch) | 确定指定字符是否为大写字母 |
char toLowerCase(char ch) | 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为小写 |
char toUpperCase(char ch) | 使用来自 UnicodeData 文件的大小写映射信息将字符参数转换为大写 |
为字符创建对象:
Character character = new Character('S');
Boolean类
Boolean类当中的构造方法
- Boolean(boolean boolValue);
- Boolean(String boolString);
其中 boolValue 必须是 true 或 false(不区分大小写),boolString 包含字符串 true(不区分大小写),那么新的 Boolean 对象将包含 true;否则将包含 false。
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 值 |
代码演示:通过编写Java程序演示如何使用不同的构造方法创建Boolean对象,并且调用booleanValue()方法将创建的对象重新转换为boolean数据输出。
public class Demo14 {
public static void main(String[] args) {
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("ok");
Boolean b3 = new Boolean("true");
System.out.println("b1 转换为 boolean 值是:" + b1);
System.out.println("b2 转换为 boolean 值是:" + b2);
System.out.println("b3 转换为 boolean 值是:" + b3);
}
}
执行结果如下:
b1 转换为 boolean 值是:true
b2 转换为 boolean 值是:false
b3 转换为 boolean 值是:true
Boolean类当中的常量
常用的常量如下:
- 1.TRUE:对应基值 true 的 Boolean 对象。
- 2.FALSE:对应基值 false 的 Boolean 对象。
- 3.TYPE:表示基本类型 boolean 的 Class 对象。
代码演示:
public class Demo15 {
public static void main(String[] args) {
Boolean flag1 = Boolean.TRUE;
System.out.println(flag1); // true
Boolean flag2 = Boolean.FALSE;
System.out.println(flag2); // false
Class<Boolean> flag3 = Boolean.TYPE;
System.out.println(flag3);
}
}
Byte类
一个 Byte 类的对象只包含一个类型为 byte 的字段。
Byte类当中的构造方法
- 1.Byte(byte value)
- 先指定一个byte类型值,然后再创建byte对象。
-
byte my_byte = 5; Byte b = new Byte(my_byte);
- 2.Byte(String s)
- 先指定一个String类型的字符,作为String类型变量,然后创建Byte对象
-
String my_byte = "5"; Byte b = new Byte(my_byte);
注意:必须使用数值型的 String 变量作为参数才能创建成功,否则会抛出 NumberFormatException 异常。
Byte类当中的方法
常用方法如下表
方法 | 返回值 | 功能 |
---|---|---|
toString() | String | 返回表示此 byte 值的 String 对象 |
parseByte(String s) | byte | 将 String 型参数解析成等价的 byte 形式 |
equals(Object obj) | boolean | 将此对象与指定对象比较,如果调用该方法的对象与 obj 相等 则返回 true,否则返回 false |
byteValue() | byte | 以一个 byte 值返回 Byte 对象 |
compareTo(Byte bytel) | int | 在数字上比较两个 Byte 对象 |
doubleValue() | double | 以一个 double 值返回此 Byte 的值 |
intValue() | int | 以一个 int 值返回此 Byte 的值 |
valueOf(String s) | Byte | 返回一个保持指定 String 所给出的值的 Byte 对象 |
代码演示:
public class Demo16 {
public static void main(String[] args) {
String str = "111";
byte num = Byte.parseByte(str);
System.out.println(num); // 111
byte num1 = 111;
String str1 = Byte.toString(num1);
System.out.println(str1); // 111
}
}
Byte类当中的常量
常用常量如下:
- 1.MIN_VALUE:byte 类可取的最小值。
- 2.MAX_VALUE:byte 类可取的最大值。
- 3.SIZE:用于以二进制补码形式表示的 byte 值的位数。
- 4.TYPE:表示基本类 byte 的 Class 实例。
代码演示:
public class Demo17 {
public static void main(String[] args) {
Byte max_value = Byte.MAX_VALUE;
System.out.println(max_value);
Byte min_value = Byte.MIN_VALUE;
System.out.println(min_value);
Byte size = Byte.SIZE;
System.out.println(size);
Class<Byte> type = Byte.TYPE;
System.out.println(type);
}
}
运行结果如下:
127
-128
8
byte
System类
简介
System类代表当前Java程序的运行平台。由于该类的构造方法是私有的(private),所以无法创建该类的对象,无法实例化。
System类的成员变量
System类拥有三个静态成员变量, PrintStream out、InputStream in、 PrintStream err。
1.PrintStream out
标准输出流
System.out.println(data);
其中,println 方法是属于流类 PrintStream 的方法,而不是 System 中的方法。
2.InputStream in
标准输入流
3.PrintStream err
标准的错误输出流
其语法与 System.out 类似,不需要提供参数就可输出错误信息。也可以用来输出用户指定的其他信息,包括变量的值。
System类的成员方法
1. arraycopy() 方法
该方法的作用是数组复制
语法格式如下:
public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length)
src:源数组
srcPos:从源数组中复制的起始索引位置
dest:目标数组
destPos:表示要赋予知道目标数组的起始索引位置
length:表示复制的个数
代码演示:
public class Demo18 {
public static void main(String[] args) {
char[] array1 = {'A','B','C','D'};
char[] array2 = {'E','F','G','H'};
System.arraycopy(array1,1,array2,1,2);
System.out.println("---------------源数组--------------");
for (int i = 0; i < array1.length; i++) {
System.out.println(array1[i]);
}
System.out.println("---------------目标数组-------------");
for (int j = 0; j < array2.length; j++) {
System.out.println(array2[j]);
}
}
}
运行结果如下:
---------------源数组--------------
A
B
C
D
---------------目标数组-------------
E
B
C
H
2. currentTimeMillis() 方法
该方法返回的是当前计算机的时间
时间的格式为当前计算机时间与 GMT 时间(格林尼治时间)1970 年 1 月 1 日 0 时 0 分 0 秒所差的毫秒数。
一般用它来测试程序的执行时间:
long m = System.currentTimeMillis();
代码演示:
public class Demo19 {
public static void main(String[] args) {
long start = System.currentTimeMillis();
for (int i = 0; i < 1000000000; i++) {
int temp = 0;
}
long end = System.currentTimeMillis();
long time = end - start;
System.out.println("程序的执行时间为" + time + "秒");
}
}
执行结果:
程序的执行时间为3秒
3.exit()方法
exit()方法的作用是终止当前正在运行的JVM
定义语法如下:
public static void exit(int status)
其中,status 的值为 0 时表示正常退出,非零时表示异常退出。
4. gc() 方法
gc()方法的作用是请求系统进行垃圾回收,完成内存中的垃圾清除
定义语法如下:
public static void gc()
5. getProperty() 方法
getProperty()方法的作用是获得系统中属性名为 key 的属性对应的值
定义语法如下:
public static String getProperty(String key)