Realización misma operación en múltiples funciones

lopoto:

Tengo una clase con múltiples getfunciones, tales como getF1a getF10. Quiero, para cada uno de estos captadores, para reemplazar la letra "x"a una "a"(ejemplo al azar). El comprador puede devolver un valor nulo.

Hasta el momento, esto es lo que he hecho y funciona, ¿hay alguna manera de conseguir algo mejor pinta que esta?

public void foo(final MyObject bar) {
    Optional.of(bar).map(MyObject::getF1).ifPresent(s -> bar.setF1(s.replaceAll("x", "a"));
    Optional.of(bar).map(MyObject::getF2).ifPresent(s -> bar.setF2(s.replaceAll("x", "a")));
    ...
    Optional.of(bar).map(MyObject::getF10).ifPresent(s -> bar.setF10(s.replaceAll("x", "a")));
}

Estaba pensando en algo como esto, el uso de una lista, obviamente, este código es incorrecto, pero se entiende la idea:

public void foo(final MyObject bar) {
    List<Function> func = new ArrayList<Function>();
    func.addAll(Arrays.asList(MyObject::getF1, MyObject::getF2, ..., MyObject::getF10));
    Optional.of(bar).map(func).ifPresent(s -> func(s.replaceAll("x", "a"));
}

Tal vez se trabaja con una corriente podría hacer el trabajo?

¡Gracias!

Nikolas:

Puede almacenar los creadores de mapas utilizados en Optional::maplos consumidores utilizan en Optional::ifPresentuna Map.

También recomiendo que le permite crear un método para evitar la duplicación de código para la sustitución de cuerdas que se llamará fácilmente. Esto es útil ya que todos los reemplazos son los mismos

private String replaced(String string) {
    return string.replaceAll("x", "a");
}

Después, simplemente iterar sobre las entradas y aplicar cada uno de los pares de valores clave (el orden no importa):

Map<Function<? super MyObject, ? extends String>, Consumer<? super String>> map = new HashMap<>();
map.put(MyObject::getF1, bar::setF1);
map.put(MyObject::getF2, bar::setF2);
map.put(MyObject::getF10, bar::setF10);
// ...

map.forEach((function, consumer) -> {
        Optional.of(bar).map(function).map(this::replaced).ifPresent(consumer);
});

---

Si desea extender este mecanismo y aplicar una función diferente a cada cadena que se pasa a la incubadora, entonces también es necesario utilizar una estructura diferente:

public final class Mapping {

    private final Function<MyObject, String> getterFunction;
    private final Function<String, String> transformationFunction;
    private final Consumer<String> setterFunction;

    public Mapping(final Function<MyObject, String> getterFunction, final Function<String, String> transformationFunction,
        final Consumer<String> setterFunction) {
        this.getterFunction = getterFunction;
        this.transformationFunction = transformationFunction;
        this.setterFunction = setterFunction;
    }

    // getters
}

Y el uso es similar (las funciones de transformación son ejemplos y pueden variar):

List<Mapping> list = new ArrayList<>();
list.add(new Mapping(MyObject::getF1, s -> s.replaceAll("x", "a"), bar::setF1));
list.add(new Mapping(MyObject::getF2, s -> s.replaceAll("x", "a"), bar::setF2));
list.add(new Mapping(MyObject::getF10, s -> s.replaceAll("x", "a"), bar::setF10));

list.forEach(mapping -> {
    Optional.of(bar)
            .map(mapping.getGtterFunction)
            .map(mapping.getTransformationFunction)
            .ifPresent(mapping.getSetterFunction);
});