深入浅出常用类

整理一下所学过的常用类，以及常用类下的方法，如果大家觉得我写的不错的话请为我点个赞好吗

Object类

简介

• 超类、基类，所有类的直接或间接父类，位于继承树的最顶层。
• 任何类，如没有书写extends显示继承某个类，都默认直接继承Object类，否则为间接继承。
• Object类中所定义的方法，是所有对象都具备的方法。
• Object类型可以存储任何对象。
  • 作为参数，可接受任何对象。
  • 作为返回值，可返回任何对象。

Object中的方法

(一)getClass()方法

示例代码

public class Test {
    public static void main(String[] args) {
        Person p = new Person(1,"刘德华");
        System.out.println(p.getClass()); 
        System.out.println(p.getClass().getName()); //返回的是内存中实实在在存在的Person 这个类
    }
}

class Person{
    int id;
    String name;
    public Person(int id, String name) {
        super();
        this.id = id;
        this.name = name;
    }
}

运行结果：

以面向对象的形式理解getClass()：

一个男人有爸爸的称呼，丈夫（老公），还有儿子的称呼，还有爷爷，叔叔等等的称呼，而这些称呼的参照物不同导致有不同的称呼。当参照物是老婆时，这个男人的称呼是丈夫(老公)，当参照物是男人的儿子时，此男人的称呼是爸爸。以此类推等等。

同理对于Person类，或者准确的说每个类（除所有类的父类Object）也有两个称呼，既可以称为是类，也可称为变量。参照物不同称呼不同。

上面的代码为例：
参照物： Person的属性id,name 则：Person的称呼是类(Class）
参照物： Class类，则：Person的称呼是变量/属性

(二)hashCode()方法

示例代码

public class Test {
        public static void main(String args[]) {
                String Str = new String("www.haoran.com");
                System.out.println("字符串的哈希码为 :" + Str.hashCode() );
        }
}

运行结果

小结

• public int hashCode(){}
• 返回对象的哈希码值
• 哈希根据对象的地址或字符串或数字使用hash算法算出来的int类型的数值。
• 一般情况下相同对象返回相同哈希码

如果需要深入了解hashCode()方法 推荐这篇博客 传送门

(三)toString()方法

• toString() 方法就是把一个类型转换为 String 字符串类型。

• 比如当定义一个int类型后，利用toString（）方法就能把int转化为string类型，即把整数类型转换为了字符串。(举例即int a = 10；转换后就变成了a =“10”。这里的10不再是整数，他有了双引号，变成了字符串。)

• tostring（）方法是object类里的方法。又因为object类是所有类的子类，这些类默认继承他，因此所有类的对象都可以使用tostring (）

• 在源码的注释中有重要一句话：It is recommended that all subclasses override this method（建议所有的子类都覆盖这个方法），java类根据需要重写toString方法才能使返回值更有意义。即如果不去重写这个方法那么返回值就会是 类名+符号@+对象的哈希码值。

那么如何重写呢?

示例代码

public class Test18 {
     
    private int x;
    private int y;
     
    public Test18(int x){
        this.x=x;
        this.y=y;
    }
     
    public String toString(){
        return "x="+x;
    }
     
    public static void main(String[] args) {
        Test18 t=new Test18(3);
        System.out.println(t.toString());
    }
}

运行结果

这里在tostring（）方法返回中必须要是“x=”+x；这种类型。因为只返回一个x的话，他还是一个int类型的值

小结

• public String toString(){}
• 返回该对象的字符串表示(表现形式)。
• 可以根据程序需求覆盖方法，如：展示对象的各个属性值。

(四)equals()方法

示例代码

public class Test {
    public static void main(String args[]) {
        String Str1 = new String("haoran");
        String Str2 = Str1;
        String Str3 = new String("haoran");
        boolean retVal;

        retVal = Str1.equals( Str2 );
        System.out.println("返回值 = " + retVal );

        retVal = Str1.equals( Str3 );
        System.out.println("返回值 = " + retVal );
    }
}

运行结果

小结

• public boolean equals(Object obj){}
• 默认实现为(this == obj)，比较两个对象地址是否相同。
• 可进行覆盖，比较两个对象的内容是否相同。
  • 比较两个引用是否指向同一个对象。
  • 判断obj是否为null。
  • 判断两个引用指向的实际对象类型是否一致。
  • 依次比较各个属性值是否相同。

简单举例equals()方法的使用，如果要深入研究 推荐这篇博客 传送门

(五)finalize方法

简单来说 finalize() 方法就是：当一个对象被 JVM虚拟机 宣告死亡时，会自动调用finalize()方法，进行对象的垃圾回收。

这个方法不需要我们手动去调用，由 JVM虚拟机自动去调用。

小结

• 当对象被判定为垃圾对象时，由JVM自动调用此方法，用以标记垃圾对象，进入回收队列。
• 垃圾对象：没有有效引用指向此对象时，为垃圾对象。
• 垃圾回收：由GC销毁垃圾对象，释放数据存储空间。
• 自动回收机制：JVM的内存耗尽，一次性回收所有垃圾
• 手动回收机制：使用System.gc();通知JVM执行垃圾回收。

包装类

什么是包装类

　Java中的基本数据类型没有方法和属性，而包装类就是为了让这些拥有方法和属性，实现对象化交互。

    数值型包装类都继承至Number，而字符型和布尔型继承至Object。

装箱与拆箱

    装箱：基本数据类型转换为包装类；

    拆箱：包装类转换为基本数据类型。

案例代码

package com.swpu;

public class Test {
    public static void main(String[] args){
        //1.自动装箱
        int t1=1;
        Integer t2=t1;
        //2.手动装箱
        Integer t3=new Integer(t1);
        System.out.println("int类型t1="+t1);
        System.out.println("自动装箱，Integer类型对象t2="+t2);
        System.out.println("手动装箱，Integer类型t3="+t3);


        //1.自动拆箱
        int t4=t2;
        //2.手动拆箱
            //通过intValue()方法返回int值，还可以利用其他方法装换为其他类型
        int t5=t2.intValue();
        System.out.println("自动拆箱,int型t4="+t4);
        System.out.println("手动拆箱,int型t5="+t5);
    }

}

输出结果

数据类型和包装类之间的转换

    通过包装类Integer.toString()将整型转换为字符串；

    通过Integer.parseInt()将字符串转换为int类型；

    通过valueOf()方法把字符串转换为包装类然后通过自动拆箱。

package com.swpu;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //基本数据类型转换为字符串
        int t1=12;
        String t2=Integer.toString(t1);
        System.out.println("int转换为String："+t2);
        //字符串转换为基本数据类型
        //通过paerInt方法
        int t3=Integer.parseInt(t2);
        //通过valeOf,先把字符串转换为包装类然后通过自动拆箱
        int t4=Integer.valueOf(t2);
        System.out.println("t3:"+t3);
        System.out.println("t4:"+t4);

    }

}

