The Java Streams API is lovely, but there are a few operations that One repeats over and over again which could be easier.<\/p>\n
One example of this is Collecting to a List. <\/p>\n
\r\nList input = asList(\"foo\", \"bar\");\r\nList filtered = input\r\n .stream()\r\n .filter(s -> s.startsWith(\"f\"))\r\n .collect(Collectors.toList());\r\n<\/pre>\nThere are a few other annoyances too. For example I find myself using flatMap almost exclusively with methods that return a Collection not a Stream. Which means we have to do<\/p>\n
\r\nList result = input\r\n .stream()\r\n .flatMap(s -> Example.threeOf(s).stream())\r\n .collect(Collectors.toList());\r\n\r\n\/\/...\r\n\r\npublic static List threeOf(String input) {\r\n return asList(input, input, input);\r\n}\r\n<\/pre>\nIt would be nice to have a convenience method to allow us to use a method reference in this very common scenario<\/p>\n
\r\nList result = input\r\n .stream()\r\n .flatMap(Example::threeOf) \/\/ Won't compile, threeOf returns a collection, not a stream \r\n .collect(Collectors.toList());\r\n<\/pre>\nBenjamin Winterberg has written a good guide to getting intellij to generate these for us <\/a>. But we could extend the API ourselves.<\/p>\nExtending the Streams API is a little tricky as it is chainable, but it is possible. We can use the Forwarding Interface Pattern<\/a> to add methods to List, but we want to add a new method to Stream. <\/p>\nWhat we can end up with is <\/p>\n
\r\nEnhancedList input = () -> asList(\"foo\",\"bar\");\r\nList filtered = list\r\n .stream()\r\n .filter(s -> s.startsWith(\"f\"))\r\n .toList();\r\n\r\n<\/pre>\nTo do this we can first use the Forwarding Interface Pattern to create an enhanced Stream with our toList method. Starting with a ForwardingStrem<\/p>\n
\r\ninterface ForwardingStream extends Stream {\r\n\r\n Stream delegate();\r\n\r\n default Stream filter(Predicate predicate) {\r\n return delegate().filter(predicate);\r\n }\r\n \r\n \/\/ Other methods omitted for brevity\r\n \r\n}\r\n<\/pre>\nNow, since Stream provides a chainable api, with methods that return Streams – when we implement our EnhancedStream we need to change the subset of methods that return a Stream to return our EnhancedStream. <\/p>\n
\r\ninterface EnhancedStream extends ForwardingStream {\r\n\r\n default EnhancedStream filter(Predicate predicate) {\r\n return () -> ForwardingStream.super.filter(predicate);\r\n }\r\n \r\n \/\/ Other methods omitted for brevity\r\n\r\n}\r\n<\/pre>\nNote that the filter method already exists on Stream and ForwardingStream, but as Java supports covariant return types<\/a> we can override it and change the returntype to a more specific type (In this case from Stream to EnhancedStream).<\/p>\nYou may also notice the lambda returned from the filter() method. Since ForwardingStream is a single method interface with just a Stream delegate() method it is compatible with a lambda that supplies a delegate Stream. Equivalent to a Supplier. EnhancedStream extends ForwardingStream and doesn’t declare any additional abstract methods, so we can return lambdas from each method that needs to return a Stream, delegating to the ForwardingStream. The ForwardingStream.super.filter() syntax allows us to call the implementation already defined in ForwardingStream explicitly.<\/p>\nNow we can add our additional behaviour to the EnhancedStream. Let’s add the toList() method, and a new flatMapCollection<\/p>\n
\r\ninterface EnhancedStream extends ForwardingStream {\r\n default List toList() {\r\n return collect(Collectors.toList());\r\n }\r\n\r\n default EnhancedStream flatMapCollection(Function> mapper) {\r\n return flatMap(mapper.andThen(Collection::stream));\r\n }\r\n\r\n \/\/ Other methods omitted for brevity\r\n\r\n}\r\n<\/pre>\nFinally, we’ll need to hook up the Stream to our List. We can use the same technique of a forwarding interface which overrides a method and specifies a more specific return type.<\/p>\n
\r\n\r\ninterface EnhancedList extends ForwardingList {\r\n default EnhancedStream stream() {\r\n return () -> ForwardingList.super.stream();\r\n }\r\n}\r\n\r\ninterface ForwardingList extends List {\r\n List delegate();\r\n\r\n default int size() {\r\n return delegate().size();\r\n }\r\n \r\n \/\/ All the other methods omitted for brevity \r\n}\r\n<\/pre>\nSo now we can put it all together. EnhancedList is a single method interface so compatible with any existing List in our code, we just wrap it in a lambda, and then we can flatMapCollection() and toList(). The following prints “foo” three times.<\/p>\n
\r\nEnhancedList input = () -> asList(\"foo\", \"bar\");\r\nList result = input\r\n .stream()\r\n .flatMapCollection(Example::threeOf) \r\n .toList();\r\n \r\nresult.forEach(System.out::println);\r\n\r\n\/\/ ...\r\n\r\npublic static List threeOf(String input) {\r\n return asList(input, input, input);\r\n}\r\n<\/pre>\nHere’s the unabbreviated code.<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"The Java Streams API is lovely, but there are a few operations that One repeats over and over again which could be easier. One example of this is Collecting to a List. List input = asList(“foo”, “bar”); List filtered = input .stream() .filter(s -> s.startsWith(“f”)) .collect(Collectors.toList()); There are a few other annoyances too. For example… Read more »<\/a><\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[8],"tags":[],"yoast_head":"\n\n\n\n\n\n\n\n\n\n\n\n