1. public class TestEquals{
   
2.         public static void main(String args[]){
   
3.                 for(int i=0;i<10;i++){
   
4.                         Person p = new Person("Tom" + i);
   
5.                         for(int j=0;j<1000;j++){
   
6.                                 String[] test = {new String("Asdf"),new String("Billy"),new String("Kessy")};
   
7.                         }
   
8.                 }
   
9.         }
   
10. }
    
11. 
    
12. class Person{
    
13.         private String name;
    
14.         public Person(String name){
    
15.                 this.name = name;
    
16.                 System.out.println("创建Person对象，name:" + name);        
    
17.         }
    
18.         //---        
    
19.         public void finalize(){
    
20.                 System.out.println("销毁Person对象，name:" + name);        
    
21.         }
    
22. }

复制代码

1. 创建Person对象，name:Tom0
   
2. 创建Person对象，name:Tom1
   
3. 创建Person对象，name:Tom2
   
4. 创建Person对象，name:Tom3
   
5. 销毁Person对象，name:Tom1
   
6. 销毁Person对象，name:Tom2
   
7. 创建Person对象，name:Tom4
   
8. 创建Person对象，name:Tom5
   
9. 创建Person对象，name:Tom6
   
10. 创建Person对象，name:Tom7
    
11. 创建Person对象，name:Tom8
    
12. 销毁Person对象，name:Tom5
    
13. 销毁Person对象，name:Tom7
    
14. 销毁Person对象，name:Tom6
    
15. 销毁Person对象，name:Tom4
    
16. 创建Person对象，name:Tom9
    

复制代码

finalize()什么时候调用?好像用到了垃圾回首机制，有大神能具体讲解下么？？

finalize 即使你显示调用，Garbage Collection 也是不在你的控制下工作，只在它认为应该工作的时候工作。

两点:
1.没有任何引用指向对象
2.jvm在适当的时候回收

这个适当的时候很纠结啊

供楼主参考

其实java的一大优点就是gc机制，垃圾回收机制。这个机制就是finalize（）方法，jvm何时调用该方法是不确定的，尽管我们可以重写该方法，并显式调用该方法，但是即使调用了我们也不知道jvm何时进行垃圾回收，垃圾回收只能回收堆内存的资源，不能销毁任何物理资源。
我们没有必要也不用调用finalize方法，该方法完全由垃圾回收机制搞定。
该方法何时被调用具有不确定性，因此不能把finalize（）方法当成一定会执行的方法
当jvm执行该方法出现异常时，垃圾回收机制不会报告异常，程序继续进行。

执行流程：进入main方法------外层for循环-------------- Person p = new Person("Tom" + i);       （  此时"="左边在栈内开辟了一块空间即创建名字为p的引用，"="右边在堆内开辟了一块空间即new Person("Tom" + i); ）
当new person(tom+i)时调用Person类里的有参构造即
public Person(String name)
{
          this.name = name;
          System.out.println("创建Person对象，name:" + name);        
}

然后每循环一次，就创建一次对象，就调用一次有参构造；一共循环10次，就调用10次有参构造方法
当循环结束，栈内引用立刻消除，对象还有可能保留一段时间，当jvm调用finalize()时就把堆内存的对象清除即你所说的销毁对象

JVM和C++在这上面有点不一样啊，
JVM处理垃圾对象的的特点：不受人为控制，不受时间控制。换句话说就是在不确定的时间 会自动调用Garbage Collection回收机制
C++:认为的程序员自己搞，累啊。

兄弟对这个问题 别太纠结 交给JVM得了。