L'opérateur flèche -> en Java

1. Comment utiliser l’opérateur Flèche en Java
2. Opérateur de flèche dans les collections Java
3. Opérateur de flèche dans Java Thread

Ce tutoriel présente ce que fait l’opérateur flèche (->) en Java et répertorie également quelques exemples de codes pour comprendre le sujet.

Dans Java 8, une nouvelle fonctionnalité d’expression lambda a été ajoutée et, en même temps, l’opérateur flèche a vu le jour dans Java, qui est utilisé pour former une expression lambda. Il sépare les arguments du corps de l’expression.

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

L’expression lambda a été introduite dans Java 8 et peut être utilisée à la place d’une classe anonyme en Java pour rendre le code plus concis et plus lisible.

Vous trouverez ci-dessous un exemple de la façon dont nous créons une classe anonyme en Java avant Java 8.

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

Et voici comment nous pouvons implémenter la tâche ci-dessus en utilisant l’expression lambda dans Java 8.

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

Commençons par quelques exemples pour comprendre également l’utilisation des opérateurs lambda et flèche.

Comment utiliser l’opérateur Flèche en Java

Dans cet exemple, nous avons utilisé l’opérateur flèche pour créer une expression lambda qui implémente la méthode draw() de l’interface Drawable. Voir l’exemple ci-dessous.

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

Production:

Drawing width:  20

Étant donné que l’expression lambda est un excellent moyen de créer du code concis avec une approche fonctionnelle, nous pouvons l’utiliser de plusieurs manières dans le code Java. Voyons quelques exemples où nous pouvons l’appliquer.

Opérateur de flèche dans les collections Java

Dans cet exemple, nous filtrons les données ArrayList à l’aide d’une expression lambda. Nous avons utilisé l’API stream et la méthode filter() pour obtenir le résultat souhaité. Vous pouvez remarquer à quel point il est facile de créer du code à l’aide de lambda plutôt que du code non lambda. Voir l’exemple ci-dessous.

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

Production:

Iphone 12: 100500.0
Sony Xperia: 25000.0

Opérateur de flèche dans Java Thread

Il s’agit d’une autre utilisation de l’expression lambda où nous l’avons utilisée pour implémenter la méthode run() de l’interface exécutable. Étant donné que Runnable est une interface à méthode unique, il est alors facile d’utiliser une expression lambda. Voir l’exemple ci-dessous.

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

Production:

Thread is running...