buon modo per convertire opzionale <Integer> per opzionale <Long>

Question

Sto cercando di trovare un modo pulito e il codice-efficiente per convertire Optional<Integer> a Optional<Long>. Sto lavorando in Java 7 con Guava.

Quindi, in un unico luogo nel codice che ho un intero opzionale creato

E in un'altra zona ne ho bisogno come un lungo opzionale. La cosa più bella che potrei venire in mente è questa:

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

Ma questo è ingombrante, soprattutto se si considera quanto sia stato facile per lanciare il tipo di quando stavo usando tipi primitivi.

Qualche buona idea là fuori?

Answer 1

TL; DR: In Java 7, n

Purtroppo questo è il migliore Java 7 ha da offrire in termini di supporto per le funzioni.

vorrei solo dire che transform non verrà mai chiamato con null modo da poter fare:

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

Da the documentation:

Se l'istanza è presente, si trasforma con il dato Function; altrimenti, viene restituito absent(). Se la funzione restituisce null, viene generato un valore NullPointerException.

Così mai ritorno null da un Function passato al transform.

Se si riutilizza questo molto, allora si potrebbe utilizzare il modello enum Singleton:

public enum IntToLong implements Function<Integer, Long> { 

    INSTANCE; 

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

Poi:

optionalInt.transform(IntToLong.INSTANCE); 

Questo riduce, ovviamente, il codice sul sito chiamata a scapito di avere classi extra nella base di codice - qualcosa di cui non sarei troppo preoccupato.

Answer 2

vicino al getto:

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

fondamentalmente questo evita il sovraccarico di invocare trasformata. Invocare isPresent potrebbe essere semplificato per controllare direttamente il valore per null.