内存泄漏就是指一个不再被程序使用的对象或变量一直被占据在内存中。也就是该回收的内存没有被释放白白占据空间。java中有gc专门回收内存，那java中是否也有内存泄漏的问题呢？在什么情况下会出现内存泄漏呢？能给一个具体的实例场景吗？ps：因为内存泄漏问题是高级程序设计语言的通病，多少都有一些，所以我认为java中存在内存泄漏，但是却没有遇到过实例。

在hashcode那讲中有个内存泄露的实例
Collection collections = new HashSet();
ReflectPoint pt1 = new ReflectPoint(3,3);
ReflectPoint pt2 = new ReflectPoint(5,5);
ReflectPoint pt3 = new ReflectPoint(3,3);       

collections.add(pt1);
collections.add(pt2);
collections.add(pt3);
collections.add(pt1);       
               
pt1.y = 7;               
collections.remove(pt1);
               
System.out.println(collections.size());
你会发现没有把pt1取走，因为已改完y的hashcode以改变，而是去以改变的那个集合去找pt1，以前的那个pt1还存在，以为把pt1删掉了，然而pt1还存在。这就是内存泄露。假如程序不停的这样的增加对象，修改对象，删除对象。就好发生内存泄露

内存泄露一般指堆内存泄露，堆内存是指程序从堆中分配的，大小任意的，使用完后必须释放掉，忘记释放先前分配内存，就可能造成内存泄露，如果程序保留对永远不再使用的对象的引用，这些对象将会占用并耗尽内存，这是因为自动化的垃圾收集器无法证明这些对象将不再使用。如果存在一个对对象的引用，对象就被定义为活动的，因此不能删除，因此要释放可以通过将对象字段设置为null或从集合中删除
保留下来却永远不再使用的对象引用这就是内存泄露。
一个例子：
Arraylist a = new Arraylist（10）;
for（int i=1；i<100；i++）
{
object  o = new Object();
a.add(o);
o=null；
}
//此时，所有的object对象都没有被释放，因为变量a引用这些对象

Java中的内存泄露是指：存在无用但是垃圾回收器无法回收的对象。而且即使有内存泄露问题存在，也不一定会表现出来。
public class Stack {
　private Object[] elements=new Object[10];
　private int size = 0;

　public void push(Object e){
　　ensureCapacity();
　　elements[size++] = e;
　}

　public Object pop(){
　　if( size == 0)
　　　throw new EmptyStackException();
　　　return elements[--size];
　}

private void ensureCapacity(){
　if(elements.length == size){
　　Object[] oldElements = elements;
　　elements = new Object[2 * elements.length+1];
　　System.arraycopy(oldElements,0, elements, 0, size);
　}
}
}

　　上面的原理应该很简单，假如堆栈加了10个元素，然后全部弹出来，虽然堆栈是空的，没有我们要的东西，但是这是个对象是无法回收的，这个才符合了内存泄露的两个条件：无用，无法回收。

　　但是就是存在这样的东西也不一定会导致什么样的后果，如果这个堆栈用的比较少，也就浪费了几个K内存而已，反正我们的内存都上G了，哪里会有什么影响，再说这个东西很快就会被回收的，有什么关系。下面看两个例子。

　　例子1

public class Bad{
　public static Stack s=Stack();
　　static{
　　　s.push(new Object());
　　　s.pop(); //这里有一个对象发生内存泄露
　　　s.push(new Object()); //上面的对象可以被回收了，等于是自愈了
　　}
}

　　因为是static，就一直存在到程序退出，但是我们也可以看到它有自愈功能，就是说如果你的Stack最多有100个对象，那么最多也就只有100个对象无法被回收其实这个应该很容易理解，Stack内部持有100个引用，最坏的情况就是他们都是无用的，因为我们一旦放新的进取，以前的引用自然消失！

　　例子2

public class NotTooBad{
　public void doSomething(){
　　Stack s=new Stack();
　　s.push(new Object());
　　//other code
　　s.pop();//这里同样导致对象无法回收,内存泄露.
　}//退出方法,s自动无效,s可以被回收,Stack内部的引用自然没了,所以
　//这里也可以自愈,而且可以说这个方法不存在内存泄露问题,不过是晚一点
　//交给GC而已,因为它是封闭的,对外不开放,可以说上面的代码99.9999%的
　//情况是不会造成任何影响的,当然你写这样的代码不会有什么坏的影响,但是
　//绝对可以说是垃圾代码!没有矛盾吧,我在里面加一个空的for循环也不会有
　//什么太大的影响吧,你会这么做吗?
}

　　上面两个例子都不过是小打小闹,但是C/C++中的内存泄露就不是Bad了,而是Worst了。他们如果一处没有回收就永远无法回收,频繁的调用这个方法内存不就用光了!因为Java还有自愈功能(我自己起的名字),所以Java的内存泄露问题几乎可以忽略了,但是知道的人就不要犯了。

　　不知者无罪!Java存在内存泄露,但是也不要夸大其辞。如果你对Java都不是很熟,你根本就不用关心这个,我说过你无意中写出内存泄露的例子就像你中一千万一样概率小,开玩笑了,其实应该是小的多的多!

　　而且即使你有幸写出这样的代码，对系统没有什么大的影响。

　　杞人忧天的情况

　　1.无话可说型

Object obj=new Object();
obj=null;
//这个完全多此一举,因为退出了作用范围，对象的引用自动消失
//不要在你的程序中出现这样的语句，没有错，但是就是不雅观

　　2.思考不对型

void func(Object o){
　o=new Object();
　return
}

　　当我们知道Java参数是传值，就知道上面的方法什么也没错，就是申请了一个对象然后再丢给GC。因为是传值，这里的o是一个调用时候的拷贝,会不会无法回收？不就是拷贝吗，退出方法什么都没了，这个对象怎么会留的住。

　　3.尽量避免型

class A{
　B b=new B(this);
}
class B{
　A a;
　B(A a){this.a=a;}
}

　　这个存在互相引用，可能导致孤岛现象，但是这个不会造成内存泄露不过我自己觉得这个会降低GC的效率，就从我的智力来看，我觉得这种情况比一般情况难以判断怎么回收!当然GC比我聪明，不过应该也要动一点脑子吧。

譬如

JMyClass myclassArr[1000000] = null;

String s = 键盘输入一个数字
count = s.StringToInt();///count保存JMyClass对象的总数，

for (i = 0 ; i < 100000; i ++ )
{
   myclassArr[i] = new JMyClass ();
}


...

后来一个不小心count = 100; ////被误写了，

好了，你100以后的JMyClass再也不用到了，但是他们也不会被回收。

就是内存泄露了嘛。