For 3 and more arguments you could use curried(http://en.wikipedia.org/wiki/Currying) functions with last consumer: Function<Double, Function<Integer, Consumer<String>>> f = d -> i -> s -> { System.out.println(“” + d+ “;” + i+ “;” + s); }; f.apply(1.0).apply(2).accept(“s”); Output is: 1.0;2;s It’s enough to have a function of one argument to express function of any number of … Read more
It’s not clear why you have a List<DataCarName> in first place instead of a List/Set<String>. The predicate you have to provide must check if for the corresponding data car instance, there’s its name in the list. e -> e.getName().contains(“BMW”) will only check if the name of the data car contains BMW which is not what … Read more
map.entrySet().removeIf(entry -> entry.getValue().equals(“0”)); You can’t do it with streams, but you can do it with the other new methods. EDIT: even better: map.values().removeAll(Collections.singleton(“0”));
I guess (or at least it is an alternative) this way is more performant: public static IntStream baz(List<Integer> list) { return list.stream().mapToInt(Integer::intValue); } since the function Integer::intValue is fully compatible with ToIntFunction since it takes an Integer and it returns an int. No autoboxing is performed. I was also looking for an equivalent of Function::identity, … Read more
Yes, you can expect this even if you are using parallel stream as long as you did not explicitly convert it into unordered() mode. The ordering never changes in sequential mode, but may change in parallel mode. The stream becomes unordered either: If you explicitly turn it into unordered mode via unordered() call If the … Read more
The pramodh’s answer is good if you want to map your value to 1. But in case you don’t want to always map to a constant, the use of the “merge-function” might help: Map<Integer, Integer> map1 = Files.lines(Paths.get(inputFile)) .map(line::trim()) .map(Integer::valueOf) .collect(Collectors.toMap(x -> x, x -> 1, (x1, x2) -> x1)); The above code is almost … Read more
It means that the filter is only applied during the terminal operation. Think of something like this: public Stream filter(Predicate p) { this.filter = p; // just store it, don’t apply it yet return this; // in reality: return a new stream } public List collect() { for (Object o : stream) { if (filter.test(o)) … Read more
You will see this cool pattern. The Stream classes includes a IntStream, LongStream, DoubleStream etc. This is so that you can use primitive types in stream operations. Because otherwise you have to use Stream<Integer> or Stream<Double>, which will box the values. Similarly, the map methods also do this. In the Stream<T> class, there are mapToInt, … Read more
Streams API actually has first-class support for your requirement: setOfE.parallelStream().anyMatch(e -> eval(e)); As opposed to your approach with reduce, this is guaranteed to have short-circuit evaluation and optimally leverage parallelism.
What you want is Comparator#comparing: userMap.values().stream() .sorted(Comparator.comparing(User::getName, UserNameComparator.INSTANCE)) .collect(Collectors.toList()); For the second part of your question, you would just use Comparator.comparing( u->u.getProfile().getUsername(), UserNameComparator.INSTANCE )