输出结果

扩展知识

    包装类对象的初始值为null（是一个对象）；

    包装类对象之间的比较：

package com.swpu;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Integer one=new Integer(100);
        Integer two=new Integer(100);
        //one和对two是两个不同的对象，==在比较对象时比较的是内存地址，两个是不同的空间，放的值相同
        System.out.println("one==two:"+(one==two));
        Integer three=100;//自动装箱
        /*    Integer three=Integer.valueOf(100);
         * 这时缓存区没有，就会构造一个
         */
        System.out.println("three==100:"+(three==100));//自动拆箱
        Integer four=100;
        /*实际执行的是    Integer four=Integer.valueOf(100); 这时缓存区有，就会直接取
         * Java为了提高拆装箱效率，在执行过程中提供了一个缓存区（对象池）【类似于常量数组】，
         * 如果传入的参数是，-128<参数<127会直接去缓存查找数据，如果有久直接产生，如果没有就隐式调用new方法产生
         */

        System.out.println("three==four:"+(three==four));
        Integer five=200;
        System.out.println("five==200:"+(five==200));
        Integer six=200;
        //注：这里为200，超出了缓存区范围，所以都需要构建
        System.out.println("five==six:"+(five==six));
    }
}

输出结果

Java中除了float和double的其他基本数据类型，都有常量池

String类

String类型的存储

(一)第一种创建方法，直接创建

示例代码

