Re: byte[] out = new byte[MAX_NUM];
moongeegee wrote:
I have java code as byte[] buf = new byte[MAX_NUM];
Should I free the byte[] after that? If I need to free the byte[], how
to free it.
I know C++, I need to do "delete [] byte", how about java?
It's normally not necessary. The array you allocated with "new" will be
freed (or more properly garbage collected) when all of its references
are no longer reachable. But there are some special applications where
you need to "free" some object to prevent it being held when no longer
needed. So:
buf = null;
will replace the reference "buf" with null, and the garbage collector
will clean up your object in a bit. That's it, you don't need to call
any special method.
Why would you do this? The common example is a stack. Imagine a stack
implemented as:
public class MyStack { // untested code...
Object[] stack = new Object[20];
int top;
public void push( Object o ) {
stack[top++] = o;
}
public Object pop() {
return stack[--top];
}
}
If you look carefully at the pop() method, you will notice that the
array "stack" still holds a reference to whatever object was just
returned. The reference was copied, and stack still has a copy. This
counts as a memory leak in Java, because you're holding objects when you
really don't need to. The usual fix goes something like this:
public Object pop() { // also untested
Object o = stack[--top];
stack[top] = null;
return o;
}
And now at least we aren't holding a reference when we don't need it
anymore.