接受的答案列出了在finalize期间关闭资源的操作。

然而，这个答案表明，至少在使用JIT编译器的java8中，您会遇到意想不到的问题，有时甚至在您完成从对象维护的流中读取之前就调用了终结器。

所以即使在这种情况下，也不建议调用finalize。

删除已经添加到全局/静态位置(不需要)的东西，并在对象被删除时需要删除，这是很方便的。例如:

    private void addGlobalClickListener() {
        weakAwtEventListener = new WeakAWTEventListener(this);

        Toolkit.getDefaultToolkit().addAWTEventListener(weakAwtEventListener, AWTEvent.MOUSE_EVENT_MASK);
    }

    @Override
    protected void finalize() throws Throwable {
        super.finalize();

        if(weakAwtEventListener != null) {
            Toolkit.getDefaultToolkit().removeAWTEventListener(weakAwtEventListener);
        }
    }

资源(文件，套接字，流等)需要关闭一旦我们完成他们。它们通常有close()方法，我们通常在try-catch语句的finally部分调用该方法。有时finalize()也可以被少数开发人员使用，但在我看来，这不是一种合适的方式，因为不能保证finalize总是被调用。

在Java 7中，我们有try-with-resources语句，可以这样使用:

try (BufferedReader br = new BufferedReader(new FileReader(path))) {
  // Processing and other logic here.
} catch (Exception e) {
  // log exception
} finally {
  // Just in case we need to do some stuff here.
}

在上面的例子中，try-with-resource将通过调用close()方法自动关闭资源BufferedReader。如果我们愿意，我们也可以在自己的类中实现Closeable，并以类似的方式使用它。在我看来，这似乎更整洁，更容易理解。

class MyObject {
    Test main;

    public MyObject(Test t) {    
        main = t; 
    }

    protected void finalize() {
        main.ref = this; // let instance become reachable again
        System.out.println("This is finalize"); //test finalize run only once
    }
}

class Test {
    MyObject ref;

    public static void main(String[] args) {
        Test test = new Test();
        test.ref = new MyObject(test);
        test.ref = null; //MyObject become unreachable，finalize will be invoked
        System.gc(); 
        if (test.ref != null) System.out.println("MyObject still alive!");  
    }
}

====================================

结果:

This is finalize

MyObject still alive!

=====================================

所以你可以在finalize方法中使一个不可达的实例可达。

公认的答案是好的，我只是想补充的是，现在有一种方法来实现finalize的功能，而不实际使用它。

看看“Reference”类。弱引用，幻影引用和软引用。

您可以使用它们来保存对所有对象的引用，但是这个引用ALONE不会停止GC。这样做的好处是，当它被删除时，你可以让它调用一个方法，并且这个方法可以保证被调用。

至于finalize: 我使用finalize一次来了解哪些对象正在被释放。你可以用静态、引用计数等来玩一些巧妙的游戏——但这只是为了分析，但要注意这样的代码(不只是在finalize中，但这是你最有可能看到它的地方):

public void finalize() {
  ref1 = null;
  ref2 = null;
  othercrap = null;
}

这表明某人不知道自己在做什么。像这样的“清理”实际上是不需要的。当类被GC化时，这将自动完成。

如果你在finalize中发现这样的代码，那肯定是编写它的人搞糊涂了。

如果它在其他地方，可能是代码是一个坏模型的有效补丁(一个类存在很长一段时间，由于某种原因，它引用的东西必须在对象GC之前手动释放)。一般来说，这是因为有人忘记删除监听器或其他东西，不知道为什么他们的对象没有被GC，所以他们只是删除它引用的东西，耸耸肩然后离开。

它永远不应该被用来“更快”地清理东西。

编辑:好吧，这真的不管用。我实现了它，并认为如果它有时失败了，这对我来说是可以的，但它甚至没有调用finalize方法一次。

我不是一个专业的程序员，但在我的程序中，我有一个案例，我认为是一个使用finalize()的好例子，那是一个缓存，在它被销毁之前将其内容写入磁盘。因为它没有必要在每次销毁时都执行，它只会加速我的程序，我希望我没有做错。

@Override
public void finalize()
{
    try {saveCache();} catch (Exception e)  {e.printStackTrace();}
}

public void saveCache() throws FileNotFoundException, IOException
{
    ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("temp/cache.tmp"));
    out.writeObject(cache);
}