What use is a method that just returns its input? Surprisingly useful. A surprising use is as a way to convert between types.<\/p>\n
There’s a well known trick that’s often used to work around Java’s terrible array literals that you may have come across. If you have a method that takes an array as an argument<\/p>\n
\r\npublic static void foo(String[] anArray) { }\r\n<\/pre>\nInvoking foo requires the ugly<\/p>\n
\r\nfoo(new String[]{\"hello\", \"world\"});\r\n<\/pre>\nFor some reason Java requires the redundant “new String[]” here, even though it can be trivially inferred. Fortunately we can work around this with the following method which at first glance might seem pointless.<\/p>\n
\r\npublic static T[] array(T... input) {\r\n return input;\r\n}\r\n<\/pre>\nIt just returns the input. However it is accepting an array of Type T in the form of a varargs, and returning that array. It becomes useful due as now Java will infer the types and create the array cleanly. We can now call foo like so.<\/p>\n
\r\nfoo(array(\"hello\", \"world\"));\r\n<\/pre>\nThat is a neat trick, but it really becomes useful in Java 8 thanks to structural typing of lambdas\/method references and implicit conversions between types. Here’s another example of a method that’s far more useful than it appears at first glance. It just accepts a function and returns the same function.<\/p>\n
\r\npublic static Function f(Function f) {\r\n return f;\r\n}\r\n<\/pre>\nThe reason it’s useful is we can pass it any structurally equivalent method reference and have it converted to a java.util.function.Function, which provides us some useful utility methods for function composition. <\/p>\n
Here’s an example. Let’s say we have a list of Libraries (Collection of Collection of Books)<\/p>\n
\r\ninterface Library {\r\n List books();\r\n static Library library(Book... books) {\r\n return () -> asList(books);\r\n }\r\n}\r\n\r\ninterface Book {\r\n String name();\r\n static Book book(String name) { return () -> name; }\r\n}\r\n\r\nList libraries = asList(\r\n library(book(\"The Hobbit\"), book(\"LoTR\")),\r\n library(book(\"Build Quality In\"), book(\"Lean Enterprise\"))\r\n);\r\n<\/pre>\nWe can now print out the book titles thusly<\/p>\n
\r\nlibraries.stream()\r\n .flatMap(library -> library.books().stream()) \/\/ Stream of libraries to stream of books.\r\n .map(Book::name) \/\/ Stream of names\r\n .forEach(System.out::println); \r\n<\/pre>\nBut that flatMap call is upsetting, everything else is using a method reference, not a lambda expression. I’d really like to write the following, but it won’t compile because flatMap requires a function that returns a Stream, rather than a function that returns a List.<\/p>\n
\r\nlibraries.stream()\r\n .flatMap(Library::books) \/\/ Compile Error, wrong return type.\r\n .map(Book::name) \r\n .forEach(System.out::println); \r\n<\/pre>\nHere’s where our method that returns its input comes in again. This compiles fine.<\/p>\n
\r\nlibraries.stream()\r\n .flatMap(f(Library::books).andThen(Collection::stream)) \r\n .map(Book::name) \r\n .forEach(System.out::println); \r\n \r\npublic static Function f(Function f) {\r\n return f;\r\n}\r\n<\/pre>\nThis works because Library::books is equivalent to a Function<Library, List<Book>>, so passing it to the f() method implicitly converts it to that type. java.util.function.Function provides an andThen method which returns a new function which composes the two functions. <\/p>\n
Now in this trivial example it’s actually longer to write this than the equivalent lambda, but it can be useful when combining more complex examples.<\/p>\n
We can do the same thing with other functional interfaces. For example to allow Predicate composition or negation.<\/p>\n
Here we have a handy isChild() method implemented for us on Person, but we really want the inverse – isAdult() check to pass to the serveAlcohol method. This sort of thing comes up all the time.<\/p>\n
\r\ninterface Person {\r\n boolean isChild();\r\n static Person child() { return () -> true; }\r\n static Person adult() { return () -> false; }\r\n}\r\n\r\npublic static void serveAlcohol(Person person, Predicate isAdult) {\r\n if (isAdult.test(person)) System.out.println(\"Serving alcohol\");\r\n}\r\n<\/pre>\nIf we want to reuse Person::isChild we can do the same trick. The p() method converts the method reference to a Predicate for us, and we can then easily negate it.<\/p>\n
\r\nserveAlcohol(adult(), p(Person::isChild).negate());\r\n\r\npublic static Predicate p(Predicate p) {\r\n return p;\r\n}\r\n<\/pre>\nHave you got any other good examples?<\/p>\n","protected":false},"excerpt":{"rendered":"