Which is better, Stream or Iterator

Question

I was playing with Java * Stream API and I had Following code in the Lagecy system:

Iterator itr = configMap.entrySet().iterator();
        List<String> resultList = new ArrayList<String>();
        while(itr.hasNext()){
            Entry e = (Entry)itr.next();
            Config rc = (Config)e.getValue();

            if (rc != null && rc.getVisibleTo() != null && (rc.getVisibleTo().equalsIgnoreCase("0010") || rc.getVisibleTo().equalsIgnoreCase("0111") || rc.getVisibleTo().equalsIgnoreCase("0011"))){        
                resultList .add(rc.getName());
            }
        }

I wrote the Stream Equivalent of above code as below:

List<String> resultList = configMap.entrySet()
                   .parallelStream()
                   .map(r -> r.getValue())
                   .filter(r -> r.getVisibleTo() != null)
                   .filter(r -> {return 
                              r.getVisibleTo().equalsIgnoreCase("0010")
                           || r.getVisibleTo().equalsIgnoreCase("0111")
                           || r.getVisibleTo().equalsIgnoreCase("0011");
                        })
                   .map(r -> r.getName())
                   .collect(Collectors.toList());

Both the way I am getting the desired results. My question is which performance wise is better way of writing in this case? Am I actually gaining any value if I chose either one over another? The map has around 1000 values in it.

Answer 1

First of all, if performance is your concern, you should decide based on facts, so measure, don't guess (i.e. using JMH).

For simple cases, iteration or classic loops tend to be faster than Streams. On the other hand, streams can be much faster, and can often be further accelerated by parallelism (where the workload is easily parallelizable). In most cases it doesn't really matter (in my experience) as either the dataset is too small and/or the code where it's used is not performance cricital enough.

Regarding readability/maintainabilty I tend to prefer the stream/functional approach for better separation of concerns. But a for-each loop might improve your iterative code as well. So there is no simple yes/no answer, it all depends on the context.

Answer 2

Since you wrote this as a parallel stream, which attempts to multi thread and divide the work, you are likely to see some performance degradation from overhead managing the threads, given that your job is a bit small. Another trap here is that since you are using the CommonForkJoinPool (the default thread pool for this), this is not a great choice as blocking that up with tasks can degrade performance for the entire app (which, while not terribly relevant for the small size of your job, is a thing to keep in mind).

That being said, were you to use the single-threaded configMap.entrySet().stream() instead, I would say the performance difference might be very slightly slower, but the readability more than makes up for it. So the choice becomes a decision between slightly faster code or better readability, which is entirely up to you (but I'd pick the stream, personally).

Answer 3

I would just slightly rewrite sream example:

List<String> resultList = configMap.entrySet()
        .parallelStream()
        .map(Map.Entry::getValue)
        .filter(Objects::nonNull) // value might be a null
        .filter(r ->
                ((Predicate<String>) "0010"::equals)
                        .or("0111"::equals) // null-save equivalent to  "0111".equals(value)
                        .or("0011"::equals)
                        .test(r.getVisibleTo())
        )
        .map(Config::getName)
        .collect(Collectors.toList());

and will use it. For detailed performance explanation please see these question Java 8: performance of Streams vs Collections and Iterator versus Stream of Java 8

as suggested in comments below by @4castle, we can make it even shorter by using configMap.values() instead of configMap.entrySet() :

List<String> resultList = configMap.values()
        .parallelStream()
        .filter(Objects::nonNull)
        .filter(r ->
                ((Predicate<String>) "0010"::equals)
                        .or("0111"::equals) // null-save equivalent to  "0111".equals(value)
                        .or("0011"::equals)
                        .test(r.getVisibleTo())
        )
        .map(Config::getName)
        .collect(Collectors.toList());