Is it possible to replace a simple java for loop (with index) with java 8 stream

Question

I want to have failfast behavior for any unsuccessful response and if all go successful then I return the last successful response as shown in following code.

for(int i=0;i<input.size(); i++){
   Data data = service.getData(input.get(i));
   if(data.isSuccessful() && i==input.size()-1){
      return data;
   }else if(!data.isSuccessful()){
    return data;
    }else{
    return null;
  }
 }

I tried to replace above mention code with streams but not been able to do so far.Main issue is that I am not able to imitate i(index) variable behavior in java8 stream code.

resp = input.stream().map((input)->{service.getData()}).filter(
(resp)->{
     if(!resp.isSuccessful())
        return true; 
     else if(resp.isSuccessful() && last resp)//if somehow I figure out last element
        return true;
     else 
        return false;}).findFirst();

Look at your two variants. Letting aside that it doesn’t work, do you really have the feeling that the second one is an improvement over the `for` loop? — Holger, Jan 13 '16 at 09:34
The loop in the original code only process one element since every code path in the body of the loop returns a value. — Alexis C., Jan 13 '16 at 09:36
@Holger performance should be the criteria. But my intention was to migrate code to java8 — Bharat Bhagat, Jan 13 '16 at 09:46
@All sorry guys for lot of small mistakes. my real intention is plainly written in first line. — Bharat Bhagat, Jan 13 '16 at 09:48
There is no reason why the stream variant should have a better performance than the for loop. — Holger, Jan 13 '16 at 09:49

score 9 · Accepted Answer · edited May 23 '17 at 12:13

There is no need for external libraries.

return IntStream.range(0, input.size())
.mapToObj(i -> {
    Data data = service.getData(input.get(i));
    if (!data.isSuccessful() || i == input.size() - 1) {
        return Optional.of(data);
    }
    return Optional.<Data>empty();
})
.filter(Optional::isPresent)
.findFirst()
.orElse(null);

More information about looping with indices: Is there a concise way to iterate over a stream with indices in Java 8?
Consider returing the Optional, rather than the result or null

Complete example (compilable):

import java.util.Optional;
import java.util.stream.IntStream;

class Data {
    public boolean isSuccessful() {return false;}
}
class Input {
    public Object get(int i) {return null;}
    public int size() {return 0;}
}
class Service {
    public Data getData(Object object) {return null;}
}
public class T {
    public static void main(String[] args) {method();}

    protected static Optional<Data> method() {
        Input input = new Input();
        Service service = new Service();

        return IntStream.range(0, input.size())
                .mapToObj(i -> {
                    Data data = service.getData(input.get(i));
                    if (!data.isSuccessful() || i == input.size() - 1) {
                        return Optional.of(data);
                    }
                    return Optional.<Data>empty();
                })
                .filter(Optional::isPresent)
                .findFirst()
                .orElse(null);
    }
}

That what I meant saying "pure Stream API solution would be much uglier". — Tagir Valeev, Jan 13 '16 at 11:49
Hmm, while this certainly answers the OP's question, I feel that from a subjective point of view this solution shouldn't be preferred over an imperative one, style-wise. — Lukas Eder, Jan 15 '16 at 10:13

score 4 · Answer 2 · answered Jan 13 '16 at 10:19

Seems that you actually want the following:

for (int i = 0; i < input.size(); i++) {
    Data data = service.getData(input.get(i));
    if (!data.isSuccessful() || i == input.size() - 1) {
        return data;
    }
}
return null;

The shortest lambda-based solution I can propose involves the jOOλ library:

return Seq.seq(input)
          .map(service::getData)
          .limitWhileClosed(Data::isSuccessful)
          .reduce((a, b) -> b)
          .orElse(null);

The essential part here is limitWhileClosed method which takes the input element while the condition holds, but also includes the first element which violates the condition. After that we use reduce((a, b) -> b) to get the last taken element.

The limitWhileClosed method is absent in Java-8 Stream API. Java-9 will add the takeWhile which is similar, but does not include the violating element. So the pure Stream API solution would be much uglier than plain for loop.

Thanks that will do. I will use jooq library. is it at all beneficial, performance wise to replace this for loop with stream api. — Bharat Bhagat, Jan 13 '16 at 11:03
@bharat9848, you will likely to lose some performance with jOOλ, though if your `server::getData` is expensive, then the performance loss would be relatively insignificant. — Tagir Valeev, Jan 13 '16 at 11:40

Is it possible to replace a simple java for loop (with index) with java 8 stream

2 Answers2