[JAVA] Einführung in den Lambda-Stil

Warum den Lambda-Ausdruck verwenden?

Java, das für die groß angelegte Entwicklung verwendet wird, ist erforderlich, um die Codemenge so weit wie möglich zu reduzieren und das Lesen zu erleichtern. Der in Java 8 verwendete "Lambda-Ausdruck" ist für solche Gelegenheiten nützlich. Ein Merkmal von Lambda-Ausdrücken ist, dass Sie Methoden wie Variablen behandeln können.

Wie schreibt man:

[Schnittstellendeklaration]= (Streit)->{Ausführungsblock}

Lassen Sie uns sofort aus dem Quellcode überprüfen. Zunächst der traditionelle Ausdruck:

public class LambdaTest {

    public static void main(String[] args) {
        //Traditioneller Ausdruck
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("threading" + Thread.currentThread().getId());
            }
        }).start();
    }
}

Das Folgende ist eine Darstellung des Lambda-Ausdrucks.

public class LambdaTest {

    public static void main(String[] args) {
        //Lambda-Ausdruck
        new Thread(() -> {
            System.out.println("Lambda threading" + Thread.currentThread().getId());
        }).start();
    }
}

Java-Funktionsschnittstelle

Die funktionale Schnittstelle von Java ist fast dieselbe wie eine herkömmliche Schnittstelle, aber das einzige Merkmal ist, dass die funktionale Schnittstelle "eine Schnittstelle mit nur einer definierten abstrakten Methode" ist. Es spielt keine Rolle, ob statische Methoden oder Standardmethoden enthalten sind. (Es ist eine gute Idee, die Annotation java.lang.FunctionalInterface hinzuzufügen.)

Weitere Informationen zur Java-Funktionsoberfläche finden Sie in der ausführlichen Einführung. https://qiita.com/Jenny1025/items/470e304ff77c44874fc8

Beispiel:

@FunctionalInterface
public interface UserIdentify {
    String verifyUser(String userName);
}

Vorteile der Lambda-Formel

Der Vorteil des Lambda-Ausdrucks von Java besteht darin, dass die Beschreibung funktionaler Schnittstellen mithilfe anonymer Klassen vereinfacht werden kann.

• Anonyme Klasse: Eine Klasse, die nicht nur einmal verwendet wird

Anonyme Klasse:

public class App 
{
    public static void main( String[] args ) {

        //Funktionsschnittstelle
        UserIdentify ic = new UserIdentify() {
            @Override
            public String verifyUser(String userName) {
                return "admin".equals(userName)? "admin":"member";
            }
        };

        System.out.println(ic.verifyUser("admin"));
        System.out.println(ic.verifyUser("manager"));
        }
    }

Wie drückt man es in der Lambda-Formel aus?

public class App {
    public static void main( String[] args ) {
        
        UserIdentify ic1 = (String userName) -> {
                return "admin".equals(userName)? "admin":"member";
            };
        System.out.println(ic1.verifyUser("admin"));
        System.out.println(ic1.verifyUser("manager"));
        }
    }

Insbesondere Erklärung, wie ein Lambda-Ausdruck geschrieben wird

1. Deklaration: Schnittstellentyp im Lambda-Stil
2. Argumente: Geben Sie in () ein. Entspricht der Anzahl und Reihenfolge der Schnittstellenargumente
3. Ausdruck: ->
4. Ausführungsblock: Implementieren in {}

Beginnen wir mit einem konkreten Beispiel.

Keine Argumente, kein Rückgabewert

public class App {
    public static void main( String[] args ) {

        //Keine Argumente, kein Rückgabewert
        Lambda1 lambda1 = () -> System.out.println("Hello world");
        lambda1.test();
    }
    interface Lambda1 {
        void test();
    }
}

Implementierungsergebnis: Hallo Welt

Mit Argument kein Rückgabewert

public class App {
    public static void main( String[] args ) {

        //Mit Argument kein Rückgabewert
        Lambda2 lambda2 = (n, a) -> System.out.println(n + " is " + a + " years old");
        lambda2.test("Sally",18);
    }
    interface Lambda2 {
        void test(String name, Integer age);
    }
}

Implementierungsergebnis: Sally ist 18 Jahre alt

Mit Argument, mit Rückgabewert

public class App {
    public static void main( String[] args ) {

        //Mit Argument, mit Rückgabewert
        Lambda3 lambda3 = (a, b) -> a + b;
        System.out.println(lambda3.test(100,3000));
    }
    interface Lambda3 {
        int test(int a, int b);
    }
}

Implementierungsergebnis: 3100