Just Learn Code

Simplify Your Java Code with Lambda Expressions and Arrow Operators

Java is a programming language that has a lot of popularity and relevance. When developers work with Java, they look for different ways to make their code more efficient and readable.

That’s where lambda expressions come in, and with them, the arrow operator. In this article, we’ll start by explaining what lambda expressions and arrow operators are, what they offer in comparison to anonymous classes, and how to use them in different situations.

Lambda Expression and Arrow Operator

Lambda expressions were introduced in Java 8 and are intended to make code more concise and easier to read. They are anonymous functions that can be treated as objects and passed as arguments to other methods.

These expressions are especially useful when you need to use a method for a single purpose, instead of defining an entire class for that functionality. The arrow operator, also known as the lambda arrow, is what separates the parameters and the body of the lambda expression.

It’s a simple “->” symbol that separates the arguments to the left and the expression to the right. Together, lambda expressions and arrow operators allow developers to create more succinct and readable code.

Comparison with Anonymous Class

Anonymous classes were the standard way of defining inline implementations in previous versions of Java. They are inner classes without a name that are defined within the body of another class or a method.

Developers use them as a quick alternative to defining a separate class for a single functionality. One of the main differences between lambda expressions and anonymous classes is the size of the code.

An anonymous class can quickly become bloated with boilerplate code, which can make it hard to read and maintain. Lambda expressions, on the other hand, are much shorter and concise.

They promote a more functional programming style, where code is treated as a set of functions that take inputs and produce outputs, without changing any state.

How to Use Arrow Operator in Java

Lambda expressions and arrow operators can be used in a variety of ways in Java. One of the main uses of lambda expressions is to provide concise implementation of functional interfaces.

A functional interface is an interface that has only one abstract method and is often used to define lambdas to operate on collections. A simple example of a functional interface is the Runnable, which accepts no parameters and has a void return type:


Runnable r = () -> System.out.println(“Hello, World!”);



The arrow operator separates the parameter list from the lambda body.

In this case, there are no parameters, so we use empty parentheses. In the lambda body, we use System.out.println() to print our message to the console.

Finally, we call the run() method on our Runnable object, executing the lambda. Another use case for arrow operators is to implement interfaces that have only one abstract method, like the Drawable interface:


interface Drawable {

void draw(int x, int y);


public class ArrowOperatorExample {

public void useDrawable() {

Drawable d1 = (x, y) -> System.out.println(“Drawing a shape at x=” + x + ” and y=” + y);

d1.draw(10, 10);




We define the Drawable interface, which has one abstract method, draw(x, y).

We then define a class ArrowOperatorExample, which has a method useDrawable(). In this method, we create an instance of the Drawable interface using a lambda expression that takes two integer arguments and prints a message to the console.

We finally call the draw() method on our Drawable object, passing in an x and y parameter.


Java offers a lot of options for developers to write concise and efficient code. Lambda expressions and arrow operators are popular ways of achieving this.

They allow developers to write inline functions and pass them around as arguments to other methods, making code much more readable and concise. We’ve seen how arrow operators can be used to define lambdas in functional interfaces and how they compare against anonymous classes.

We hope this article was informative, and that you learned something new about lambda expressions, arrow operators, and how to use them in Java.

Arrow Operator in Java Collections

Java collections are an essential part of the Java programming language. They are used for storing and manipulating groups of objects.

One of the most beneficial aspects of Java collections is that they are now able to utilize the lambda expressions and arrow operators features introduced in Java 8. In this section, we will discuss how to use the arrow operator in Java collections and the advantages of using lambda expressions.

Example of Filtering ArrayList Data using

Lambda Expression and Arrow Operator

Java collections provide a significant convenience for data manipulation, and ArrayList is one of the most versatile collections offered by Java. The Arrow operator can be utilized to filter data from an ArrayList.

The filter method is called on an ArrayList object, passing in a lambda expression that returns true if we want to keep an item or false if we want to discard it. Here’s an example:


import java.util.Arrays;

import java.util.ArrayList;

public class ArrowOperatorArrayListExample {

public static void main(String[] args) {

ArrayList names = new ArrayList<>(Arrays.asList(“Alice”, “Bob”, “Charlie”, “David”, “Eva”, “Frank”));


.filter(s -> s.startsWith(“A”) || s.startsWith(“D”))





In this example, we define an ArrayList object called names with six elements.

We then call the stream() method on the ArrayList object, which returns a Stream object to filter and iterate the elements. The filter() method is then called on the Stream object, with a lambda expression that returns true if an element starts with an A or a D.

The forEach() method is then called on the resulting stream, passing in a method reference to System.out.println. The output will be all the array elements that start with A or D.

Advantages of Using Lambda Expression over Non-Lambda Code

Using the arrow operator and lambda expression in Java collections makes code easier to maintain and results in faster execution. In the example above, we have seen how easy it is to use the filter() method with lambda expressions.

This method allows us to filter collections without the need for external iteration. If we did not use a lambda expression, we would need to write more code to iterate over the collection, compare each item, and then execute a statement.

This is not only a lot of extra code but could be more time-consuming as well. Lambda expressions result in less code, which in turn makes it easier to read, review, and debug.

With a concise code, there are fewer chances of introducing bugs, and it’s easier to identify and fix issues if they occur. Additionally, using lambda expressions can help reduce technical debt by making code more readable and maintainable.

Arrow Operator in Java Thread

Java threads are used to achieve parallelism and concurrency in Java. The Runnable interface is used to create threads in Java.

The interface is a single-method interface because it contains only one abstract method called run(). It can be useful to use lambda expressions while implementing the run() method.

In this section, we will see how we can use the arrow operator in Java threads to simplify such implementations. Example of Using

Lambda Expression and Arrow Operator to Implement Run Method of Runnable Interface

We can define the run() method of the Runnable interface using a lambda expression.

Since the Runnable interface has only one abstract method, we can use a lambda expression without needing to create a new class or inner class for its implementation. “`java

public class ArrowOperatorThreadExample {

public static void main(String[] args) {

Runnable r = () -> {

System.out.println(“I am a Runnable thread!”);


Thread thread = new Thread(r);





In this example, we define a Runnable variable r using lambda expressions.

We use the arrow operator to define the body of the run() method. The System.out.println() statement in the implementation of the run() method gets executed when the Thread object starts running.

We then create a new Thread object, passing it the runnable instance r, and execute the thread by calling its start() method.

Simplicity of Using Lambda Expression for Single Method Interfaces

Lambda expressions provide a clean and concise approach to implement single abstract method interfaces. By utilizing the arrow operator, we can define the implementation of a single abstract method much more quickly than with a traditional implementation.

Additionally, using a lambda expression takes up less space than defining an entire new class or inner class to achieve the same functionality. For example, the implementation of Runnable interface is often very simple, and the arrow operator simplifies it even further.

Using a lambda expression to define the implementation of the Runnable interface makes it easier to write, read, and maintain threads. In conclusion, Arrow operators and lambda expressions provide a simplified approach to writing code, allowing developers to make their code more efficient and more readable.

When used in Java Collections or Threads, it results in a simplified and more efficient approach. It’s recommended that developers follow best practices while using them, and at the same time, leverage the advantages they provide to make their code more concise and readable.

Lambda expressions and arrow operators are powerful features introduced in Java 8 that simplify code, improve readability, and increase efficiency. This article explored how they can be used in Java collections and threads to make data manipulation and thread implementation more concise and straightforward.

The arrow operator provides a clean separator between the parameter list and lambda body, and using lambda expressions instead of traditional implementations results in less code and fewer bugs. Overall, the article emphasizes the importance of utilizing these features in Java programming to make code more efficient and readable.

Popular Posts