String name = "hello"; //hello 常量存储在字符串池中，name变量存在堆中
name = "zhangsan";// “zhangsan”赋值给name赋值时，并没有存储在常量池中的数据，而是重新开辟一个空间存放 zhangsan
String name2 = "zhangsan"; //不会重新在常量池中开辟一个空间，而是直接指向之前创建好的 zhangsan这个值

结构图

(二)第二种创建方法：通过new 来创建
示例代码

//字符串的另一种创建方式,new String
String str = new String("java"); //是在堆和常量池中分别创建一个java的空间

结构图

String的常用方法

1. public int length()：返回字符串长度
2. public char charAt(int i)：根据下标获取字符。
3. public boolean contains(String str)：判断当前字符串中是否包含str
4. public char[] toCharArray(); 返回字符串对应的数组
5. public int indexOf(); 返回子字符串首次出现的位置
6. public int lastIndexOf(String str); 返回字符串最后一次出现的位置
7. public String trim()：去掉字符串前后的空格
8. public String toUpperCase()：将小写转成大写
9. public boolean endWith(String str)：判断字符串是否以str结尾。
10. public String replace(char oldChar,char newChar)：将旧字符串替换成新字符串
11. public String[] split(String str)：根据str做拆分
12. public boolean equalsIgnoreCase(Object o)：忽略大小写的比较
13. public int compareTo(String s)：比较大小

案例代码

//1、2、3
String content = "java";
System.out.println(content.length());
System.out.println(content.charAt(content.length()-1)); 
System.out.println(content.contains("j"));
System.out.println(content.contains("php"));

//4、5、6
System.out.println(Arrays.toString(content.toCharArray()));
System.out.println(content.indexOf("java"));
System.out.println(content.indexOf("java",4));
System.out.println(content.lastIndexOf("java"));

//7、8、9
String content2 = "   hello world   ";
System.out.println(content2.trim());
System.out.println(content2.toUpperCase());
System.out.println(content2.toLowerCase());
String filename = "hello.java";
System.out.println(filename.endsWith(".java"));
System.out.println(filename.startsWith("hello"));

//10、11
System.out.println(content.replace("java", "php"));

String say="java is the best programing language java hao";
String[] arr = say.split(" ");
System.out.println(arr.length);
for (String s : arr) {
	System.out.println(s);
}
//12、13
String s1="hello";
String s2="HELLO";
System.out.println(s1.equalsIgnoreCase(s2)); //equalsIgnoreCase 忽略大小写的比较


String s3="abc"; //97
String s4="xyz"; //120
System.out.println(s3.compareTo(s4));

String s5="abc";
String s6="abcxyz";
System.out.println(s5.compareTo(s6));

输出结果

//1、2、3
4
a
true
false

//4、5、6
[j, a, v, a, 是, 世, 界, 上, j, a, v, a, 最, 好, 的, 语, 言, j, a, v, a]
0
8
17

//7、8、9
hello world
   HELLO WORLD   
   hello world   
true
true

//10、11
php是世界上php最好的语言php
8
java
is
the
best
programing
language
java
hao
//11、12
true
-23
-3

总结

• content.length()-1 ：返回最后一位字符，如果不 -1 则会 报出 java.lang.StringIndexOutOfBoundsException 字符串截取下标越界异常
• indexOf 有很多重载的方法，此例中只列出了两种，有更多需求请查阅 Api 文档
• toUpperCase()：将字符串转换为大写，toLowerCase()：将字符串转换为小写
• endsWith()：从字符串后面开始找，startsWith()：从字符串前面开始找。
• equalsIgnoreCase 忽略大小写的比较.

String s5=“abc”;
String s6=“abcxyz”;

通过compareTo比较大小的时候，如果变量s5和s6中的值重复了，那么他们比较的就是字符串的长度

StringBuffer和StringBuilder

介绍

• StringBuffer：可变长字符串，JDK1.0提供，运行效率慢、线程安全
• StringBuiler：可变长字符串，JDK5.0提供，运行效率快、线程不安全

使用

• StringBuffer和StringBuiler使用的方法完全一样。

案例代码

