Programmation fonctionnelle en Java

La programmation fonctionnelle Java voit le jour après la version Java 8^ème. La programmation fonctionnelle signifie un changement fondamental dans l'approche de la résolution de problèmes. La programmation fonctionnelle permet de programmer avec des expressions (déclarer des fonctions), de passer des fonctions comme arguments et d'utiliser des fonctions comme instructions.

Types de programmation fonctionnelle

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

• Programmation fonctionnelle des flux
• Programmation fonctionnelle des expressions Lambda
• Programmation fonctionnelle de référence de méthode

Comment fonctionne la programmation fonctionnelle en Java ?

Avant d'entrer dans le concept de programmation fonctionnelle, voyons la différence entre la programmation fonctionnelle et structurée. La programmation structurée met l'accent sur la structure ou le processus logique, tandis que la programmation fonctionnelle se concentre principalement sur les données. La programmation structurée suit une approche descendante, tandis que la programmation fonctionnelle suit une approche de bas en haut.

La programmation fonctionnelle est séparée en minuscules entités d'exécution appelées objets, tandis que la programmation structurée sépare les petites unités ou fonctions. La programmation structurée est moins sécurisée, tandis que la programmation fonctionnelle est hautement sécurisée. La programmation structurée ne peut pas gérer des problèmes complexes, tandis que la programmation fonctionnelle gère n'importe quel niveau d'un problème complexe.

Exemples de programmation fonctionnelle en Java

Vous trouverez ci-dessous les exemples mentionnés :

Exemple n°1 : Programmation fonctionnelle des flux

Syntaxe :

objectName.stream();

Code :

Animal.java

package com.streams;
public class Animal {
String name;
String color;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public Animal(String name, String color) {
super();
this.name = name;
this.color = color;
}
}

AnimalNames.java

package com.streams;//creating package
//importing required packages to the code
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
public class AnimalNames {
public static void main(String[] args) {
getMyDogNames();//calling the method
}
private static void getMyDogNames() {
Animal a1=new Animal("Puppy","black"); //creating a object for animal class
Animal a2=new Animal("Tommy","brown");//creating a object for animal class
Animal a3=new Animal("Zimmy","white");//creating a object for animal class
List<Animal> persons = Arrays.asList(a1,a2,a3); //passing object references to list
String dogName = persons.stream() //covert all elements into stream
.filter(name -> "Puppy".equals(name.getName()))//filtering given elements from persons class
.map(Animal::getName)     //persons elements iterate over map
.findAny()//find out the given element passed from filter
.orElse("");//
System.out.println("Dog Name :" + dogName); //print the dog name
List<String> collect = persons.stream()
.map(Animal::getName)
.collect(Collectors.toList());//collecting all names from list
System.out.println("All Dog names");
collect.forEach(System.out::println);//iterating collection with for each loop
}
}

Sortie :

Explication :

• Dans la classe Java, nous générons des setters et des getters.
• Nous écrivons le code principal pour imprimer les noms de chiens dans la classe Java.
• Dans le code lui-même, mentionnez le but de chaque ligne dans le commentaire.
• Si nous écrivons le même code en programmation structurée, nous devons écrire plus de lignes pour chaque méthode comme filter(), collector(), findAny(), map(), etc. Ainsi, la plupart des développements de programmation fonctionnelle sont préférés à programmation structurée.

Exemple n°2 : expressions lambda

• Une expression lambda est utilisée pour représenter une interface de méthode avec une expression.
• Il permet d'itérer, de filtrer et d'extraire les données des collections.
• L'implémentation de l'interface d'expression Lambda est une interface fonctionnelle.
• Cela réduit beaucoup de code.
• Une expression lambda est traitée comme une fonction, le compilateur Java ne peut donc pas créer .class

Syntaxe :

(arguments) ->
{
//code for implementation
}
Arguments:  argument-list can be have values or no values
Example: arguments1, arguments2, arguments3,……
->: Joins code implementation and arguments.

a. Expression lambda avec un seul argument

Syntaxe :

(argument1) ->
{
//code for implementation
}

Exemple – AreaOfSquare.java

Code :

package com.lambda;//creating a package
interface Square{  //creating interface for quare
public int getArea(int side);  //create a method for get area
}
public class AreaOfSquare{  //As we are working with Lambda expression so no need to implement interface of square
public static void main(String[] args) {
Square area=(side)->{  // Lambda expression with only one argument.
Return side*side;  //returning area
};
System.out.println(“Area of Square=>”+area.getArea(10));   //printing area by calling interface getArea method
}
}

Sortie :

Explication :

• Ce qui précède a créé une interface Square et une expression lambda écrite à l'intérieur de la classe AreaOfSquare.
• Dans l'expression lambda, logique écrite pour l'aire d'un carré.
• Dans la dernière ligne imprimée, l'aire du carré de 100 en appelant la méthode d'interface getArea().

b.  Expression lambda sans argument

Syntaxe :

() ->
{
//code for implementation
}

Exemple – MyNameString.java

Code :

package com.lambda;//creating a package
interface Name{  //creating interface for Name
public String getMyName();  //create a method for get name
}
public class MyNameString{  //As we are working with Lambda expression so no need to implement interface of Name
public static void main(String[] args) {
Name name=()->{  // Lambda expression with out argument.
return "Hi, Amardeep!"; //returning name
};
System.out.println(name.getMyName());   //printing name by calling interface getMyName method
}
}

Sortie :

Explication :

• Ce qui précède a créé un nom d'interface et à l'intérieur de la classe MyNameString une expression lambda écrite sans argument.
• Dans l'expression lambda, logique écrite pour la chaîne de retour.
• Dans la dernière ligne imprimée, la chaîne est Salut, Amardeep ! En appelant la méthode d'interface getMyName().

Exemple n°3 : Référence de méthode

• La référence de méthode est utilisée pour faire référence à une méthode d'interface fonctionnelle.
• C'est une autre forme simple d'expression lambda.
• Si vous utilisez une expression lambda à chaque fois pour pointer une méthode, nous pouvons utiliser la référence de méthode à la place de la référence de méthode.

Syntaxe :

Class-Name:: static method name

Exemple – StaticMethodReference.java

Code :

package method.reference;//creating package
interface RectangleArea{  //creating RectangleArea interface
public int getArea(int l,int b);  //creating method getArea in interface
}
public class StaticMethodReference {  //creating a classs
public static int showRectangleArea(int length, int breadth){  //creating method for getting rectangle area
return length*breadth;
}
public static void main(String[] args) {
// Referring static method
RectangleArea area = StaticMethodReference::showRectangleArea;  //calling class name with method name
// Calling interface method
int outArea=area.getArea(10,20);
System.out.println("Area of rectangle :"+outArea);//printing area
}
}

Sortie :

Explication :

• Ce qui précède a créé une interface Rectangle et, à l'intérieur de la classe StaticMethodReference, a écrit le code de référence de la méthode statique.
• Dans la méthode showRectangleArea(), logique écrite pour l'aire d'un rectangle.
• La ligne suivante a transmis la référence de méthode statique à la référence d'interface RectangleArea.
• Ensuite, imprimez une ligne sur la zone du rectangle en appelant la méthode getArea(10,20).
• Donne une sortie de 200.

Conclusion

La programmation fonctionnelle est réalisée avec des flux, des expressions lambda et des références de méthodes. Cela réduit les lignes de code et améliore les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!