Java内置包装类【包装类，装箱和拆箱、Object类（爹类）、Integer类、Float类、Double类、Number类、Character类、Boolean类、Byte类、System类】

---

简介

在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类当中有如下方法可以实现：

扫描二维码关注公众号，回复： 13304675 查看本文章

• 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)