Arrow Operator in Java

The arrow operator (->) in Java is explained in this article along with some sample code to help you grasp the concept.

The arrow operator, which is used to create lambda expressions, was introduced along with the addition of the lambda expression functionality in Java 8. It divides the expression body from the arguments.

To make Java code more understandable and concise, lambda expression, which was introduced by Java 8, can be employed in place for anonymous classes.

An illustration of how to build an anonymous class using Java prior to Java 8 is shown below.

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

And here's how we may carry out the aforementioned task in Java 8 utilizing a lambda expression.

To better grasp how to use the lambda and arrow operators, let's start with some examples.

How to use Arrow Operator in Java?

In this illustration, the draw() method of both the Drawable interface was implemented using a lambda expression and the arrow operator. See the illustration below.

M.java

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

Output:

We can utilize lambda expression in Java programming in a variety of ways because it's a great technique to write succinct code using a functional approach. Here are several instances where we can use it.

Array Operator in Java collection

In this illustration, we use a lambda expression to filter data from an ArrayList. To achieve the desired outcome, we used the filter() method and the stream API. You can see how much simpler lambda code is to write than non-lambda code. See the illustration below.

M1.java

package javaexample;
import java.util.ArrayList;  
import java.util.List;  
import java.util.stream.Stream;   
class P{  
    int id;  
    String n;  
    float pri;  
    public P(int id, String n, float pri) {   
        this.id = id;  
        this.n = n;  
        this.pri = pri;  
    }  
}  
public class M1{  
    public static void main(String[] args) {  
        List<P> l = new ArrayList<P>();  
        l.add(new P(1," JavaTpoint ",17000));  
        l.add(new P(3," Tutorial and example ",100500));  
        l.add(new P(2," Website ",25000));  
          
        // using the arrow to filter data  
        Stream<P> filtered_data = l.stream().filter(q -> q.pri > 17000);
        filtered_data.forEach(  
                p -> System.out.println(p.n+": "+p.pri)  
        );  
    }
}

Output:

Tutorial and example: 100500.0
Website: 25000.0

Array operator in Java thread

In order to implement the run() method of both the runnable interface, we used lambda expression in this instance. A lambda expression can be used with ease because Runnable has a single method interface. see the illustration below.

M3.java

package javaexample;
import java.util.ArrayList;  
import java.util.List;  
import java.util.stream.Stream;   
public class M3{  
    public static void main(String[] args) {  

        // using arrow operator  
        Runnable r1=()->{  
            System.out.println(" Thread is running... ");  
        };  
        Thread t1 = new Thread(r1);  
        t1.start();  
    }
}

Output: