Essayez ceci comme expression lambda comme argument

Concept d'expression Lambda comme argument :

• Une expression lambda peut être passée en argument dans les méthodes qui acceptent des types cibles compatibles.
• Ceci est utile car cela vous permet de passer du code exécutable comme argument, rendant le code plus expressif.

Exemple d'objectif :

• Créez des fonctions de manipulation de chaînes (inverser, inverser la casse des lettres et remplacer les espaces par des traits d'union) à l'aide d'expressions lambda.
• Ces expressions sont transmises à la méthode changeStr(), qui applique les fonctions et renvoie le résultat.

Structure de l'interface fonctionnelle :

• Définissez l'interface StringFunc avec une méthode func(String str), qui accepte et renvoie une String.

Définition de la méthode changeStr() :
La méthode changeStr() prend deux paramètres :
Un paramètre de type StringFunc (interface fonctionnelle).
Une chaîne à manipuler.
La méthode applique la fonction d'interface à la chaîne et renvoie le résultat.

Utilisation de l'expression Lambda :
Exemple 1 : Expression Lambda qui inverse les caractères d'une chaîne et l'affecte à la variable inverse.

Passe l'expression lambda à changeStr() pour inverser la chaîne.

Exemple 2 : Expression Lambda qui remplace les espaces par des traits d'union et est transmise directement à changeStr().

Exemple 3 : Bloquer l'expression lambda qui inverse la casse des lettres dans une chaîne et est également transmise directement à changeStr().

Exemple de code complet :
Voici le code complet qui montre comment transmettre des expressions lambda à la méthode changeStr() :

interface StringFunc {
    String func(String str);
}

class LambdaArgumentDemo {
    static String changeStr(StringFunc sf, String s) {
        return sf.func(s);
    }

    public static void main(String args[]) {
        String inStr = "Lambda Expressions Expand Java";
        String outStr;
        System.out.println("Here is input string: " + inStr);

        // Expressão lambda para inverter a string
        StringFunc reverse = (str) -> {
            String result = "";
            for (int i = str.length() - 1; i >= 0; i--)
                result += str.charAt(i);
            return result;
        };

        // Passando a expressão lambda 'reverse' para o método
        outStr = changeStr(reverse, inStr);
        System.out.println("The string reversed: " + outStr);

        // Expressão lambda para substituir espaços por hífens
        outStr = changeStr((str) -> str.replace(' ', '-'), inStr);
        System.out.println("The string with spaces replaced: " + outStr);

        // Expressão lambda para inverter a caixa das letras
        outStr = changeStr((str) -> {
            String result = "";
            char ch;
            for (int i = 0; i < str.length(); i++) {
                ch = str.charAt(i);
                if (Character.isUpperCase(ch))
                    result += Character.toLowerCase(ch);
                else
                    result += Character.toUpperCase(ch);
            }
            return result;
        }, inStr);
        System.out.println("The string in reversed case: " + outStr);
    }
}

Résultat attendu :

Here is input string: Lambda Expressions Expand Java
The string reversed: avaJ dnapxE snoisserpxE adbmaL
The string with spaces replaced: Lambda-Expressions-Expand-Java
The string in reversed case: lAMBDA eXPRESSIONS eXPAND jAVA

Observations :
Passer des expressions lambda directement comme arguments aux méthodes augmente la flexibilité et la lisibilité du code.
L'expression lambda qui inverse la casse des lettres est plus complexe, mais peut toujours être transmise directement dans la méthode. En général, les lambdas plus complexes sont mieux attribués aux variables.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!