一种可能是为ArrayList创建一个包装器，该包装器只提供一个方法：一个向ArrayList添加内容的方法。将ArrayList本身设为私有。现在，在全局范围中构造这些包装器对象之一（作为类中的静态对象），并用final关键字限定它（例如，public static final ArrayListWrapper wrapperClass=new ArrayListWrapper（））。因此，现在不能更改引用。也就是说，wrapperClass=null不起作用，不能用于释放内存。但是除了向wrapperClass中添加对象之外，也没有办法对wrapperClass进行任何操作。因此，添加到wrapperClass中的任何对象都不可能被回收。

在具有自己生命周期的类中随意使用非静态内部类。

在Java中，非静态内部类和匿名类对其外部类具有隐式引用。另一方面，静态内部类则不然。

下面是一个常见的Android内存泄漏示例，但这并不明显：

public class SampleActivity extends Activity {

  private final Handler mLeakyHandler = new Handler() { // Non-static inner class, holds the reference to the SampleActivity outer class
    @Override
    public void handleMessage(Message msg) {
      // ...
    }
  }

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Post a message and delay its execution for a long time.
    mLeakyHandler.postDelayed(new Runnable() {//here, the anonymous inner class holds the reference to the SampleActivity class too
      @Override
      public void run() {
     //....
      }
    }, SOME_TOME_TIME);

    // Go back to the previous Activity.
    finish();
  }}

这将防止活动上下文被垃圾收集。

面试官可能在寻找一个循环引用，比如下面的代码（顺便说一下，这只会在使用引用计数的非常旧的JVM中泄漏内存，而现在情况已经不是这样了）。但这是一个非常模糊的问题，因此这是展示您对JVM内存管理理解的绝佳机会。

class A {
    B bRef;
}

class B {
    A aRef;
}

public class Main {
    public static void main(String args[]) {
        A myA = new A();
        B myB = new B();
        myA.bRef = myB;
        myB.aRef = myA;
        myA=null;
        myB=null;
        /* at this point, there is no access to the myA and myB objects, */
        /* even though both objects still have active references. */
    } /* main */
}

然后您可以解释，使用引用计数，上面的代码会泄漏内存。但大多数现代JVM不再使用引用计数。大多数都使用一个清理垃圾收集器，它实际上会收集这些内存。

接下来，您可能会解释创建一个具有底层本机资源的Object，如下所示：

public class Main {
    public static void main(String args[]) {
        Socket s = new Socket(InetAddress.getByName("google.com"),80);
        s=null;
        /* at this point, because you didn't close the socket properly, */
        /* you have a leak of a native descriptor, which uses memory. */
    }
}

然后您可以解释这在技术上是内存泄漏，但实际上泄漏是由JVM中的本机代码分配底层本机资源造成的，而Java代码没有释放这些资源。

最后，对于现代JVM，您需要编写一些Java代码来分配JVM感知范围之外的本地资源。

理论上你不能。Java内存模型阻止了这一点。但是，因为必须实现Java，所以可以使用一些警告。这取决于您可以使用什么：

如果可以使用本机，则可以分配以后不会放弃的内存。如果这是不可用的，那么Java有一个不为人知的小秘密。您可以请求一个不由GC管理的直接访问数组，因此可以很容易地用于造成内存泄漏。这由DirectByteBuffer提供(http://download.oracle.com/javase/1.5.0/docs/api/java/nio/ByteBuffer.html#allocateDirect（int））。如果不能使用其中任何一个，仍然可以通过欺骗GC来造成内存泄漏。JVM是使用一代垃圾收集来实现的。这意味着垃圾堆被划分为三个区域：年轻人、成年人和老年人。对象创建时从年轻区域开始。随着它被越来越多地使用，它逐渐发展到成人到老年人。最有可能到达接骨木区域的对象不会被垃圾收集。您无法确定对象是否泄漏，如果您请求停止并清理GC，它可能会清理它，但在很长一段时间内，它会泄漏。更多信息请访问(http://java.sun.com/docs/hotspot/gc1.4.2/faq.html)此外，类对象不需要是GC’ed。也许有办法做到这一点。

我认为，一个有效的例子可能是在线程集中的环境中使用ThreadLocal变量。

例如，使用Servlet中的ThreadLocal变量与其他web组件通信，让容器创建线程，并在池中维护空闲线程。ThreadLocal变量如果没有正确清理，将一直存在，直到同一个web组件覆盖它们的值。

当然，一旦确定，问题很容易解决。

这里有一个在纯Java中创建真正的内存泄漏（运行代码无法访问但仍存储在内存中的对象）的好方法：

应用程序创建一个长时间运行的线程（或者使用线程池更快地泄漏）。线程通过（可选的自定义）ClassLoader加载类。该类分配一大块内存（例如新字节[10000000]），在静态字段中存储对它的强引用，然后在ThreadLocal中存储对自身的引用。分配额外的内存是可选的（泄漏类实例就足够了），但这会使泄漏工作得更快。应用程序清除对自定义类或从中加载该类的ClassLoader的所有引用。重复

由于ThreadLocal在Oracle的JDK中的实现方式，这会造成内存泄漏：

每个线程都有一个私有字段threadLocals，它实际上存储线程本地值。此映射中的每个键都是对ThreadLocal对象的弱引用，因此在ThreadLocal对象被垃圾收集后，其条目将从映射中删除。但每个值都是一个强引用，因此当一个值（直接或间接）指向作为其键的ThreadLocal对象时，只要线程存在，该对象既不会被垃圾收集，也不会从映射中删除。

在本例中，强引用链如下所示：

线程对象→ threadLocals映射→ 示例类的实例→ 示例类→ 静态ThreadLocal字段→ ThreadLocal对象。

（ClassLoader在创建泄漏时并没有真正发挥作用，它只是因为这个额外的引用链而使泄漏变得更糟：example类→ 类加载器→ 它加载的所有类。在许多JVM实现中，尤其是在Java7之前，情况更糟，因为类和ClassLoader被直接分配到permagen中，根本不会被垃圾收集。）

这种模式的一个变体是，如果您经常重新部署碰巧使用ThreadLocal的应用程序，而这些应用程序在某种程度上指向自己，那么应用程序容器（如Tomcat）会像筛子一样泄漏内存。这种情况可能有许多微妙的原因，并且通常很难调试和/或修复。

更新：由于很多人一直在要求它，这里有一些示例代码显示了这种行为。