public class Demo03 {
	public static void main(String[] args) {
		//StringBuffer sb = new StringBuffer();
		StringBuilder sb = new StringBuilder();
		//四个方法
		//1、append();追加
		sb.append("java世界第一");
		System.out.println(sb.toString());
		sb.append("java真香");
		System.out.println(sb.toString());
		sb.append("java不错");
		System.out.println(sb.toString());
		//2、insert();添加
		sb.insert(0, "我在最前面");
		System.out.println(sb.toString());
		//3、replace();
		sb.replace(0, 5, "hello");
		System.out.println(sb.toString());
		//4、delete();删除元素
		sb.delete(0, 5);
		System.out.println(sb.toString());
		//5、反转字符串
		System.out.println(sb.reverse());
		//6、清空
		sb.delete(0, sb.length());
		System.out.println(sb.length());
	}
}

打印结果

java世界第一
java世界第一java真香
java世界第一java真香java不错
我在最前面java世界第一java真香java不错
hellojava世界第一java真香java不错
java世界第一java真香java不错
错不avaj香真avaj一第界世avaj
0

StringBuffer、StringBuilder和String之间的区别、速度比较

• 效率比String高
• 比String省内存

代码案例

public class Demo04 {
	public static void main(String[] args) {
		long start = System.currentTimeMillis(); //计算开始的时间
		
		//注释的是用String计算出来的时间
		// String string = "";
		// for (int i=0;i<99999;i++){
		// 	string+=i;
		// }
		// System.out.println(string);

		//计算出来的是StringBuilder出来的时间
		StringBuilder sb = new StringBuilder();
		for (int i=0;i<99999;i++){
			sb.append(i);
		}
		System.out.println(sb.toString());
		long end = System.currentTimeMillis();
		System.out.println("用时："+(end-start));
	}
}

打印结果

我的结果：String是40多秒，StringBuilder是20毫秒，每台机子都不一样大概在这上下浮动。

BigDecimal类

简介

    Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的 +、-、*、/ 等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

构造器

BigDecimal(int)       //创建一个具有参数所指定整数值的对象。
BigDecimal(double) 	  //创建一个具有参数所指定双精度值的对象。
BigDecimal(long)      //创建一个具有参数所指定长整数值的对象。
BigDecimal(String) 	  //创建一个具有参数所指定以字符串表示的数值的对象。

    这几个都是常用的构造器，他们返回的对象都是BigDecimal对象。换而言之， 将各个类型的值转换为BigDecimal对象，就是通过构造器。

    反过来说，将BigDecimal对象转换为其他类型的对象，我们通过以下几种：

toString()             //将BigDecimal对象的数值转换成字符串。
doubleValue()          //将BigDecimal对象中的值以双精度数返回。
floatValue()           //将BigDecimal对象中的值以单精度数返回。
longValue()            //将BigDecimal对象中的值以长整数返回。
intValue()             //将BigDecimal对象中的值以整数返回。

常用方法

BigDecimal b1 = new BigDecimal("20");
BigDecimal b2 = new BigDecimal("30");


b1.add(b2) ：加法，求两个BigDecimal类型数据的和。
b1.subtract(b2)：减法，求两个BigDecimal类型数据的差。
b1.multiply(b2)：乘法，求两个BigDecimal类型数据的积。
b1.remainder(b2)：求余数，求b1除以b2的余数。
b1.max(b2) : 最大数，求两个BigDecimal类型数据的最大值
b1.min(b2) : 最小数，求两个BigDecimal类型数据的最小值。
bi.abs()：绝对值，求BigDecimal类型数据的绝对值。
b1.negate()：相反数，求BigDecimal类型数据的相反数。

这里把除法单独拉出来

BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

    除法 divide有三个参数的方法，第一参数表示除数，第二个参数表示小数点后保留位数，第三个参数表示取舍规则。只有在作除法运算或四舍五入时才用到取舍规则。 因为BigDecimal除法可能出现不能整除的情况，比如 4.5/1.3，这时会报出 java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result这样的异常。所以当我们用三参数的除法方法时，规定了保留几位小数以及你的保留方式，就可以避免异常。

几个取舍规则：

ROUND_CEILING //向正无穷方向舍入
ROUND_DOWN //向零方向舍入
ROUND_FLOOR //向负无穷方向舍入
ROUND_HALF_DOWN  //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向下舍入, 例如1.55 保留一位小数结果为1.5
ROUND_HALF_EVEN  //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，如果保留位数是奇数，使用ROUND_HALF_UP，如果是偶数，使用ROUND_HALF_DOWN
ROUND_HALF_UP  //向（距离）最近的一边舍入，除非两边（的距离）是相等,如果是这样，向上舍入, 1.55保留一位小数结果为1.6
ROUND_UNNECESSARY //计算结果是精确的，不需要舍入模式
ROUND_UP //向远离0的方向舍入

