uso dei consumatori specifici per tipo di elemento con Java 8 flusso

Question

Sto avendo un flusso Java 8 di numeri:

Stream<Number> numbers = ...; 

mi piacerebbe iterare il flusso e invocare un consumatore specifico in base al tipo di ciascun elemento. Cioè per Integer elementi Vorrei richiamare un Consumer<Integer>, per Long un Consumer<Long> ecc

C'è il metodo forEach() ma questo prevede un Consumer<? super Number>, richiede che l'attuazione (solitamente un'espressione lambda) per InstanceOf-interruttore del tipo esatto si. ci

numbers.forEach(callbacks -> { 
    callbacks.on(Integer.class, i -> { /* handle Integer */ }); 
    callbacks.on(Long.class, l -> { /* handle Long */ }) 
}); 

è un qualsiasi API esistente che mi avrebbe permesso di registrare un consumatore specifico per elemento flusso sub-tipo in un modo:

In termini di un'API, sto essenzialmente alla ricerca di qualcosa di simile simile a questo?

Answer 1

Sei sicuro di non voler eseguire lo stream due volte? Sarà più leggibile.

Ma se si vuole, è possibile definire un consumatore tipo di controllo in questo modo:

public static<T> Consumer<Object> acceptType(Class<T> clazz, Consumer<? super T> cons) { 
    return t -> { 
     if (clazz.isInstance(t)) { 
      cons.accept(clazz.cast(t)); 
     } 
    }; 
} 

È quindi possibile combinare più i consumatori utilizzando andThen:

Consumer<Object> combined = acceptType(Integer.class, i -> ...) 
        .andThen(acceptType(Long.class, lng -> ...)) 

Se si desidera nascondere andThen, puoi definire

static<T> Consumer<T> doAll(Consumer<T>... consumers) { 
    return Arrays.stream(consumers) 
      .reduce(Consumer::andThen) 
      .orElse(t -> {}); 
} 

Quindi diventa

nums.forEach(doAll(
      acceptType(Integer.class, i -> ...), 
      acceptType(Long.class, lng -> ..), 
      ... 
)); 

Answer 2

Non so di queste built-in, ecco un'opzione: Raccogliere tutti i Consumer s in un Map digitato dal tipo che consuma, e cercare il consumatore giusto. Consiglierei questa soluzione se lavori con molti tipi e questi tipi possono cambiare dinamicamente. La soluzione più efficiente (per consumo di CPU) sarebbe probabilmente quella di utilizzare switch su item.getType().

public class Casts { 
    public static void main(String[] args) { 

     Stream<Number> stream = Arrays.stream(new Number[] { 3, 4L }); 

     Map<Class<?>, Consumer<? super Number>> consumers = new HashMap<>(); 
     putCastConsumer(consumers, Long.class, 
       i -> System.out.println("Mapped long " + i)); 
     putCastConsumer(consumers, Integer.class, 
       i -> System.out.println("Mapped int " + i)); 

     consumeByType(stream, consumers); 
    } 

    public static <U, T extends U> void putCastConsumer(
      final Map<Class<?>, Consumer<? super U>> map, 
      final Class<T> clazz, 
      final Consumer<T> consumer) { 
     map.put(clazz, value -> consumer.accept(clazz.cast(value))); 
    } 

    public static <T> void consumeByType(
      final Stream<T> stream, 
      final Map<Class<?>, Consumer<? super T>> consumers) { 
     stream.forEach(item -> consumers.get(item.getClass()).accept(item)); 
    } 
}