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
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 :
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 :
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 :
Syntaxe :
object::methodName()
Travail :
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 :
Syntaxe :
ClassName :: instanceMethodName()
Travail :
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 :
Syntaxe :
myFunc(roster, HashSet<MyClass>::new);
Travail :
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:
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!