JIYIK CN >

This tutorial explains ->the role of the arrow operator ( ) in Java and lists some sample code to understand the topic.

In Java 8, a new feature lambda expression was added, and the arrow operator appeared in Java to form lambda expressions. It separates the parameters from the expression body.

(parameters) -> {
  statements;
} // Lambda expression having arrow

Lambda expressions were introduced in Java 8 and can be used to replace anonymous classes in Java, making the code more concise and readable.

Below is an example of how we create anonymous classes in Java prior to Java 8.

Runnable r = new Runnable() {
  @Override
  public void run() {
    System.out.print("Run method");
  }
};

This is how we can achieve the above task using lambda expressions in Java 8.

Runnable r = () -> System.out.print("Run method");

Let's start with some examples to understand the use of lambda and arrow operators.

Use of Arrow Operator in Java

In this example, we have used the arrow operator to create a lambda expression that implements the method Drawableof the interface draw(). Refer to the following example.

interface Drawable {
  public void draw();
}
public class Main {
  public static void main(String[] args) {
    int width = 20;
    // arrow operator
    Drawable d2 = () -> {
      System.out.println("Drawing width:  " + width);
    };
    d2.draw();
  }
}

Output:

Drawing width:  20

Since lambda expressions are a super way to create concise code using a functional approach, we can use it in many ways in our Java code. Let's look at some examples where we can apply it.

Arrow operator in Java collections

In this example, we use lambda expression to filter ArrayList data. We have used stream API and filter() method to get the required result. You will notice that it is easier to create code using lambda than non-lambda code. Refer to the following example.

package javaexample;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;
class Product {
  int id;
  String name;
  float price;
  public Product(int id, String name, float price) {
    this.id = id;
    this.name = name;
    this.price = price;
  }
}
public class Main {
  public static void main(String[] args) {
    List<Product> list = new ArrayList<Product>();
    list.add(new Product(1, "Samsung S5", 17000));
    list.add(new Product(3, "Iphone 12", 100500));
    list.add(new Product(2, "Sony Xperia", 25000));

    // using arrow to filter data
    Stream<Product> filtered_data = list.stream().filter(p -> p.price > 17000);
    filtered_data.forEach(product -> System.out.println(product.name + ": " + product.price));
  }
}

Output:

Iphone 12: 100500.0
Sony Xperia: 25000.0

Arrow operator in Java threads

This is another use of lambda expression, where we use it to implement run()a method of the Runnable interface. Since Runnable is a single method interface, it is easy to use lambda expression. Refer to the following example.

package javaexample;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Stream;

public class Main {
  public static void main(String[] args) {
    // using arrow
    Runnable r = () -> {
      System.out.println("Thread is running...");
    };
    Thread t2 = new Thread(r);
    t2.start();
  }
}

Output:

Thread is running...