Tente Isto 14-1 Passe uma expressão lambda como argumento

Conceito de Expressão Lambda como Argumento:

• Uma expressão lambda pode ser passada como argumento em métodos que aceitam tipos de destino compatíveis.
• Isso é útil, pois permite passar código executável como argumento, tornando o código mais expressivo.

Objetivo do Exemplo:

• Criar funções de manipulação de strings (inverter, inverter caixa de letras e substituir espaços por hífens) usando expressões lambda.
• Essas expressões são passadas para o método changeStr(), que aplica as funções e retorna o resultado.

Estrutura da Interface Funcional:

• Definir a interface StringFunc com um método func(String str), que aceita e retorna um String.

Definição do Método changeStr():
O método changeStr() recebe dois parâmetros:
Um parâmetro do tipo StringFunc (interface funcional).
Um String a ser manipulado.
O método aplica a função da interface no String e retorna o resultado.

Uso de Expressão Lambda:
Exemplo 1: Expressão lambda que inverte os caracteres de uma string e a atribui à variável reverse.

Passa a expressão lambda para changeStr() para inverter a string.

Exemplo 2: Expressão lambda que substitui espaços por hífens e é passada diretamente para changeStr().

Exemplo 3: Expressão lambda de bloco que inverte a caixa das letras de uma string e também é passada diretamente para changeStr().

Exemplo Completo de Código:
A seguir está o código completo que mostra como passar expressões lambda para o método 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);
    }
}

Saída Esperada:

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

Observações:
Passar expressões lambda diretamente como argumento para métodos aumenta a flexibilidade e legibilidade do código.
A expressão lambda que inverte a caixa das letras é mais complexa, mas ainda pode ser passada diretamente no método. Em geral, lambdas mais complexas são melhor atribuídas a variáveis.