functional - ¿Puede un lambda java tener más de 1 parámetro?

lambda stream java

Question

En Java, ¿es posible que una lambda acepte múltiples tipos diferentes?

Es decir: la variable única funciona:

    Function <Integer, Integer> adder = i -> i + 1;
    System.out.println (adder.apply (10));

Varargs también funciona:

    Function <Integer [], Integer> multiAdder = ints -> {
        int sum = 0;
        for (Integer i : ints) {
            sum += i;
        }
        return sum;
    };

    //.... 
    System.out.println ((multiAdder.apply (new Integer [] { 1, 2, 3, 4 })));

Pero quiero algo que pueda aceptar muchos tipos diferentes de argumentos, por ejemplo:

    Function <String, Integer, Double, Person, String> myLambda = a , b, c, d->  {
    [DO STUFF]
    return "done stuff"
    };

El uso principal es tener pequeñas funciones en línea dentro de las funciones para mayor comodidad.

Revisé google e inspeccioné el paquete de funciones de Java, pero no pude encontrarlo. es posible?

Answer 1

Es posible si define una interfaz tan funcional con múltiples parámetros de tipo. No existe tal tipo incorporado. (Hay algunos tipos limitados con múltiples parámetros).

@FunctionalInterface
interface Function<One, Two, Three, Four, Five, Six> {
    public Six apply(One one, Two two, Three three, Four four, Five five);
}

public static void main(String[] args) throws Exception {
    Function<String, Integer, Double, Void, List<Float>, Character> func = (a, b, c, d, e) -> ''z'';
}

Tampoco hay forma de definir un número variable de parámetros de tipo, si eso es lo que estaba preguntando.

Algunos idiomas, como Scala, definen una serie de tipos incorporados, con 1, 2, 3, 4, 5, 6, etc. parámetros de tipo.

Answer 2

Otra alternativa, no estoy seguro de si esto se aplica a su problema particular, pero para algunos puede ser aplicable es usar UnaryOperator en la biblioteca java.util.function. donde devuelve el mismo tipo que especifique, por lo que coloca todas sus variables en una clase y es como un parámetro:

@FunctionalInterface
public interface FiveParameterConsumer<T, U, V, W, X> {
    public void accept(T t, U u, V v, W w, X x);
}

Entonces, la clase que tiene, en este caso Person , puede tener numerosas variables de instancia y no tendrá que cambiar el parámetro de su expresión lambda.

Para aquellos interesados, he escrito notas sobre cómo usar la biblioteca java.util.function: http://sysdotoutdotprint.com/index.php/2017/04/28/java-util-function-library/

Answer 3

Para algo con 2 parámetros, puede usar BiFunction . Si necesita más, puede definir su propia interfaz de función, así:

@FunctionalInterface
public interface FourParameterFunction<T, U, V, W, R> {
    public R apply(T t, U u, V v, W w);
}

Si hay más de un parámetro, debe poner paréntesis alrededor de la lista de argumentos, así:

FourParameterFunction<String, Integer, Double, Person, String> myLambda = (a, b, c, d) -> {
    // do something
    return "done something";
};

Answer 4

Para este caso, podría usar interfaces de la biblioteca predeterminada (java 1.8):

java.util.function.BiConsumer
java.util.function.BiFunction

Hay un pequeño (no el mejor) ejemplo de método predeterminado en la interfaz:

default BiFunction<File, String, String> getFolderFileReader() {
    return (directory, fileName) -> {
        try {
            return FileUtils.readFile(directory, fileName);
        } catch (IOException e) {
            LOG.error("Unable to read file {} in {}.", fileName, directory.getAbsolutePath(), e);
        }
        return "";
    };
}}

Answer 5

Para hacer uso de lambda: Hay tres tipos de operación:
1. Aceptar parámetro -> Consumidor
2. Pruebe el parámetro return boolean -> Predicate
3. Manipular parámetro y valor de retorno -> Función

Interfaz funcional Java hasta dos parámetros:
Interfaz de parámetro único
Consumidor
Predicado
Función

Interfaz de dos parámetros
BiConsumer
BiPredicate
BiFunción

Para más de dos , debe crear una interfaz funcional de la siguiente manera (tipo de consumidor):

public class FunctionsLibraryUse {

    public static void main(String[] args){
        UnaryOperator<People> personsBirthday = (p) ->{
            System.out.println("it''s " + p.getName() + " birthday!");
            p.setAge(p.getAge() + 1);
            return p;
        };
        People mel = new People();
        mel.setName("mel");
        mel.setAge(27);
        mel = personsBirthday.apply(mel);
        System.out.println("he is now : " + mel.getAge());

    }
}
class People{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

Answer 6

También puede usar la biblioteca jOOL: https://github.com/jOOQ/jOOL

Ya ha preparado interfaces de funciones con diferentes números de parámetros. Por ejemplo, puede usar org.jooq.lambda.function.Function3 , etc. desde Function0 hasta Function16 .