我们最常用的四舍五入是 ROUND_HALF_UP

除法案例代码

BigDecimal r1 = new BigDecimal("1.4")
				.subtract(new BigDecimal("0.5"))
				.divide(new BigDecimal("0.9"));
		
System.out.println(r1);

BigDecimal r2 = new BigDecimal("10").divide(new BigDecimal("3"),2,BigDecimal.ROUND_HALF_UP);
//这里如果不使用重载方法进行四舍五入的化会报出
//java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result
//这个异常
System.out.println(r2);

输出结果

1
3.33

Date类

• Date表示特定的瞬间，精确到毫秒。Date类中的大部分方法都已经被Calendar类中的方法所取代。

• 时间单位

  • 一秒=1000毫秒
  • 1毫秒=1000微秒
  • 1微秒=1000纳秒

创建Date类及使用方法

打印今天的时间

Date date1 = new Date();
System.out.println(date1.toString()); 
System.out.println(date1.toLocaleString()); //这个方法已经过期了，但是按照习惯看toLocaleString()这个方法打印出来的数据比较顺眼

打印结果

Mon Sep 21 17:13:07 CST 2020
2020-9-21 17:13:07

打印昨天的时间

Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 1000));
System.out.println(date2.toLocaleString());

打印结果

2020-9-20 17:13:07

• 用今天的时间减去一天，就是昨天的时间。
• 求一天的时间：*1000 毫秒进秒，*60 秒进分钟，*60 分钟进小时，*24 小时进天。

运用Date类中的方法

Date date1 = new Date();
Date date2 = new Date(date1.getTime() - (60 * 60 * 24 * 1000));

//1、方法 after before
System.out.println(date1.after(date2));  
System.out.println(date1.before(date2)); 

//2、比较 compareTo();
System.out.println(date1.compareTo(date2)); 
System.out.println(date2.compareTo(date1));

//3、比较是否相等 equals()
System.out.println(date1.equals(date2));

• after：date1是否在date2之后
• before：date1是否在date2之前
• compareTo：比较时间大小的，相等返回0，大于返回1，小于返回-1.
• equals：比较两个时间是否相等

打印结果

true
false
1
-1
false

Caledar类

• Calendar提供了获取或设置各种日历字段的方法。
• 构造方法
  • protected Calendar()：由于修饰符是protected，所以无法直接创建对象。
  • 其他方法

Caledar类语法

Calendar calendar = Calendar.getInstance(); //因为这个类是protected修饰的，所以创建类对象时应该使用这个类下面的 getInstance()方法来进行对象的初始化。

Caledar类创建与方法

代码案例

//1、创建一个Calendar对象
Calendar calendar = Calendar.getInstance();
System.out.println(calendar.getTime().toLocaleString());
System.out.println(calendar.getTimeInMillis()); //从1970年1月1日到现在过了多少毫秒

//2、获取时间信息
	//获取年
	int year = calendar.get(Calendar.YEAR);
	//月 0(月是从0开始的开始的，Calendar中的 0月 就相当于现实中的1月)-11 11就是12月
	int month = calendar.get(Calendar.MONTH);
	//日
	int day = calendar.get(Calendar.DAY_OF_MONTH); //用Date也行
	//小时
	int hours = calendar.get(Calendar.HOUR_OF_DAY); //HOUR是12小时的，HOUR是24小时的
	//分钟
	int minute = calendar.get(Calendar.MINUTE);
	//秒
	int second = calendar.get(Calendar.SECOND);
	System.out.println(year + "年" + (month+1) + "月" + day + "日" + hours + "小时" + minute + "分钟" + second + "秒");
	
	//3、修改时间
	Calendar calendar2 = Calendar.getInstance();
	calendar2.set(Calendar.DAY_OF_MONTH, 20);
	System.out.println(calendar2.getTime().toLocaleString());

	//4、add方法添加时间
	calendar2.add(Calendar.HOUR, 1);
	System.out.println(calendar2.getTime().toLocaleString());

	//5、补充方法
	calendar2.add(Calendar.MONTH, 1);
	int max = calendar2.getActualMaximum(Calendar.DAY_OF_MONTH); //获取当前月中的最大值
	int min = calendar2.getActualMinimum(Calendar.DAY_OF_MONTH); //获取当前月中的最小值
	System.out.println(max);
	System.out.println(min);

