There are (at least) 3 ways. For the sake of example code, I’ve assumed you want to call 2 consumer methods methodA and methodB: A. Use peek(): list.stream().peek(x -> methodA(x)).forEach(x -> methodB(x)); Although the docs say only use it for “debug”, it works (and it’s in production right now) B. Use map() to call methodA, … Read more
Basically, you want to concatenate all the nested streams into one flat stream, without affecting the members themselves. You’ll use objectStreams.flatMap(Function.identity()); because you must provide some mapping function for each stream member, and in this case it is the identity function.
It’s impossible to partition the arbitrary source stream to the fixed size batches, because this will screw up the parallel processing. When processing in parallel you may not know how many elements in the first sub-task after the split, so you cannot create the partitions for the next sub-task until the first is fully processed. … Read more
Use flatMap: return map.values().stream().flatMap(Set::stream).collect(Collectors.toSet()); The flatMap flattens all of your sets into single stream.
Just put the condition into the lambda itself, e.g. animalMap.entrySet().stream() .forEach( pair -> { if (pair.getValue() != null) { myMap.put(pair.getKey(), pair.getValue()); } else { myList.add(pair.getKey()); } } ); Of course, this assumes that both collections (myMap and myList) are declared and initialized prior to the above piece of code. Update: using Map.forEach makes the code … Read more
You can do it like this: set.removeIf(item -> { if (!item.qualify()) return false; item.operate(); return true; }); If item.operate() always returns true you can do it very succinctly. set.removeIf(item -> item.qualify() && item.operate()); However, I don’t like these approaches as it is not immediately clear what is going on. Personally, I would continue to use … Read more
You say you want to sort by value, but you don’t have that in your code. Pass a lambda (or method reference) to sorted to tell it how you want to sort. And you want to get the keys; use map to transform entries to keys. List<Type> types = countByType.entrySet().stream() .sorted(Comparator.comparing(Map.Entry::getValue)) .map(Map.Entry::getKey) .collect(Collectors.toList());
There’s a reason why most examples avoid storing the result into a Collection. It’s not the recommended way of programming. You already have a Collection, the one providing the source data and collections are of no use on its own. You want to perform certain operations on it so the ideal case is to perform … Read more
You can use an IntStream to generate the indices followed by mapToObj: char[] arr = {‘a’,’c’,’e’}; Stream<Character> cStream = IntStream.range(0, arr.length).mapToObj(i -> arr[i]);
I want to share the solution I found because at first I expected to use map-and-reduce methods, but it was a bit different. Map<String,Long> collect = wordsList.stream() .collect( Collectors.groupingBy( Function.identity(), Collectors.counting() )); Or for Integer values: Map<String,Integer> collect = wordsList.stream() .collect( Collectors.groupingBy( Function.identity(), Collectors.summingInt(e -> 1) )); EDIT I add how to sort the map … Read more