Cum am defini o metoda care preia o lambda ca un parametru în Java 8?

Lambda sunt pur și simplu un call-ului construct: destinatarul lambda nu are nevoie să știe că un Lambda este implicat, în schimb, acceptă o Interfață cu metoda corespunzătoare.

Cu alte cuvinte, puteți defini sau de a folosi o interfață funcțională (de exemplu, o interfață cu un singur metoda), care acceptă și se întoarce exact ceea ce vrei.

Pentru aceasta Java 8 vine cu un set de frecvent utilizate tipuri de interfață în java.util.funcția (datorită Maurice Naftalin pentru sugestie despre JavaDoc).

Pentru acest caz de utilizare specific acolo's java.util.funcția.IntBinaryOperator cu o singur int applyAsInt(int stanga, int dreapta) metoda, astfel încât ai putea scrie "metodă" de genul asta:

static int method(IntBinaryOperator op){
    return op.applyAsInt(5, 10);
}

Dar puteți la fel de bine defini propriile interfață și de a folosi astfel:

public interface TwoArgIntOperator {
    public int op(int a, int b);
}

//elsewhere:
static int method(TwoArgIntOperator operator) {
    return operator.op(5, 10);
}

Folosind propriul dvs. de interfață are avantajul că poate au nume care mai indică în mod clar intenția.

Pentru a utiliza Lambda expresie trebuie să fie de a crea propria interfață funcțională sau de a folosi Java interfața funcțională pentru operație care necesită două întregi și întoarce ca valoare. IntBinaryOperator

Folosind definite de utilizator interfață funcțională

interface TwoArgInterface {

    public int operation(int a, int b);
}

public class MyClass {

    public static void main(String javalatte[]) {
        // this is lambda expression
        TwoArgInterface plusOperation = (a, b) -> a + b;
        System.out.println("Sum of 10,34 : " + plusOperation.operation(10, 34));

    }
}

Folosind Java interfața funcțională

import java.util.function.IntBinaryOperator;

public class MyClass1 {

    static void main(String javalatte[]) {
        // this is lambda expression
        IntBinaryOperator plusOperation = (a, b) -> a + b;
        System.out.println("Sum of 10,34 : " + plusOperation.applyAsInt(10, 34));

    }
}

Alt exemplu pe care am creat-o este aici

Pentru funcțiile care nu au mai mult de 2 parametri, puteți trece-le fără a defini propria interfață. De exemplu,

class Klass {
  static List<String> foo(Integer a, String b) { ... }
}

class MyClass{

  static List<String> method(BiFunction<Integer, String, List<String>> fn){
    return fn.apply(5, "FooBar");
  }
}

List<String> lStr = MyClass.method((a, b) -> Klass.foo((Integer) a, (String) b));

În BiFunction<Integer, String, Lista<String>>, "Întreg" și "String" sunt parametrii săi, și Lista` este tipul de returnare.

Pentru o functie cu un singur parametru, puteți utiliza Funcția<T, R>`, unde " T " este parametrul de tip, și R este valoarea returnată de tip. Se referă la acest page pentru toate interfețele care sunt deja puse la dispoziție de Java.

Nu's un Web public accesibil versiune de Lambda-ului Java 8 JavaDocs, legate de http://lambdafaq.org/lambda-resources. (Acest lucru ar trebui să fie în mod evident un comentariu pe Joachim Sauer's a răspuns, dar nu pot't obține în ASTFEL de cont cu puncte de reputație am nevoie pentru a adăuga un comentariu.) La lambdafaq site-ul (I-l mențină) răspunsurile acestea și o mulțime de alte Java-lambda întrebări.

NB Acest răspuns a fost scris înainte de Java 8 GA documentația devenit disponibile publicului]1. Am'am lăsat în loc, deși, pentru că Lambda FAQ s-ar putea fi în continuare util pentru oameni de învățare despre caracteristici introduse în Java 8.

