tags:

views:

380

answers:

5

for example we can construct such a this array like==>

new elementType[0];

I have read this such a construct but I didn't get the whole such the usage of these arrays!!! :(

+5  A: 

Check this link.

rahul
does this hold true for both C++ and Java?
Nippysaurus
The first link is irrelevant for Java.
Igor Krivokon
Edited my post.
rahul
link shows how to return empty arrays instead of null.
Thorbjørn Ravn Andersen
A: 

You need to clarify your question. Please provide more context.

The declaration of an array does not actually create an array — it simply tells the compiler that this variable will hold an array of the specified type.

Amir Afghani
The question is perfectly clear. The expression "new elementType[0]" does in fact create an array and is not a variable declaration.
bendin
+7  A: 

It's easier to work with than null in many cases, where null is the obvious alternative.

Suppose you want to return an Iterable<String> containing (say) a list of relevant filenames... but there aren't any for some reason. You could return null to indicate that, but then the caller has to special-case that. Instead, if you return an empty collection, the caller can still use an enhanced for loop:

for (String file : getFiles())

So why use an empty array instead of an empty ArrayList or something similar? Arrays are a fixed size, so an empty array is effectively immutable. That means you can keep a single value and return it to whoever you like, knowing they can't possibly do anything with it. That can be very useful in some situations.

Jon Skeet
+18  A: 

An example. Say, you have a function

public String[] getFileNames(String criteria) {

to get some filenames. Imagine that you don't find any filenames satisfying criteria. What do you return? You have 2 choices - either return null, or 0-sized array. The variant with 0-sized array is better, because your caller doesn't need to check for NULL and can process the array in a consistent way - say, in a loop (which would be empty in this case).

There's a chapter on this in Effective Java, Item 27

Igor Krivokon
+1  A: 

it is a replacement for null since you don't need to check for null before use it. More formally it is a special case of special case design pattern (check also Null Object).

Another idiomatic use is collections toArray:

List<String> list = new ... ;
// fill the list
String[] array = list.toArray(new String[0]);
dfa