Java 8 lambda Nul argument

Disons que j'ai fonctionnelles suivantes de l'interface en Java 8:

interface Action<T, U> {
   U execute(T t);
}

Et pour certains cas, j'ai besoin d'une action sans arguments ou le type de retour. Alors j'écris
quelque chose comme ceci:

Action<Void, Void> a = () -> { System.out.println("Do nothing!"); };

Cependant, il me donne une erreur de compilation, j'ai besoin d'écrire comme

Action<Void, Void> a = (Void v) -> { System.out.println("Do nothing!"); return null;};

Ce qui est laid. Est-il possible de se débarrasser de la Void type de paramètre?

Jetez un oeil à stackoverflow.com/questions/14319787/...
Si vous avez besoin d'une action, comme vous l'avez défini, il n'est pas possible. Cependant, votre premier exemple pourrait tenir dans une Runnable, qui que vous êtes à la recherche pour Runnable r = () -> System.out.println("Do nothing!");
Je ne veux pas utiliser un Consommateur comme suggéré dans ce post.
le problème est que l'Exécutable ne peut pas être un sous-type de mon type de fonction.
En java, si dans la signature de la méthode que vous avez le type de retour - vous devez retourner quelque chose dans la méthode de la mise en œuvre.
Matt réponse du fait que les types de travail, mais ce qui ne l'appelant lorsqu'il obtient une valeur de retour null?
Vous pourriez croiser les doigts et espérons que les suggestions 2 & 3 dans ce post acceptée pour Java 9!

InformationsquelleAutor Wickoo | 2015-04-29

90

