¿Cómo puede encadenar I llamadas funcionales en Java?

Max Zofal:

Tengo dos piezas similares de código:

void task1() {
    init();
    while(someCondition) {
      doSomething();
    }
    shutdown();
  }

void task2() {
    while(someCondition) {
      init();
      doSomething();
      shutdown();
    }
  }

Me gustaría evitar la duplicación de código y pensé que esto podría hacerse mediante el uso de un enfoque funcional. Quiero poner el lazo y el inicio de llamada / apagado en funciones separadas y luego encadeno sus llamadas (no la interfaz para funciones de Java 8, más pseudocódigo):

Function setup(Function f){
    init();
    f();
    shutdown();
}

Function loop(Function f){
    while(someCondition) {
      f();
    }
}

Entonces quiero cadena de éstos como esto:

void task1() {
   setup(loop(doSomething));
 }

void task2() {
    loop(setup(doSomething));
  }

Pensé en componer / andthen en la interfaz de funciones de Java, pero que no son adecuados, ya que sólo la mano sobre el valor de retorno de una función a la siguiente. ¿Alguien tiene una idea de cómo hacer esto con Java 8 o con un enfoque diferente?

barredora:

De hecho puede hacer esto. Es necesario Runnable, no Function, ya que sus métodos no aceptan parámetros y devuelven ningún valor. Si sus métodos tienen una firma diferente, sin embargo, es necesario utilizar otro tipo.

public static void init() { ... }
public static void doSomething() { ... }
public static void shutdown() { ... }

public static Runnable setup(Runnable r) {
    return () -> {
        init();
        r.run();
        shutdown();
    };
}

public static Runnable loop(Runnable r) {
    return () -> {
        while (someCondition) {
            r.run();
        }
    };
}

// I used "Main" here because this in a class called Main. Replace "Main" with the name of your class
public static void task1() {
    setup(loop(Main::doSomething)).run();
}

public static void task2() {
    loop(setup(Main::doSomething)).run();
}

También hay que señalar que, aunque a los ojos de un programador funcional, el primer código podría ser "duplicado", a los programadores de Java, el primer código es muy bien como está. La reescritura de esta manera podría ser más confuso para las personas que no están acostumbrados al estilo funcional.