Pentru oricine care este pe google despre asta, o buna metoda ar fi sa folosesc java.util.funcția.BiConsumer`. ex:

Import java.util.function.Consumer
public Class Main {
    public static void runLambda(BiConsumer<Integer, Integer> lambda) {
        lambda.accept(102, 54)
    }

    public static void main(String[] args) {
        runLambda((int1, int2) -> System.out.println(int1 + " + " + int2 + " = " + (int1 + int2)));
    }

La outprint ar fi: 166

Pentru mine, soluția cea mai probabilă este de a defini un Callback interfata :

interface Callback {
    void call();
}

și apoi să-l folosească ca parametru în funcția pe care doriți să sunați la :

void somewhereInYourCode() {
    method(() -> {
        // You've passed a lambda!
        // method() is done, do whatever you want here.
    });
}

void method(Callback callback) {
    // Do what you have to do
    // ...

    // Don't forget to notify the caller once you're done
    callback.call();
}

O precizie deși

Un lambda nu este o interfață specială, de clasă sau de orice altceva ai putea declara de unul singur. "Lambda" este doar numele dat () -> {} sintaxă specială, care permite o mai bună lizibilitate atunci când trece o singură metodă de interfețe ca parametru. Acesta a fost proiectat pentru a înlocui acest lucru :

method(new Callback() {
    @Override
    public void call() {
        // Classic interface implementation, lot of useless boilerplate code.
        // method() is done, do whatever you want here.
    }
});

Deci, în exemplul de mai sus, Callback e nu lambda, it's doar o interfață regulat ; "lambda" este numele sintaxa comenzi rapide, puteți utiliza pentru a pune în aplicare.

Lambda expresie poate fi transmis ca argument.Pentru a trece o expresie lambda ca un argument de tipul de parametru (care primește lambda expresie ca argument) trebuie să fie funcționale tip de interfață.

Dacă există o interfață funcțională -

interface IMyFunc {
   boolean test(int num);
}

Și acolo este un filtru metodă care adaugă int în listă numai dacă este mai mare decât 5. Rețineți aici că filtrul metodă are funtional interfață IMyFunc ca unul dintre parametru. În acest caz lambda expresie poate fi transferată ca un argument pentru metoda parametru.

public class LambdaDemo {
    public static List<Integer> filter(IMyFunc testNum, List<Integer> listItems) {
        List<Integer> result = new ArrayList<Integer>();
        for(Integer item: listItems) {
            if(testNum.test(item)) {
                result.add(item);
            }
        }
        return result;
    }
    public static void main(String[] args) {
        List<Integer> myList = new ArrayList<Integer>();
        myList.add(1);
        myList.add(4);
        myList.add(6);
        myList.add(7);
        // calling filter method with a lambda expression
        // as one of the param
        Collection<Integer> values = filter(n -> n > 5, myList);

        System.out.println("Filtered values " + values);
    }
}

Puteți utiliza interfețe funcționale menționate mai sus. mai jos sunt câteva exemple

Function<Integer, Integer> f1 = num->(num*2+1);
System.out.println(f1.apply(10));

Predicate<Integer> f2= num->(num > 10);
System.out.println(f2.test(10));
System.out.println(f2.test(11));

Supplier<Integer> f3= ()-> 100;
System.out.println(f3.get());

Sper că vă ajută

Ei bine, asta's ușor. Scopul de expresie lambda este de a implementa Interfața Funcțională. Este interfața cu o singură metodă. Aici este awesone articol despre predefinite și moștenirea funcționale interfețe.

Oricum, dacă doriți să pună în aplicare propria interfață funcțională, face. Doar pentru simplu exemplu:

public interface MyFunctionalInterface {
    String makeIt(String s);
}

Deci sa's face-o clasă, în cazul în care vom crea o metodă, care acceptă tipul de MyFunctionalInterface :

public class Main {

    static void printIt(String s, MyFunctionalInterface f) {
        System.out.println(f.makeIt(s));
    }

    public static void main(String[] args) {

    }
}

Ultimul lucru ce trebuie să faceți este de a trece la punerea în aplicare a MyFunctionalInterface pentru metoda pe care am'am definit:

public class Main {

    static void printIt(String s, MyFunctionalInterface f) {
        System.out.println(f.makeIt(s));
    }

    public static void main(String[] args) {
        printIt("Java", s -> s + " is Awesome");
    }
}

Ca's a!

Lambda nu este un obiect, ci o Interfață Funcțională. Puteți defini cât mai multe Interfețe Funcționale, deoarece acestea pot utiliza @FuntionalInterface ca o adnotare

@FuntionalInterface
public interface SumLambdaExpression {
     public int do(int a, int b);
}

public class MyClass {
     public static void main(String [] args) {
          SumLambdaExpression s = (a,b)->a+b;
          lambdaArgFunction(s);
     }

     public static void lambdaArgFunction(SumLambdaExpression s) {
          System.out.println("Output : "+s.do(2,5));
     }
}

Rezultatul va fi după cum urmează

Output : 7

Conceptul de Bază de o Expresie Lambda este de a defini propriile logica dar deja definite Argumente. Astfel, în codul de mai sus puteți modifica definiția a face funcția de plus față de orice altă definiție, dar argumentele tale sunt limitate la 2.

Practic, pentru a trece un lamda expresie ca un parametru, avem nevoie de un tip în care putem. Doar ca o valoare întreagă care ne ține în primitive int sau Întreg clasa. Java nu't au un tip separat pentru lamda expresie în schimb se folosește o interfață de tip pentru a ține argument. Dar asta interfață ar trebui să fie un interfață funcțională.

Face următoarele ..

Ați declarat metoda(lambda l) Tot ce vreau să fac este de a crea o Interfață cu numele "lambda" și să declare o metodă abstractă

public int add(int a,int b);  

metoda numele nu contează aici..

Deci, atunci când u sun MyClass.metoda( (a,b)->a+b) Această punere în aplicare (a,b)->a+b va fi injectat la interfață se adaugă metoda .Deci, ori de câte ori te sun eu.adaugaeste de gând să ia această punere în aplicare și de a efectua plus deașibșiîntoarceți-l.adaugă(2,3)va reveni5`.

