To retrieve a String consisting of all the ID’s separated by the delimiter “,” you first have to map the Person ID’s into a new stream which you can then apply Collectors.joining on. String result = personList.stream().map(Person::getId) .collect(Collectors.joining(“,”)); if your ID field is not a String but rather an int or some other primitive numeric … Read more
You can do it like this, Optional<Preset> optional = Arrays.stream(presets) .filter(x -> “MyString”.equals(x.getName())) .findFirst(); if(optional.isPresent()) {//Check whether optional has element you are looking for Preset p = optional.get();//get it from optional } You can read more about Optional here.
You need to collect your Stream into a List: List<String> adresses = users.stream() .map(User::getAdress) .collect(Collectors.toList()); For more information on the different Collectors visit the documentation. User::getAdress is just another form of writing (User user) -> user.getAdress() which could as well be written as user -> user.getAdress() (because the type User will be inferred by the … Read more
I agree with Stuart Marks that list == null ? Stream.empty() : list.stream() is the right way to do this (see his answer), or at least the right way to do this pre-Java 9 (see edit below), but I’ll leave this answer up to demonstrate usage of the Optional API. <T> Stream<T> getStream(List<T> list) { … Read more
Don’t worry about any performance differences, they’re going to be minimal in this case normally. Method 2 is preferable because it doesn’t require mutating a collection that exists outside the lambda expression. it’s more readable because the different steps that are performed in the collection pipeline are written sequentially: first a filter operation, then a … Read more
Since there are only 4 elements that pass the filter, limit(10) never reaches 10 elements, so the Stream pipeline keeps generating new elements and feeding them to the filter, trying to reach 10 elements that pass the filter, but since only the first 4 elements pass the filter, the processing never ends (at least until … Read more
You can do this with Stream: Map<String, Object> result = resources.entrySet() .stream() .filter(e -> keys.contains(e.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (x, y) -> y, LinkedHashMap::new)); The part (x, y) -> y is because of mergeFunction when find duplicate keys, it returns value of second key which found. the forth part is mapFactory which a supplier providing a new … Read more
You can use a Collector like this to put the result into a LinkedList: LinkedList<String> usernames2 = users.stream() .map(User::getUsername) .collect(Collectors.toCollection(LinkedList::new));
Map<Boolean, List<Integer>> results= List1.stream().collect(Collectors.partitioningBy( n -> n < 0)); I think that this one is prettier and easy to read. (You can then get the negative and non-negative list from the map.)
Either is fine. Pick the one that seems more readable to you. If the calculation naturally decomposes, as this one does, then the multiple maps is probably more readable. Some calculations won’t naturally decompose, in which case you’re stuck at the former. In neither case should you be worrying that one is significantly more performant … Read more