son - java 8 lambdas pdf

¿Equivalente para las funciones lambda de Python en Java?

Question

¿Puede alguien decirme si hay un equivalente para las funciones lambda de Python en Java?

Answer 1

Algo similar a la de Zifre, podría crear una interfaz así

public interface myLambda<In, Out> {
    Out call(In i);
}

para permitirte escribir, di

Function<MyObj, Boolean> func = new Function<MyObj, Boolean>() {
    public Boolean callFor(myObj obj) {
        return obj.canDoStuff();
    };

MyObj thing = getThing;

if (func.callFor(thing)) {
    doSomeStuff();
} else {
    doOtherStuff();
}

Todavía es un poco confuso, sí, pero al menos tiene entrada / salida.

Answer 2

Como ya se señaló, las expresiones lambda se introdujeron en Java 8.

Si viene de Python, C # o C ++, vea el excelente ejemplo de Adrian D. Finlay, que personalmente me parece mucho más fácil de entender que la documentación oficial .

Este es un vistazo rápido basado en el ejemplo de Adrian, creado usando un cuaderno jupyter con el kernel python y el kernel java IJava .

Pitón:

# lambda functions
add = lambda x, y : x + y
multiply = lambda x, y : x * y
# normal function. In python, this is also an object.
def add_and_print_inputs(x, y):
    print("add_and_print inputs : {} {}".format(x,y))
    return x + y
print(add(3,5), multiply(3,5), add_and_print_inputs(3,5))

Salida:

add_and_print inputs : 3 5
8 15 8

Las funciones lambda de Java pueden ser multilínea, mientras que en Python son una sola declaración. Sin embargo no hay ventaja aquí. En Python, las funciones regulares también son objetos. Se pueden agregar como parámetros a cualquier otra función.

# function that takes a normal or lambda function (myfunc) as a parameter
def double_result(x,y,myfunc):
    return myfunc(x,y) * 2
double_result(3,5,add_and_print_inputs)

Salida:

add_and_print inputs : 3 5
16

Java:

// functional interface with one method
interface MathOp{
    int binaryMathOp(int x, int y);
}
// lambda functions
MathOp add = (int x, int y) -> x + y;
MathOp multiply = (int x, int y) -> x * y;
// multiline lambda function
MathOp add_and_print_inputs = (int x, int y) -> {
    System.out.println("inputs : " + x + " " + y);
    return x + y;};// <- don''t forget the semicolon
// usage
System.out.print("" +
add.binaryMathOp(3,5) + " " +
multiply.binaryMathOp(3,5) + " " + 
add_and_print_inputs.binaryMathOp(3,5))

Salida:

inputs : 3 5
8 15 8

Y cuando se usa como parámetro:

// function that takes a function as a parameter
int doubleResult(int x, int y, MathOp myfunc){
    return myfunc.binaryMathOp(x,y) * 2;
}
doubleResult(3,5,add_and_print_inputs)

Salida:

inputs : 3 5
16

Answer 3

Con el lanzamiento de Java 8 , lambda-expresión ya está disponible. Y la función lambda en java es en realidad "más poderosa" que las de python.

En Python, lambda-expresión solo puede tener una única expresión para su cuerpo, y no se permite ninguna declaración de return . En Java, puedes hacer algo como esto: (int a, int b) -> { return a * b; }; (int a, int b) -> { return a * b; }; y otras cosas opcionales también.

Java 8 también introduce otra interfaz llamada Function Interface . Es posible que desee comprobar eso también.

Answer 4

Desafortunadamente, no hay lambdas en Java hasta que Java 8 introdujo Lambda Expressions . Sin embargo, puedes obtener casi el mismo efecto (de una manera realmente fea) con clases anónimas:

interface MyLambda {
    void theFunc(); // here we define the interface for the function
}

public class Something {
    static void execute(MyLambda l) {
        l.theFunc(); // this class just wants to use the lambda for something
    }
}

public class Test {
    static void main(String[] args) {
        Something.execute(new MyLambda() { // here we create an anonymous class
            void theFunc() {               // implementing MyLambda
                System.out.println("Hello world!");
            }
        });
    }
}

Obviamente, estos tendrían que estar en archivos separados :(

Answer 5

No creo que exista un equivalente exacto, sin embargo, hay clases anónimas que son lo más cercanas que puedes obtener. Pero sigue siendo bastante diferente. Joel Spolsky escribió un artículo sobre cómo los estudiantes que solo enseñan Java se están perdiendo estas bellezas de la programación de estilo funcional: ¿Puede su lenguaje de programación hacer esto? .

Answer 6

Sí,

Las expresiones Lambda se introducen en java desde java8.

La sintaxis básica para las expresiones lambda son:

(parameters)->
{
  statements;
}

Ejemplo

(String s)->
{
System.out.println(s);
}

Revisa este enlace:

http://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

Answer 7

Una idea se basa en una public interface Lambda<T> genérica public interface Lambda<T> : consulte http://www.javalobby.org/java/forums/t75427.html .