• Practic aceasta este ceea ce lambda nu..

Există flexibilitate în utilizarea lambda ca parametru. Acesta vă permite funcțional programare în java. De bază a sintaxei este

param -> method_body

Următoarele este o cale, puteți defini o metoda de a lua interfață funcțională (lambda este folosit) ca parametru. o. dacă doriți să definiți o metodă declarată în interiorul o interfață funcțională, spune, interfață funcțională este dat ca argument/parametru la o metoda numita de main()

@FunctionalInterface
interface FInterface{
    int callMeLambda(String temp);
}

class ConcreteClass{

    void funcUsesAnonymousOrLambda(FInterface fi){
        System.out.println("===Executing method arg instantiated with Lambda==="));
    }

    public static void main(){
        // calls a method having FInterface as an argument.
        funcUsesAnonymousOrLambda(new FInterface() {

            int callMeLambda(String temp){ //define callMeLambda(){} here..
                return 0;
            }
        }
    }

/***********Can be replaced by Lambda below*********/
        funcUsesAnonymousOrLambda( (x) -> {
            return 0; //(1)
        }

    }

FInterface fi = (x) -> { return 0; };

funcUsesAnonymousOrLambda(fi);

Aici mai sus poate fi văzut, cum o expresie lambda poate fi înlocuit cu o interfață.

De mai sus explică o anumită utilizare de expresie lambda, există mai multe. ref https://stackoverflow.com/questions/23451579/java-8-lambda-within-a-lambda-cant-modify-variable-from-outer-lambda