Is it bad practice to assign a new array to an existing array to 'clear' the array in Java?

Question

So I'm currently working on a program that needs to be able to deal with a large amount of data stored in arrays and it needs a method to clear out everything in the array. For the below example, would this be a bad thing to do memory wise? I know the garbage collector would eventually clean it up for you but is there a reason why another method (e.g. a for loop and setting each value within to null) might be better than this?

Object[] objArray = new Object[n];
/*Do some stuff with objArray*/
objArray = new Object[n]

Otherwise, doing this will allow this operation to run in O(1) time vs a for loop which would take O(n).

Answer 1

It is bad practice.

Firstly, assigning a new array to the variable doesn’t actually “clear” anything out (more on this below).

This is best practice:

objArray = null;

which makes the original array unreachable and therefore it will be (eventually) garbage collected.

It also avoids an unnecessary allocation of memory creating the empty array you used to replace the old one.

However, neither option “clears” out the original array, which may pose an, albeit small, security exposure. Until garbage collected, the contents of the array may be divinable if the memory contents are dumped etc.

The truly clear the array:

Arrays.fill(objArray, null);

Answer 2

No, it is not bad practice. However, nulling all indices of the array will very likely be faster (technically, this is what is called an implementation detail; but feel free to benchmark this on your specific system), because the extra step of allocating new memory is not needed. However, be advised to not fall victim to what is known as premature optimization, as it can cause you to waste time if you later find you need to make large changes. Also, mind that since you will keep using the existing array object, any other parts of your code that reference it will then also see the changes to it.

Answer 3

Technically, it really shouldn't matter.

It is more about readability, and communication of intent.

You see, nowadays you strive to make your objects immutable. If things can't be changed, you avoid all sorts of multi threading issues. So updating a reference to point to a new array isn't exactly in line with that.

The other point worth mentioning: if you really want to clear arrays (at least for primitive types), you better iterate the array and reset all of its slot. ( obviously that is not possible for arrays of reference types )

Answer 4

It's totally fine, since you are using 'primitive' array, instead of any Collection. You may feel insecure about memory allocation from the previous array, but don't worry the GC will clean that up for you. But when using the Collections API, you rather call:

yourCollection.clear()

Answer 5

Another approach, as used by ByteBuffer, is to keep the original array, leave its contents alone, and overwrite from the beginning. When using the array, use the index of the last element updated to avoid the remainder of the array. "Clearing" the array doesn't really gain anything, unless whatever is processing the array is looking for some specific value to indicate the end of content.

Answer 6

Typical Java users should not worry about memory management unless security or performance are explicit bottlenecks. See related questions.

If you actually need to have a way to "erase" the array for your logic (i.e mark the array as reset), and since you intend on reusing the array later, you can

• use a boolean to mark the array as "unusable" until it has been filled again (better solution if the objects inside the array do not consume too much memory)

• fill it with null rather than assigning null to it to avoid multiple array allocations (especially if n is large) in the long run: Arrays.fill(objArray, null);.