La syntaxe que vous êtes après est possible avec une petite aide de la fonction qui convertit un Runnable en Action<Void, Void> (vous pouvez le placer dans Action par exemple):
```
public static Action<Void, Void> action(Runnable runnable) {
    return (v) -> {
        runnable.run();
        return null;
    };
}

//Somewhere else in your code
 Action<Void, Void> action = action(() -> System.out.println("foo"));
```
- C'est la meilleure solution que vous pourriez avoir, de l'OMI, si +1 (ou avec une méthode statique dans l'interface elle-même)
- Konstantin Yovkov la solution ci-dessous (avec @FunctionalInterface) est une meilleure solution, car il n'implique pas de génériques et ne nécessite pas de code supplémentaire.
- Désolé, je ne vois pas une réponse impliquant @FunctionalInterface. Il a simplement dit qu'il n'est pas possible de le prolonger...
- Salut @Matt, désolé. J'ai réagi trop vite. Pour la question à laquelle vous répondez est parfaitement valide. Malheureusement, mon vote est verrouillé, donc je ne peux pas supprimer mon -1 sur cette réponse. Deux remarques: 1. Au lieu de Runnable action doit prendre une coutume @FunctionalInterface quelque chose qui s'appelle SideEffect, 2. la nécessité de cette fonction d'assistance met en évidence que quelque chose de bizarre qui se passe, et probablement l'abstraction est cassé.
InformationsquelleAutor Matt
375

Utilisation Fournisseur si il ne prend rien, mais renvoie quelque chose.

Utilisation Consommation si elle prend quelque chose, mais ne retourne rien.

Utilisation Callable si elle renvoie un résultat et pourrait jeter (plus semblable à Thunk en général CS termes).

Utilisation Exécutable si il ne fait rien et ne peut pas jeter.
- Comme exemple je l'ai fait pour l'envelopper de "nul", de retour d'appel : public static void wrapCall(Runnable r) { r.run(); }. Merci
- belle réponse. Court et précis.
- N'aide pas, si elle doit jeter un checked exception, malheureusement.
- La consommation permet à un seul paramètre d'entrée
- Pour compléter cette réponse, qui ne vaut pas un edit: vous pouvez également utiliser BiConsumer (prend 2, renvoie 0), la Fonction (1, retour 1) et BiFunction (prend 2, renvoie 1). Ceux qui sont le plus important à connaître
- On remarque ici, c'est que Exécutable impossible de lever et vraiment mieux utilisé lorsque vous souhaitez exécuter de manière asynchrone. Si vous voulez avoir une interface fonctionnelle plus proche de Thunk, vous devez utiliser Callable, qui peut jeter.
- Est-il quelque chose comme "Callable" (qui renvoie une exception dans sa méthode call ()), mais ne nécessite aucune valeur de retour?
InformationsquelleAutor x1a0
36

Le lambda:
```
() -> { System.out.println("Do nothing!"); };
```
représente en fait une implémentation d'une interface comme:
```
public interface Something {
    void action();
}
```
qui est complètement différent de celui que vous avez défini. C'est pourquoi vous obtenez une erreur.

Puisque vous ne pouvez pas prolonger votre @FunctionalInterface, ni présenter une nouvelle marque, alors je pense que vous n'avez pas beaucoup d'options. Vous pouvez utiliser le Optional<T> interfaces pour désigner certaines des valeurs (type de retour ou de la méthode en paramètre est manquant, cependant. Cependant, ce ne sera pas à la lambda corps plus simple.
- Le problème, c'est que votre Something fonction ne peut pas être un sous-type de mon Action type, et je ne peux pas avoir deux types différents.
- La caisse de ma mise à jour.
- Techmically qu'il peut, mais il dit qu'il veut éviter. 🙂
InformationsquelleAutor Konstantin Yovkov
28

Vous pouvez créer une sous-interface pour ce cas particulier:
```
interface Command extends Action<Void, Void> {
  default Void execute(Void v) {
    execute();
    return null;
  }
  void execute();
}
```
Il utilise un méthode par défaut pour remplacer les hérité paramétrée méthode Void execute(Void), de déléguer l'appel à la méthode la plus simple void execute().

Le résultat est qu'il est beaucoup plus simple à utiliser:
```
Command c = () -> System.out.println("Do nothing!");
```
InformationsquelleAutor Jordão

Qui n'est pas possible. Une fonction qui a un non-vide de type de retour (même si c'est Void) doit retourner une valeur. Cependant, vous pourriez ajouter des méthodes statiques pour Action qui vous permet de "créer" un Action:

interface Action<T, U> {
   U execute(T t);

   public static Action<Void, Void> create(Runnable r) {
       return (t) -> {r.run(); return null;};
   }

   public static <T, U> Action<T, U> create(Action<T, U> action) {
       return action;
   } 
}

Qui vous permettra d'écrire ce qui suit:

//create action from Runnable
Action.create(()-> System.out.println("Hello World")).execute(null);
//create normal action
System.out.println(Action.create((Integer i) -> "number: " + i).execute(100));

InformationsquelleAutor fabian

Ajouter une méthode statique à l'intérieur de votre interface fonctionnelle

package example;

interface Action<T, U> {
       U execute(T t);
       static  Action<Void,Void> invoke(Runnable runnable){
           return (v) -> {
               runnable.run();
                return null;
            };         
       }
    }

public class Lambda {


    public static void main(String[] args) {

        Action<Void, Void> a = Action.invoke(() -> System.out.println("Do nothing!"));
        Void t = null;
        a.execute(t);
    }

}

Sortie

Do nothing!

Ce qui est différent de la déjà posté des réponses?

InformationsquelleAutor MCHAppy

3

Je ne pense pas que c'est possible, car les définitions de fonctions ne correspondent pas à votre exemple.

Votre lambda expression est évaluée exactement comme
```
void action() { }
```
alors que votre déclaration ressemble à
```
Void action(Void v) {
    //must return Void type.
}
```
comme un exemple, si vous avez d'interface suivants
```
public interface VoidInterface {
    public Void action(Void v);
}
```
le seul type de fonction (alors que l'instanciation) qui seront compatibles ressemble
```
new VoidInterface() {
    public Void action(Void v) {
        //do something
        return v;
    }
}
```
et un manque d'instruction de retour ou d'argument, vous donnera une erreur du compilateur.

Par conséquent, si vous déclarez une fonction qui prend un argument et retourne un, je pense qu'il est impossible de le convertir à une fonction qui ne fait rien de mentionné ci-dessus.

InformationsquelleAutor pnadczuk

Juste pour la référence fonctionnelle de l'interface peut être utilisée pour la méthode de référence en cas de jets de méthode et/ou renvoie une valeur.

void notReturnsNotThrows() {};
void notReturnsThrows() throws Exception {}
String returnsNotThrows() { return ""; }
String returnsThrows() throws Exception { return ""; }

{
    Runnable r1 = this::notReturnsNotThrows; //ok
    Runnable r2 = this::notReturnsThrows; //error
    Runnable r3 = this::returnsNotThrows; //ok
    Runnable r4 = this::returnsThrows; //error

    Callable c1 = this::notReturnsNotThrows; //error
    Callable c2 = this::notReturnsThrows; //error
    Callable c3 = this::returnsNotThrows; //ok
    Callable c4 = this::returnsThrows; //ok

}


interface VoidCallableExtendsCallable extends Callable<Void> {
    @Override
    Void call() throws Exception;
}

interface VoidCallable {
    void call() throws Exception;
}

{
    VoidCallableExtendsCallable vcec1 = this::notReturnsNotThrows; //error
    VoidCallableExtendsCallable vcec2 = this::notReturnsThrows; //error
    VoidCallableExtendsCallable vcec3 = this::returnsNotThrows; //error
    VoidCallableExtendsCallable vcec4 = this::returnsThrows; //error

    VoidCallable vc1 = this::notReturnsNotThrows; //ok
    VoidCallable vc2 = this::notReturnsThrows; //ok
    VoidCallable vc3 = this::returnsNotThrows; //ok
    VoidCallable vc4 = this::returnsThrows; //ok
}

Veuillez ajouter un peu plus de contexte. Cela semble intéressant, mais son sens n'est pas immédiatement évident.

InformationsquelleAutor SlavaL

Vous devez vous connecter pour publier un commentaire.