Explication des expressions lambda

J'ai des questions sur les expressions lambda et RxJava. Ces questions concernent principalement une compréhension incomplète des expressions lambda ou RxJava. Je vais essayer d'expliquer les expressions lambda aussi simplement que possible. RxJava je décrirai séparément.

Expressions Lambda et RxJava

Que sont les expressions lambda? Les expressions lambda sont «juste» une nouvelle façon de faire la même chose que nous pourrions toujours faire, mais d'une nouvelle façon plus propre et moins verbeuse d'utiliser des classes internes anonymes.

Une classe interne anonyme en Java est une classe sans nom, elle doit être utilisée si vous devez remplacer les méthodes de classe ou d'interface. Une classe interne anonyme peut être créée à partir d'une classe ou d'une interface.

Par exemple:

abstract class Animal { abstract void speak(); } Animal a = new Animal() { void speak() { System.out.println("Woff"); } }; 

Sur Android, nous utilisons généralement une classe interne anonyme comme écouteur, par exemple, pour les boutons de ce type:

 Button btn = findViewById(R.id.button); btn.setOnClickListener( new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } ); 

Revenons aux expressions lambda. Il s'agit de la partie suivante, qui fait partie du code précédent, qui est considérée comme une classe interne anonyme.

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

Les expressions lambda ne peuvent être utilisées que si vous devez remplacer au plus une méthode. Heureusement pour nous, View.OnClickListener n'en contient qu'un. Jetez un œil au code ci-dessous. Quelle partie pensez-vous que nous devons supprimer?

 new View.OnClickListener() { @Override public void onClick(final View view) { // Do some fancy stuff with the view parameter. } } 

Après avoir supprimé presque tout le code, nous devons ajouter ->, comme dans le code ci-dessous. La vue des paramètres d'entrée peut être utilisée à l'intérieur de la fonction de la même manière qu'auparavant.

 (view) -> { // Do some fancy stuff with the view parameter. } 

Dans certains cas, vous devrez peut-être ajouter un type à un paramètre, si le compilateur ne peut pas le deviner, vous pouvez le faire en l'ajoutant avant le paramètre:

 (View view) -> { // Do some fancy stuff with the view parameter. } 

Vous pouvez également utiliser du code multiligne:

 (view) -> { Intent intent = new Intent(context, AuthActivity.class); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK); view.getContext().startActivity(intent); } 

Si vous avez une interface avec une méthode qui prend deux paramètres ...

 interface MyInterface { abstract void onMethod(int a, int b); } 

... l'expression lambda ressemblera à ceci:

 (a, b) -> { // Do some fancy stuff with the a and b parameter. } 

Si la méthode a un type de retour ...

 interface MySecondInterface { abstract int onSecondMethod(int a, int b); } 

... l'expression lambda ressemblera à ceci:

 (a, b) -> { return a + b; } 

Mais ce n'est pas tout, il y a des cas spéciaux qui rendent le code encore plus petit. Si le corps de votre méthode ne contient qu'une seule ligne de code, vous pouvez supprimer les accolades {} . Si vous supprimez des accolades, vous devez également supprimer le point-virgule, en laissant ce qui suit:

 (a, b) -> return a + b 

Il y a encore une chose que nous pouvons faire. Si nous n'avons qu'une seule ligne de code, le compilateur peut comprendre si la partie retournée est nécessaire ou non, nous pouvons donc la laisser comme ceci:

 (a, b) -> a + b 

Si nous avions du code multiligne, cela se résumerait à ce qui suit:

 (a, b) -> { a+=1; return a + b; } 

Alors qu'avons-nous fait? Nous avons pris ceci:

 new MySecondInterface() { @Override public int onSecondMethod(final int a, final int b) { return a + b; } }; 

et l'a transformé en ceci:

 (a, b) -> a + b 

Il ne reste qu'une chose, les références de méthode. Supposons que nous ayons une interface, comme précédemment, et une méthode qui accepte cette interface comme paramètre:

 public interface Callback { public void onEvent(int event); } public void myMethod(Callback callback){ } 

Sans expression lambda, cela ressemblerait à ceci:

 myMethod(new Callback() { @Override public void onEvent(final int state) { System.out.println(state); } }); 

En ajoutant une expression lambda, comme nous l'avons fait auparavant, nous obtenons ce qui suit:

 myMethod(state -> System.out.println(state)); 

Mais ce n'est pas tout. Si le code utilisé est sur une seule ligne et que la fonction appelée prend un paramètre, nous pouvons passer la référence de la méthode sous cette forme:

 myMethod(System.out::println); 

Le paramètre sera transmis automatiquement, sans avoir besoin d'un autre code! Incroyable non? J'espère que vous avez appris quelque chose de nouveau!