valor de ajuste por defecto de objeto anidado opcional con colocador en OrElse clasue

Martin:

Quiero comprobar el valor de una clase adaptador que es objeto anidado en la clase de dispositivo que se parece a:

@Setter
@Getter
public class Device {
    private Optional<Socket> socket;
}

Socket se ve así:

@Setter
@Getter
public class Socket {
    private Optional<Adapter> adapter = Optional.empty();
}

Adaptadoras se ve así:

@Setter
@Getter
@AllArgsConstructor
public class Adapter {
    public String name;
}

y en caso de que sea conjunto vacío un valor predeterminado para un campo name.

Mi método se parece a:

public static Optional<Adapter> checkAdapterNameOrSetDefaultValue(Optional<Device> device) {
return device
        .flatMap(Device::getSocket)
        .ifPresent(d -> d.getAdapter().orElse(d.setAdapter(Optional.of(new Adapter("DDD")))));
}

Al parecer, podría funcionar, pero IntelliJ quejarse de la parte colocador sea nulo:

d.setAdapter(Optional.of(new Adapter("DDD")))

con un mensaje:

orElse Adapter in Optional cannot be applied to (void)

Aquí surge la cuestión de si es posible emitir el tipo void en Opcional en este caso de manera que los tipos son compatibles entre sí o establecer el nombre predeterminado de una manera diferente.

Andrew Tobilko:

Me he dado cuenta de un par de problemas aquí.

1. No es usada Optionalpor tener Optionalcampos.
2. Mal uso Optionalpasándolo como un argumento método.
3. checkAdapterNameOrSetDefaultValuesuena como un voidmétodo. Ni checktampoco setimplica devolver un valor.

Dejando a un lado estos, he aquí una forma sencilla de lograrlo.

public static void checkAdapterNameOrSetDefaultValue(Optional<Device> device) {
    if (device.isPresent()) {
        final Optional<Socket> optionalSocket = device.get().getSocket();
        if (optionalSocket.isPresent()) {
            final Socket socket = optionalSocket.get();
            if (socket.getAdapter().isEmpty()) {
                socket.setAdapter(Optional.of(new Adapter("DDD"));
            }
        }
    }
}

Una versión de lujo sería

device.flatMap(Device::getSocket).ifPresent(socket -> {
    if (socket.getAdapter().isEmpty()) {
        socket.setAdapter(Optional.of(new Adapter("DDD")));
    }
});

¿es posible envolver el resultado de la versión de lujo para la clase adaptador?

Sí, pero yo no soy partidario de este tipo de cosas.

public static Optional<Adapter> checkAdapterNameOrSetDefaultValue(Optional<Device> device) {
    final Adapter defaultAdapter = new Adapter("DDD");

    return Optional.of(device
            .flatMap(Device::getSocket)
            .map(d -> {
                if (d.getAdapter().isEmpty()) {
                    d.setAdapter(Optional.of(defaultAdapter));
                    return defaultAdapter;
                }
                return d.getAdapter().get();
            })
            .orElseGet(() -> defaultAdapter));
}