Trucchi linguistici per abbreviare il mio codice Java?

Question

Attualmente sto riscoprendo Java (lavorando molto con Ruby di recente) e adoro il controllo in tempo reale di tutto. Rende il refactoring così facile. Tuttavia, mi manca giocare veloce e loose con i tipi per fare un ciclo each. Questo è il mio peggior codice.

È il più breve possibile? Ho una raccolta chiamata looperTracks, che ha istanze che implementano Looper. Non voglio modificare quella raccolta, ma voglio scorrere i suoi membri PIÙ il this (che implementa anche Looper).

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks.length + 1); 
for (LooperTrack track : looperTracks) { 
    allLoopers.add(track); 
} 
allLoopers.add(this); 

for (Looper looper : allLoopers) { 
    // Finally! I have a looper 

Sono particolarmente preoccupato per tutte le funzioni che sono nuovi per Java 1.5 su quel forse ho perso. Per questa domanda sono non chiedendo di JRuby e Groovy, anche se so che avrebbero lavorato per questo.

Edit: (! Troppo Ruby) Siamo spiacenti ... looperTracks è di tipo LooperTrack[] e LooperTrack implementa Looper.

Answer 1

Ci sono almeno due possibili incorporato modi per abbreviare il tuo codice:

si potrebbe usare Collection.addAll(Collection) che aggiunge ogni elemento della collezione passata come parametro al fine della raccolta .:

List<Looper> allLoopers = new ArrayList<Looper>(); 

... 

allLoopers.addAll(looperTracks); 
allLoopers.add(this); 

for(Looper looper : allLoopers) { 
    ... 
} 

oppure è possibile utilizzare un costruttore che prende una raccolta come parametro:

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks); 

a causa del cambiamento di domanda: Tutti gli array può EA sily essere convertito in raccolte usando java.util.Arrays ad es.

List<Looper> someLooperTracks = Arrays.asList(looperTracks). 

Questo sarà avvolgere la matrice in un elenco dimensione fissa.

Answer 2

Si potrebbe almeno utilizzare il fatto che è possibile costruire una raccolta utilizzando un altro come valori di base. In base allo docs:

Costruisce una lista contenente gli elementi della raccolta specificata, nell'ordine in cui vengono restituiti dall'iteratore della raccolta. L'istanza ArrayList ha una capacità iniziale del 110% della dimensione della raccolta specificata.

Ciò significa che probabilmente ci sarà spazio per this senza dover ridimensionare.

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks); 
allLoopers.add(this); 

for (Looper looper : allLoopers) { 
    // Finally! I have a looper 

Answer 3

Perché non è possibile aggiungerli tutti come parte della chiamata del costruttore?

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks); 

allLoopers.add(this); 

for(Looper looper : allLoopers) { 
... 
} 

Answer 4

A seconda di battitura, è possibile utilizzare:

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks); 
allLoopers.add(this); 

o:

List<Looper> allLoopers = new ArrayList<Looper>(looperTracks.length + 1); 
allLoopers.addAll(looperTracks); 
allLoopers.add(this); 

Answer 5

non credo che si può rendere più breve di questo ...

for (Looper looper : new ArrayList<Looper>(looperTracks){{ add(EnclosingClass.this); }}) { 
    // Finally! I have all loopers 
} 

Answer 6

Puoi provare ad usare un immutable list usando t lui metodo nCopies(). Citando il riferimento API,

public static <T> List<T> nCopies(int n, T o)

restituisce un elenco immutabile costituito di n copie dell'oggetto specificato. L'oggetto dati appena assegnato è minuscolo (contiene un riferimento singolo all'oggetto dati). Questo metodo è utile in combinazione con il metodo List.addAll per generare elenchi. L'elenco restituito è serializzabile.

questo eviterà la prima foreach iterazione.

Answer 7

Nel caso in cui non si desideri utilizzare Groovy o JRuby a causa della loro natura dinamica, è consigliabile utilizzare Scala. Scala è tipizzato staticamente ma più conciso di Java.

Answer 8

Ho appena implementato un Iterator di Iterable s (è implementato in un modo più robusto testato// recensito da GuavaIterables.concat(Iterable...)):

// make a concatenation of iterables 
public static <T> Iterable<T> $(final Iterable<T> first, final Iterable<T>... iterables) { 
    List<Iterator<T>> allIterables = new LinkedList<Iterator<T>>(); 
    allIterables.add(first.iterator()); 

    for (Iterable<T> iterable : iterables) { 
     allIterables.add(iterable.iterator()); 
    } 

    final Iterator<Iterator<T>> iterators = allIterables.iterator(); 

    return new Iterable<T>() { 

     @Override 
     public Iterator<T> iterator() { 
      return new Iterator<T>() { 

       private Iterator<T> current = iterators.next(); 

       @Override 
       public boolean hasNext() { 
        if (current.hasNext()) { 
         return true; 
        } else { 
         if (iterators.hasNext()) { 
          current = iterators.next(); 
          return current.hasNext(); 
         } else { 
          return false; 
         } 
        } 
       } 

       @Override 
       public T next() { 
        return current.next(); 
       } 

       @Override 
       public void remove() { 
       } 
      }; 
     } 
    }; 
} 

usando il codice diventa:

for (Looper looper : $($(looperTracks), this)) { 

} 

nel caso in cui si cura l'implementazione è parte del mio Dollar library (rilesead come LGPL3).

Answer 9

È necessario assemblare tutto in un unico elenco? In caso contrario, cosa c'è di sbagliato in questo?

for (Looper looper : looperTracks) { 
    doSomething(looper); 
} 
doSomething(this); 

Answer 10

Prova

Looper[] loop = new Looper[looperTracks.length + 1]; 
System.arraycopy(looperTracks, 0, loop, 0, looperTracks.length); 
loop[looperTracks.length] = this; 
for (Looper l : loop) { ... } 

ma onestamente, perché non solo ciclo attraverso l'array esistente, e poi fare quello che vuoi a che fare con il ciclo per this dopo?

La List -version degli sguardi di cui sopra come:

List<Looper> loop = new ArrayList<Looper>(Arrays.asList(looperTracks)); 
loop.add(this); 
for (Looper l : loop) { ... } 

Answer 11

Guava rende questo abbastanza facile:

for (Looper looper : ObjectArrays.concat(looperTracks, this)) {} 

Here è la documentazione per il metodo ObjectArrays#concat.

Answer 12

Ho intenzione di lanciarlo, ma non provare a ridurre il codice a scapito di renderlo leggibile.

Il codice leggibile è sempre il mio obiettivo quando inizio a scrivere il codice, semplicemente perché so che a un certo punto del futuro o io o qualcun altro lo vedremo e lo capiremo.