Try This as a lambda expression as an argument

Lambda Expression Concept as Argument:

• A lambda expression can be passed as an argument in methods that accept compatible target types.
• This is useful as it allows you to pass executable code as an argument, making the code more expressive.

Example Objective:

• Create string manipulation functions (invert, reverse case of letters and replace spaces with hyphens) using lambda expressions.
• These expressions are passed to the changeStr() method, which applies the functions and returns the result.

Functional Interface Structure:

• Define the StringFunc interface with a method func(String str), which accepts and returns a String.

Definition of the changeStr() Method:
The changeStr() method takes two parameters:
A parameter of type StringFunc (functional interface).
A String to be manipulated.
The method applies the interface function to the String and returns the result.

Use of Lambda Expression:
Example 1: Lambda expression that reverses the characters of a string and assigns it to the reverse variable.

Passes the lambda expression to changeStr() to reverse the string.

Example 2: Lambda expression that replaces spaces with hyphens and is passed directly to changeStr().

Example 3: Block lambda expression that reverses the case of letters in a string and is also passed directly to changeStr().

Full Code Example:
Following is the complete code that shows how to pass lambda expressions to the changeStr() method:

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);
    }
}

Expected Output:

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:
Passing lambda expressions directly as arguments to methods increases code flexibility and readability.
The lambda expression that reverses the case of letters is more complex, but can still be passed directly into the method. In general, more complex lambdas are better assigned to variables.

The above is the detailed content of Try This as a lambda expression as an argument. For more information, please follow other related articles on the PHP Chinese website!