mémo d'expression java lambda

Interface fonctionnelle

Une interface fonctionnelle est une interface dans laquelle une seule méthode abstraite est déclarée. À part cela, il n'y a pas de restrictions particulières. Par exemple, peu importe si vous avez plusieurs méthodes par défaut et méthodes privées.

Qu'est-ce qu'une expression lambda?

Une fonction qui donne une implémentation d'interface sur le client (appelant). En utilisant des expressions lambda, il n'est pas nécessaire de créer une classe concrète qui implémente l'interface. Les expressions Lambda ne sont possibles que si vous donnez une implémentation d'une interface fonctionnelle. En effet, lorsqu'il existe plusieurs méthodes abstraites dans l'interface auxquelles vous souhaitez donner une implémentation, le compilateur ne peut pas spécifier à quelle méthode abstraite donner l'implémentation (définition).

fermeture

Lorsque vous donnez une implémentation à l'aide d'une expression lambda, d'une classe locale ou d'une classe anonyme dans une méthode, une fonction qui permet aux variables locales du client d'être utilisées dans le bloc qui donne l'implémentation. Les variables utilisées comme fermetures sont copiées sous forme de champs dans les instances lambda (pour java). Dans certaines langues, les références sont transmises. Les variables passées dans la clôture sont définitives.

Exemple de code

InfintieIntSequence.java

public interface InfiniteIntSequence{
        default public boolean hasNext(){ return true; }
        public int next();


        public static InfiniteIntSequence generate(IntSupplier s){
                return s::getAsInt; //@1
        }

        public static InfiniteIntSequence iterate(int seed, IntUnaryOperator f){
                return new InfiniteIntSequence(){
                        int lseed = seed; //@2
                        @Override public int next(){
                                int res=lseed;
                                lseed=f.applyAsInt(lseed);
                                return res;
                        }
                };
        }

        public static InfiniteIntSequence random(int from, int until){
                Random r = new Random();
                int bound = until-from;
                if(0<bound) return ()->r.nextInt(bound)+from;
                else throw new IllegalArgumentException();
        }

        public static InfiniteIntSequence range(int from){
                return iterate(from, i -> i+1 );
        }

        default public void forEach(IntConsumer c, int n){
                while(n-- > 0 && hasNext() ) c.accept(next());
        }
}

Ce qui est retourné par @ 1: return est une instance de classe qui hérite de l'interface InfiniteIntSequence, en remplaçant la méthode next (). Comme InfiniteIntSequence est une interface fonctionnelle, il est garanti qu'il n'y a qu'un seul abstract et sod. Par conséquent, le compilateur peut comprendre qu'il remplace next (), il est donc possible d'omettre d'écrire diverses choses. next () est une méthode de signature qui renvoie un type int sans argument.