Array declaration trick : Is it bad to use it?

Question

I am declaring this class, that doesn't to be useful.

public class ArrayTrick {

    public static char[] arr(char... arr) {
        return arr;
    }

    public static float[] arr(float... arr) {
        return arr;
    }

    public static double[] arr(double... arr) {
        return arr;
    }

    public static long[] arr(long... arr) {
        return arr;
    }

    public static int[] arr(int... arr) {
        return arr;
    }

    public static short[] arr(short... arr) {
        return arr;
    }

    public static byte[] arr(byte... arr) {
        return arr;
    }

    public static boolean[] arr(boolean... arr) {
        return arr;
    }

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

}

which allows me (once I have a static import in my code) to declare arrays like this:

int[][] arr = arr(
   arr(1, 2, 1),
   arr(2, 1, 3),
   arr(3, 3, 3));

personally I find it useful and the few people I work with understand it.

It comes from the fact that I got frustrated by java array declaration after working in python, and I sometime work with keyboards where the curly brackets are hard to find (Italian standard on my old laptop).

What I want to know is : Is there anything bad about working like that? Is it readable enough in your opinion? How come this trick is not famous?

Answer 1

Not much different from

int[][] arr = {{1, 2, 1},
               {2, 1, 3},
               {3, 3, 3}};

Also, I don't think you can run away from curly brackets in java :)

Answer 2

It's readable enough, but it's not famous or used often because it's so much easier to declare and initialize on the same line using:

int[][] arr = {
        {1,2,1},
        {2,1,3},
        {3,3,3}};

Answer 3

The trick's not famous because you really don't need it with the curly bracket notation. Is it really a help to avoid those curly brackets? In C-related languages, I think there's no avoiding them.

Array initialization:

int[][] arr = {
    {1, 2, 1},
    {2, 1, 3},
    {3, 3, 3}
};

Your version is readable enough, but since I know the language supports this, I'd wonder if the function would do anything more.

Answer 4

Is that necessary?, what about:

    String[][] arr = {{"2","3","4"},
                     {"3","4","5"},
                     {"4","5","6"}};

Answer 5

The only time I used ArrayTrick type declarations is when I would want to use varargs in a situation where varargs cannot be declared in a method call. This is typically where a handler is used.

Example,using an example I deal with everyday, and using my library I have written, SQLExecutor, consider the following:

final String SQL_QUERY = "Select* from transaction where TRANSACTION_ID = ? AND TRANSACTION_TYPE >= ?";
final String DATABASE_CONNECTION_STRING = "";
final String USER_NAME = "";
final String PASSWORD = "";

Connection connection = null;
try {
    connection = DriverManager.getConnection(DATABASE_CONNECTION_STRING, USER_NAME, PASSWORD);
    SQLQueryExecutor executor = new BasicSQLQueryExecutor();
    executor.setConnection(connection); //ALWAYS pass a Connection.
    executor.setCloseConnection(false);

    Transaction transaction = executor.executeQuery(SQL, VarargsUtils.toArray(1294, "EFT"), new IterativeResultSetHandler<BigDecimal[]>() {

        /* (non-Javadoc)
        * @see za.co.sindi.sql.IterativeResultSetHandler#handle(za.co.sindi.sql.ResultSetIterator)
        */
        @Override
        public BigDecimal[] handle(ResultSetIterator iterator) throws SQLException {
        // TODO Auto-generated method stub
            Transaction transaction = new Transaction();
            while (iterator.hasNext()) {
                Map<Object, Object> attributes = iterator.next();
                transaction.setTransactionId(attributes.get("TRANSACTION_ID"));
                transaction.setTransactionType(attributes.get("TRANSACTION_TYPE"));
            }

            return transaction;
        }
    });
} catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} catch (DatabaseExecutionException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
} finally {
    try {
        SQLUtils.close(connection);
    } catch (SQLException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

The IterativeResultSetHandler is a handler that gets called after a query execution.

Now, I wanted to pass as many attributes as possible, and since varargs can only be the last argument in a method call, I created VarargsUtils to do just like your ArrayTricks class.

Answer 6

It's good, it ought to be in the standard lib. You probably should spell out "array" in full though.

I see 3 use cases for it

//1
  for(String s : array("a", "b", "c")) ...

//2
  someMethod( array(1,2), array("a", "b") );

//3
  List<String> list1 = ..., list2 = ...;
  List<String>[] lists = array( list1, list2 );
  // generic array creation and initialization