Trucco di dichiarazione di array: è brutto usarlo?

Question

Dichiaro questa classe, che non è utile.

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; 
    } 

} 

che mi permette (una volta ho un'importazione statica nel mio codice) per dichiarare array come questo:

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

personalmente ritengo utile e le poche persone con cui lavoro capirlo.

Viene dal fatto che sono stato frustrato dalla dichiarazione di array java dopo aver lavorato in python, e a volte lavoro con le tastiere in cui le parentesi graffe sono difficili da trovare (lo standard italiano sul mio vecchio portatile).

Quello che voglio sapere è: c'è qualcosa di negativo nel lavorare così? È leggibile abbastanza secondo te? Come mai questo trucco non è famoso?

Answer 1

sono quelli necessari ?, che dire:

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

Answer 2

E 'leggibile abbastanza, ma non è noto o utilizzato spesso perché è molto più facile da dichiarare e inizializzare sulla stessa linea con:

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

Answer 3

non molto diverso da

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

Inoltre, non penso che tu possa scappare dalle parentesi graffe in java :)

Answer 4

Il trucco non è famoso perché davvero non ne hai bisogno con la notazione delle parentesi graffe. È davvero un aiuto evitare quelle parentesi graffe? Nei linguaggi correlati a C, penso che non li si possa evitare.

Array di inizializzazione:

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

La versione è leggibile abbastanza, ma dal momento che so che il linguaggio supporta questa, mi piacerebbe chiedo se la funzione farebbe di tutto di più.

Answer 5

L'unica volta che ho utilizzato le dichiarazioni di tipo ArrayTrick è quando vorrei utilizzare vararg in una situazione in cui non è possibile dichiarare vararg in una chiamata di metodo. Questo è in genere quando viene utilizzato un gestore.

esempio, utilizzando un esempio mi occupo di tutti i giorni, e con la mia libreria ho scritto, SQLExecutor, considerare quanto segue:

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(); 
    } 
} 

Il IterativeResultSetHandler è un gestore che viene chiamato dopo un'esecuzione della query.

Ora, volevo passare come molti attributi possibile, e dal momento che varargs può essere solo l'ultimo argomento in una chiamata di metodo, ho creato VarargsUtils di fare, proprio come la vostra classe ArrayTricks.

Answer 6

È buono, dovrebbe essere nella lib standard. Probabilmente dovresti definire "array" in ogni caso.

vedo 3 casi d'uso per esso

//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