java-stream

My function finds if from a list of given words at list one word is valid in the page. So when page contains words I have written it as follows: (Simplified version) private boolean atLeastOneWordIsValidInThePage(Page page, Set<Long> wordIdsToCheck) Set<Long> wordIds = page.getWords().stream() .filter(word -> word.isValid()) .map(word->getWordId()) .collect(Collectors.toSet()); return words.stream().anyMatch((o) -> wordIds.contains(o)); Is it the best java 8 practice to write it? I want to stop searching when the first match is found. There is no need to open two separate streams. You should

I want to group a List of Objects containing a time attribute into 5-Minute intervals, preferably using streams and collectors. The only possible solution I found on StackOverflow is to calculate how many intervals (sublists) I need, add every object to every one of these Lists and filter out the ones that dont fit into the respective timeframe, which is not exactly a nice solution. (You can find the Thread here: How to group elements of a List by elements of another in Java 8 ) I thought of something similar to this: List<MyObject> list = new ArrayList<MyObject>(); ....... List<List<MyObject>

I read this problem in Richard Bird's book: Find the top five most common words in War and Peace (or any other text for that matter). Here's my current attempt: public class WarAndPeace { public static void main(String[] args) throws Exception { Map<String, Integer> wc = Files.lines(Paths.get("/tmp", "/war-and-peace.txt")) .map(line -> line.replaceAll("\\p{Punct}", "")) .flatMap(line -> Arrays.stream(line.split("\\s+"))) .filter(word -> word.matches("\\w+")) .map(s -> s.toLowerCase()) .filter(s -> s.length() >= 2) .collect(Collectors.toConcurrentMap( w -> w, w -> 1, Integer::sum)); wc.entrySet

I have the following sample code: System.out.println( "Result: " + Stream.of(1, 2, 3) .filter(i -> { System.out.println(i); return true; }) .findFirst() .get() ); System.out.println("-----------"); System.out.println( "Result: " + Stream.of(1, 2, 3) .flatMap(i -> Stream.of(i - 1, i, i + 1)) .flatMap(i -> Stream.of(i - 1, i, i + 1)) .filter(i -> { System.out.println(i); return true; }) .findFirst() .get() ); The output is as follows: 1 Result: 1 ----------- -1 0 1 0 1 2 1 2 3 Result: -1 From here I see that in first case stream really behaves lazily - we use findFirst() so once we have first

I do have a simialar problem like descripted here . But with two differences first I do use the stream api and second I do have an equals() and hashCode() method already. But within the stream the equalitity of the of Blogs are in this context not the same as defined in the Blog class. Collection<Blog> elements = x.stream() ... // a lot of filter and map stuff .peek(p -> sysout(p)) // a stream of Blog .? // how to remove duplicates - .distinct() doesn't work I do have a class with an equal Method lets call it ContextBlogEqual with the method public boolean equal(Blog a, Blog b); Is there any

Suppose I have a collection of the unknown type. What I want to do is stream it, do some stuff on the stream, and collect it back into the same collection type as my original collection. For instance: Collection<? extends Integer> getBigger(Collection<? extends Integer> col, int value) { return col.stream().filter(v -> v > value).collect(????); } The idea of this incomplete code example is to return a List if col is of List class (or any subclass of it), a Set if col is of Set class, etc... The method name and actual operations on the stream here are not important, I've specified them just to