Sbircia il prossimo elemento in un flusso

Question

C'è un modo per sbirciare il prossimo elemento in un flusso? L'idea è passata da un flusso di un elenco di oggetti, in cui è necessario confrontare due oggetti seguenti (per semplificare alcune differenze, ma ciò non dovrebbe importare qui). Come un vecchio for ciclo sarebbe così:

List<Car> autobahn = getCars(); 
for (int i = 0; i < autobahn.size()-1; i++) { 
    if(autobahn.get(i).speed>autobahn.get(i+1).speed) 
     autobahn.get(i).honk(); 
} 

Il modo migliore per quanto flusso potrebbe essere:

autobahn.stream() 
      .limit(autobahn.size()-1) 
      .filter(car -> car.speed < autobahn.get(autobahn.indexOf(car)+1).speed) 
      .forEach(car -> car.honk()); 

Il principale problema di questa soluzione è il metodo indexOf, dal momento che ci potrebbe essere due volte la stessa auto sull'autostrada. Una soluzione migliore sarebbe un modo per sbirciare successivo (o quello prima) elemento (con una classe di aiutare, questo potrebbe essere ancora possibile, ma sembra orribile)

BoxedCar boxedCar = new BoxedCar(autobahn.get(0)); 
autobahn.stream() 
      .skip(1) 
      .filter(car -> boxedCar.setContent(car)) 
      .forEach(car -> car.winTheRace()); 

con helperclass

class BoxedCar { 

    Car content; 

    BoxedCar(Car content) { 
     this.content = content; 
    } 
    boolean setContent(Car content) { 
     double speed = this.content.speed; 
     this.content = content; 
     return content.speed > speed; 
    } 
} 

o per deviare il Stream<Car> in un tipo di Stream<(Car,Car)> con il secondo flusso in qualche modo creato dal primo (questo suona anche terribile e qui non ho idea, come questo sembrerebbe).

C'è un bel modo per farlo con i flussi, o siamo attaccati allo for -loop?

Answer 1

Attaccare con il ciclo for non sarebbe una cattiva idea. L'API Stream non è progettata per questo tipo di requisito. È possibile fare riferimento a that answer per ulteriori informazioni.

Tuttavia, un modo semplice per farlo utilizzando l'API Stream è quello di utilizzare un flusso sugli indici del proprio elenco, supponendo che si disponga dell'accesso casuale.

IntStream.range(0, autobahn.size() - 1) 
     .filter(i -> autobahn.get(i).speed > autobahn.get(i+1).speed) 
     .forEach(i -> autobahn.get(i).honk()); 

Si noti che questo altamente assomigliare il ciclo for.

Answer 2

cosa sull'utilizzo di un IntStream invece di un ciclo:

IntStream.range(0, autobahn.size() - 1) 
     .filter(i -> autobahn.get(i).speed < autobahn.get(i + 1).speed) 
     .forEach(i -> autobahn.get(i).honk()); 

Answer 3

Usando il mio libero StreamEx libreria:

StreamEx.of(autobahn) 
     .pairMap((car, nextCar) -> car.speed < nextCar.speed ? car : null) 
     .nonNull() 
     .forEach(Car::honk); 

Qui funzionamento non standard pairMap viene utilizzato, che può mappare la coppia adiacente di elementi al singolo elemento. Questo funziona per qualsiasi sorgente di streaming (non solo per l'elenco indicizzato ad accesso casuale) e può essere abbastanza ben bilanciata.