El operador de flecha -> en Java

1. Cómo utilizar el operador Arrow en Java
2. Operador de flecha en colecciones de Java
3. Operador de flecha en Java Thread

Este tutorial presenta lo que hace el operador de flecha (->) en Java y también enumera algunos códigos de ejemplo para comprender el tema.

En Java 8, se agregó una nueva expresión lambda de característica y, al mismo tiempo, el operador de flecha apareció en Java, que se utiliza para formar una expresión lambda. Separa los argumentos del cuerpo de la expresión.

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

La expresión Lambda se introdujo en Java 8 y se puede utilizar en lugar de la clase anónima en Java para hacer que el código sea más conciso y legible.

A continuación se muestra un ejemplo de cómo creamos una clase anónima en Java antes de Java 8.

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

Y así es como podemos implementar la tarea anterior usando la expresión lambda en Java 8.

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

Comencemos con algunos ejemplos para comprender también el uso de los operadores lambda y flecha.

Cómo utilizar el operador Arrow en Java

En este ejemplo, usamos el operador de flecha para crear una expresión lambda que implementa el método draw() de la interfaz Drawable. Vea el ejemplo a continuación.

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();
  }
}

Producción :

Drawing width:  20

Dado que la expresión lambda es una excelente manera de crear código conciso con un enfoque funcional, podemos usarlo de varias maneras en el código Java. Veamos algunos ejemplos donde podemos aplicarlo.

Operador de flecha en colecciones de Java

En este ejemplo, filtramos los datos de ArrayList mediante una expresión lambda. Usamos la API de flujo y el método filter() para obtener el resultado deseado. Puede notar lo fácil que es crear código usando lambda en lugar de código no lambda. Vea el ejemplo a continuación.

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));
  }
}

Producción :

Iphone 12: 100500.0
Sony Xperia: 25000.0

Operador de flecha en Java Thread

Este es otro uso de la expresión lambda donde la usamos para implementar el método run() de la interfaz ejecutable. Dado que Runnable es una interfaz de método único, es fácil usar una expresión lambda. Vea el ejemplo a continuación.

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();
  }
}

Producción :

Thread is running...