This post is about using lambda expressions in Java. Lambda expressions are functions without a name that are commonly used in the functional programming style, specially to do iterations and filtering of lists.<\/p>\n\n\n\n
The way to define a lambda expression type is to define an interface with a single abstract (not defined) method:<\/p>\n\n\n\n
public interface Predicate<T> {\n public boolean check(T object);\n}<\/code><\/pre>\n\n\n\nThen another method could call a lambda expression defining the previous type, such as code like this:<\/p>\n\n\n\n
public static filter(List<T> list, Predicate<T> fun) {\n List<T> result = new ArrayList<T>();\n for(T x : list) {\n if(fun.check(x)) result.add(x);\n }\n return result;\n}<\/code><\/pre>\n\n\n\nWhat’s now left is to define the code that will check our properties in the filter function and return the list containing those objects that match the predicate:<\/p>\n\n\n\n
List<String> data = List.of(\"hello\", \"world\", \"hi\");\nList<String> result = \n filter(data, (s) -> s[0] == 'h'));<\/code><\/pre>\n\n\n\nIn this code sample, a lambda expression is used to return a boolean value corresponding to true if the string starts with the letter “h”. The value returned is a list with the elements that match the condition passed as a lambda expression.<\/p>\n\n\n\n
Lambda functions can be expressions (Java code that evaluates to a value) or if wrapped by curly braces ({}) a sequence of statements or instructions that optionally return a value.<\/p>\n\n\n\n
Common functional interfaces<\/h3>\n\n\n\nPredicates<\/h4>\n\n\n\n
One commonly used functional interface is Predicate<T><\/code> which specifies in its interface a function boolean test(T t)<\/code>. We could have defined in our previous example the argument to the function filter<\/code> as a Predicate<\/code> instead of creating our own interface.<\/p>\n\n\n\nThe function filter<\/code> from the class java.util.stream.Stream<\/code> takes one Predicate<\/code> function as an argument, filtering out of the stream the elements that do not match the condition specified in it.<\/p>\n\n\n\nOther functions in Stream<\/code> that accept Predicate<\/code> arguments are:<\/p>\n\n\n\n\nallMatch<\/code>, which takes a Predicate<\/code> object and returns as a boolean whether all elements of a stream match the given predicate.<\/li>\n\n\n\nanyMatch<\/code>, which is similar to allMatch<\/code> but returns true if at least one element of the stream matches the predicate.<\/li>\n\n\n\nnoneMatch<\/code>, which returns true if no elements of the stream match the given predicate.<\/li>\n<\/ul>\n\n\n\nFunctions<\/h4>\n\n\n\n
The functional interface Function<T,R><\/code> specifies the interface for a lambda function that takes one argument of type T<\/code> and returns a value of type R<\/code>.<\/p>\n\n\n\nThe usual Stream<\/code> operator that accepts an object of type Function<\/code> is the map<\/code> operator, which applies the function to every element of the stream and gives as an output in the destination stream the return value of the Function<\/code>.<\/p>\n\n\n\nConsumers<\/h4>\n\n\n\n
The Consumer<T><\/code> functional interface defines a function that accepts one argument of type T<\/code> and returns nothing, or void<\/code>. This is used to process the stream with a function that normally has a side-effect, such as sending data to a database or a file, and wants not to pass any result to the stream, but instead “consumes” it or takes it out of the stream.<\/p>\n\n\n\nA Stream<\/code> function that would use a Consumer<\/code> interface is the method forEach<\/code>, which just calls the function for each element, consuming all elements of the stream. Another Stream<\/code> function taking a Consumer<\/code> argument would be peek<\/code>, which returns the stream intact to allow other operations, but executes the input function every time that an element of the stream is consumed.<\/p>\n\n\n\nManipulating collections with lambda functions and streams<\/h3>\n\n\n\n
The main class that implements functional methods such as map<\/code>, filter<\/code>, et c. is the class Stream<\/code>. One can use Stream<\/code> directly or instead convert one of the many types that extend or implement java.util.Collection<\/code>, such as LinkedList<\/code>, to a Stream<\/code> object.<\/p>\n\n\n\nTo do that, one would call the function stream()<\/code> of any list or object that subclassed the class java.util.Collection<\/code>. If needed, the final result of the operations could be converted back to a List<\/code> object by calling Stream<\/code>‘s function toList()<\/code>.<\/p>\n\n\n\nReferences<\/h3>\n\n\n\n\n- Lambda Expressions<\/a>, Java Reference.<\/li>\n\n\n\n
- java.util.function package<\/a>, Java 21 Reference.<\/li>\n\n\n\n
- java.util.Collection<\/a>, Java 21 Reference.<\/li>\n\n\n\n
- java.util.List class<\/a>, Java 21 Reference.<\/li>\n\n\n\n
- java.util.stream.Stream class<\/a>, Java 21 Reference.<\/li>\n<\/ul>\n\n\n\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
This post is about using lambda expressions in Java. Lambda expressions are functions without a name that are commonly used in the functional programming style, specially to do iterations and filtering of lists. The way to define a lambda expression type is to define an interface with a single abstract (not defined) method: Then another […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[7],"tags":[6,5,4],"class_list":["post-20","post","type-post","status-publish","format-standard","hentry","category-programming","tag-functional-programming","tag-java","tag-programming"],"_links":{"self":[{"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/posts\/20","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/comments?post=20"}],"version-history":[{"count":6,"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/posts\/20\/revisions"}],"predecessor-version":[{"id":63,"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/posts\/20\/revisions\/63"}],"wp:attachment":[{"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/media?parent=20"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/categories?post=20"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/mvmoure.com\/index.php\/wp-json\/wp\/v2\/tags?post=20"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}