java - programacion - Buena forma de convertir Opcional<Integer> a Opcional<Long>

manual de programacion android pdf

Question

Estoy tratando de encontrar una forma limpia y eficiente de código para convertir el Optional<Integer> Optional<Long> . Estoy trabajando en Java 7 con guayaba.

Así que en un lugar en el código tengo un entero opcional creado

    Optional<Integer> optionalInt = Optional.fromNullable(someInt);

Y en otra área lo necesito como un largo opcional. Lo mejor que se me ocurre es esto:

    Optional<Long> optionalLong = optionalInt.transform(new Function<Integer, Long>() {
        @Override
        public Long apply(Integer inputInt) {
            if (inputInt != null)
                return inputInt.longValue();
            else
                return null;
        }
    });

Pero esto es engorroso, especialmente si consideras lo fácil que fue convertir el tipo cuando estaba usando tipos primitivos.

¿Alguna buena idea por ahí?

Answer 1

TL; DR: En Java 7, No.

Lamentablemente, esto es lo mejor que Java 7 tiene para ofrecer en términos de soporte para funciones.

Solo diría que nunca se llamará transform con null así que puedes hacer:

Optional<Long> optionalLong = optionalInt.transform(new Function<Integer, Long>() {
    @Override
    public Long apply(Integer inputInt) {
        return inputInt.longValue();
    }
});

De la documentación :

Si la instancia está presente, se transforma con la Function dada; De lo contrario, se devuelve absent() . Si la función devuelve null , se lanza una NullPointerException .

Por lo tanto, nunca devuelva el null de una Function pasada a transform .

Si reutiliza esto mucho, entonces podría usar el patrón de enum singleton:

public enum IntToLong implements Function<Integer, Long> {

    INSTANCE;

    @Override
    public Long apply(Integer input) {
        return input.longValue();
    }
}

Entonces:

optionalInt.transform(IntToLong.INSTANCE);

Obviamente, esto reduce el código en el sitio de la llamada a expensas de tener clases adicionales en el código base, algo de lo que no estaría demasiado preocupado.

Answer 2

cerca del reparto:

Optional<Long> optionalLong = Optional.fromNullable(optionalInt.isPresent() ?
     optionalInt.get().longValue() : null);

Básicamente esto evita la sobrecarga de invocar la transformación. La invocación de isPresent se podría simplificar para verificar el valor de nulo directamente.