输出结果

2020-9-21 18:30:16
1600684216193
2020年9月21日18小时30分钟16秒
2020-9-20 18:30:16
2020-9-20 19:30:16
31
1

SimpleDateFormat类

• SimpleDateFormat是一个以语言环境有关的方式来格式化和解析日期的具体类。
• 进行格式化（日期 -> 文本）、解析（文本 -> 日期）。
• 常用的时间模式字母

SimpleDateFormat的使用

案例代码

	//1、创建SimpleDateFormat对象    y：年	M：月
	//创建SimpleDateFormat对象时 使用参数的格式 进行初始化
		SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
	//2、创建Date
	Date date = new Date();
	//格式化date(把日期转成时间字符串)
	String str = sdf.format(date);
	System.out.println(str);
		//解析(把字符串转成日期) 一定要按照上方所传递的格式进行转换，不然就会报java.lang.NullPointerException异常
		Date parse = null;
		try {
			parse = sdf.parse("2002年3月31日 10:22:33"); //此方法会出现异常我们捕获一下就好
		} catch (ParseException e) {
			e.printStackTrace();
		}
		System.out.println(parse.toLocaleString());

输出结果

2020年09月21日 18:47:28
2002-3-31 10:22:33

System类

• System系统类，主要用于获取系统的属性数据和其它操作，构造方法是私有的。
• System的类和方法都是静态的，我们要想使用直接 (.) 就可以了
  

System类的使用

案例代码

	//1、arraycopy：数组的复制
	//参数一：(src：源数组)
	//参数二：(srcPos：从哪个位置开始复制 0)
	//参数三：(dest：目标数组)
	//参数四：(destPos：目标数组的位置)
	//参数五：(length：赋值的长度)
		int[] arr = {20,18,15,8,35,11,26,90};
		int[] dest = new int[8];
		System.arraycopy(arr, 0, dest, 0, arr.length);

		for (int result : dest) {
			System.out.println(result);
		}

		//2、获取毫秒数
		System.out.println(System.currentTimeMillis());
		
		long start = System.currentTimeMillis();
		for (int i = -999999; i < 999999; i++) {
			for (int j = -999999; j < 999999; j++) {
				int result = i+j;
			}
		}
		long end = System.currentTimeMillis();
		System.out.println("打印用时：" + (end-start));

		//3、System.gc(); 告诉垃圾回收器回收垃圾
		
		//这是有变量引用的，不会被垃圾回收器回收
		// Test t1 = new Test("aaa",19);
		// Test t2 = new Test("bbb",19);
		// Test t3 = new Test("ccc",19);

		// System.gc();//告诉垃圾回收器回收

		//这是没有变量引用的，会被垃圾回收器回收
		new Test("aaa",19);
		new Test("bbb",19);
		new Test("ccc",19);

		System.gc();//告诉垃圾回收器回收
		//简单来说是程序员干预一下jvm的垃圾回收

		//4、退出jvm  提前退出了jvm，后面的代码不会执行
		System.exit(0);

		System.out.println("程序结束了");

System.gc所需Test类代码

public class Test {
	private String name;
	private int age;

	public Test() {
	}

	public Test(String name, int age) {
		this.name = name;
		this.age = age;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	@Override
	protected void finalize() throws Throwable {
		System.out.println("回收了" + name+ "    " + age);
	}
}

• 重写了finalize()方法，方法作用是在对象被回收时执行这个方法中的内容，让我们看到JVM显示的回收了对象。

总结

• Object类
  • 所有类的直接或间接父类，可存储任何对象。
• 包装类
  • 基本数据类型对应的引用数据类型，可以使Object统一所有数据。
• String类
  • 字符串是常量，创建之后不可改变，字面值保存在字符串池中，可以共享。
• BigDecimal
  • 可精确计算浮点数。
• Date
  • 特定的时间
• Calendar
  • 对Date类进行完善
• SimpleDateFormat
  • 格式化时间
• System
  • 系统类