Références des méthodes Java

L'article suivant fournit un aperçu des références de méthodes Java. Dans JDK 8, les expressions lambda sont introduites pour créer des méthodes anonymes sur une seule ligne pour effectuer une opération. Mais lors de l'écriture d'une expression lambda lorsqu'une méthode existante est appelée, une telle opération est rendue possible à l'aide des références de méthode. Cela rend les expressions plus compactes et lisibles lorsqu'il existe un appel à une méthode existante. De plus, dans la portée de référence de la méthode, l'opérateur de résolution (::) est utilisé pour séparer le nom de la méthode du nom de la classe.

Commencez votre cours de développement de logiciels libres

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

Types de références de méthodes Java

Voyons la nécessité des références de méthode avec un exemple :

Code :

public class Employee {
public enum Sex {
MALE, FEMALE
}
String name;
LocalDatejoiningDate;
Sex gender;
String emailAddress;
public int getNumberOfYears() {
}
public Calendar getJoiningDate() {
return joiningDate;
}
public static int compareByJoiningDate(Employeea, Employeeb) {
return a.joiningDate.compareTo(b.joiningDate);
}}

Et si nous voulons trier la liste des employés par joinDate signifie qui rejoint en premier, alors nous pouvons appeler la méthode ci-dessous dans l'une des sous-classes.

Code :

Person[] rosterAsArray = roster.toArray(new Employee[roster.size()]);
class JoiningDateComparator implements Comparator<Employee> {
public int compare(Employeea, Employeeb) {
return a.getJoiningDate().compareTo(b.getJoiningDate());
}
}

Ainsi, nous pouvons écrire une expression lambda pour appeler la méthode ci-dessus tout en triant la liste pour comparer les dates d'arrivée de 2 employés.

Code :

Arrays.sort(rosterAsArray,
(a, b) ->Person.compareByAge(a, b)
);

Ou nous pouvons appeler la méthode de la manière ci-dessous ; les deux ont la même signification pour appeler la méthode pour chaque paire d'objets du tableau.

Code :

Arrays.sort(rosterAsArray, Person::compareByAge)

Les quatre types de références de méthodes suivants existent dans JDk 8 :

1. Référence à la méthode statique

La référence à une méthode statique utilisant l'opérateur :: est appelée référence à une méthode statique.

Syntaxe :

ClassName::MethodName()

Travail :

• Ici, la méthode référencée est d'un type statique, ce qui signifie qu'aucune instance de la classe n'est requise pour appeler cette méthode ; au lieu de cela, seul le nom de classe serait suffisant.
• Ainsi, quand on mentionneClassName::MethodName dans son expression lambda, JRE se rend dans cette classe pour trouver une méthode statique dans la classe mentionnée. Puisqu'il s'agit d'un appel à une méthode statique, il ne peut donc pas être mentionné sous un bloc non statique.

Exemple :

Dans l'exemple ci-dessous, la méthode statique add de la classe Addition est appelée en utilisant la fonctionnalité de la classe bifonction dans le package java.util, où la référence de cette méthode est stockée dans l'objet myObj et est transmise avec les valeurs nécessaires à être passé en arguments.

Code :

import java.util.function.BiFunction;
class Addition{
public static int add(int a, int b){
return a+b;
}
}
public class HelloWorld {
public static void main(String[] args) {
BiFunction<Integer, Integer, Integer>myObj = Addition::add;
int res = myObj.apply(30, 5);
System.out.println("Sum of given number is: "+res);
}
}

Sortie :

2. Référence à une méthode d'instance d'un objet particulier

Syntaxe :

object::methodName()

Travail :

• Dans ce type de référence, on utilise un objet de la classe pour faire référence à une de ses méthodes d'instance. Ici, JRE vérifie si les arguments passés sont du même type que celui mentionné dans la déclaration de la méthode.
• Cela permet d'écrire une expression lambda en utilisant les méthodes d'instance de la classe.

Exemple :

Dans l'exemple ci-dessous, la méthode showName de la classe HelloWorld est appelée en utilisant une référence de méthode aux méthodes d'instance.

Code :

interface MyInterface{
void display();
}
public class HelloWorld {
public void showName(){
System.out.println("Call to method ShowName");
}
public static void main(String[] args) {
HelloWorld obj = new HelloWorld();
MyInterface ref = obj::showName;
ref.display();
}
}

Sortie :

3. Référence à une méthode d'instance d'un objet arbitraire d'un type particulier

Syntaxe :

ClassName :: instanceMethodName()

Travail :

• Il s'agit du même type de référence que celui indiqué ci-dessus, la différence réside ici dans le fait que les objets auxquels il est fait référence ici changent continuellement, ce qui signifie que de nombreux objets appellent la même méthode mais du même type en utilisant le référencement de méthode.

Exemple : Dans l'exemple ci-dessous, nous appelons la méthode compareToIgnoreCase pour toutes les chaînes stockées dans le tableau. Ainsi, au lieu de transmettre différents objets un par un, cela se produit dans une seule instruction utilisant une liste.

Code :

import java.util.Arrays;
public class HelloWorld {
public static void main(String[] args) {
String[] empArray = { "John", "Jack", "Aditya", "Vishal", "Saurabh", "Amanda", "Daniel"};
Arrays.sort(empArray, String::compareToIgnoreCase);
System.out.println("Sorted list of names of Employees \n");
for(String str: empArray){
System.out.println(str);
}
}
}

Sortie :

4. Référence à un constructeur

Syntaxe :

myFunc(roster, HashSet<MyClass>::new);

Travail :

• Cet appel de référence sert également à appeler un constructeur d'une classe.
• Pour cela, le mot-clé 'new' est utilisé dans une expression lambda, et tel que JRE en déduit qu'il faut appeler le constructeur de cette classe particulière.

Prenons un exemple d'expression lambda qui contient un appel à la méthode ci-dessous et nécessite la transmission d'un nouveau constructeur de HashSet.

Code :

publicstatic<T, MYSRCextends Collection<T>, MYDESTextends Collection<T>>
MYDEST MyMethod(
MYSRC src,
Supplier< MYDEST>dest) {
MYDEST res = collectionFactory.get();
for (T t : src)
{res.add(t);
}
returnres;
}

Alors l'expression lambda serait comme :

Code :

Set<myClass>rosterSet = MyMethod(roster, HashSet::new);

Ici, JRE déduit automatiquement que les arguments passés contiennent des objets de type myClass ou soit nous pouvons utiliser l'expression lambda ci-dessous pour

Set<myClass>rosterSet = transferElements(roster, HashSet<myClass>::new);

Example: In the below example, a constructor of a firstReference class is being called using ‘new’ operator and stored in a reference variable ‘inObj’. This reference variable is then used to refer to the instance methods of this class.

Code:

@FunctionalInterface
interface firstInterface{
firstReference show(String say);
}
class firstReference{
public firstReference(String say){
System.out.print(say);
}
}
public class HelloWorld {
public static void main(String[] args) {
//Method reference to a constructor
firstInterface inObj = firstReference::new;
inObj.show("Let’s begin learning Contructor type method reference");
}
}

Output:

Conclusion

Method Reference is a way to make a call to an existing method in lambda expressions being used in the application. This feature has been introduced with JDK 1.8 to make lambda expressions more compact and reuse the existing code. There are four ways to make calls to the methods of the class names as shown above.

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!