Best way to create singleton array

What is the "easiest" way for you to create a singleton (with exactly one element) Objects array in Java ?

Solution 1:

Object [] singleton = { new SomeObject() };

Solution 2:

The standard way is this:

String[] arr = new String[]{"I am the one and only"};

I'm afraid it doesn't get much simpler than this.

Edit: it does:

String[] arr = {"I am the one and only"};

Thanks aioobe, I keep forgetting this.

Of course if you often create array you can create a helper method that makes things a bit simpler:

public static <T> T[] asArray(T... items){
    return items;
}

String[] arr = asArray("I am the one and only");

(But you can't enforce at compile time that it will be an array with only one element)

Next I was going to write a singleton array method, but Stephen beat me to that.

Solution 3:

If your project is already using Apache Commons lib, you can stick to ArrayUtils.toArray() method.

String[] arr = ArrayUtils.toArray("The string");
// or if using static import
String[] arr = toArray("The string");

Even if using static import it is still more verbose than the accepted answer:

String[] arr = {"The string"};

But it comes very handy when compact array initializer syntax is not allowed.

Some examples:

someMethod(toArray("The string"), /* other params */);

return toArray("The string");

@DataProvider
public Object[][] someDataProvider() {
    return rangeClosed(-12, +12)
        .map(HOURS::toMillis).boxed()
        .map(ArrayUtils::toArray)
        .toArray(Object[][]::new);
}

You can imagine any other examples yourself.

Also note, that the ArrayUtils.toArray() can wrap an arbitrary number of objects into array, not only a single one.

Solution 4:

enum solution(anti reflect attack):

enum MySingleton{
    INSTANCE(new String[]{"a","b"});

    final String[] values;

    private MySingleton(String[] values) {
        this.values = values;
    }
}

reference it as:

MySingleton.INSTANCE;

Solution 5:

This should do the job

public SomeType[] makeSingletonArray(SomeType elem) {
    return new SomeType[]{elem};
}

A generic version of this method would be somewhat awkward to use, since you would need to pass it a Class object as an additional parameter.

Inlining the SomeType[]{elem} expression is simpler, and that's how I'd normally do this.