Gestione di un attributo null utilizzando java 8 stream e ordinamento utilizzando espressioni lambda

Question

Consideriamo una classe Parent che contiene solo un attributo Integer. Ho creato 6 oggetti di classe genitore e i valori di attributo sono 100, 20, 300, 400, 500, null.

Ora ho aggiunto tutti gli oggetti a un elenco (il nome dell'elenco è l'elenco). Quindi voglio ottenere gli oggetti il ​​cui valore attributo è maggiore di 100. Ho usato Java 8 stream per questo scopo.

Predicate<Entity> predicate = e -> e.getParentId() < 100; 
result = list.stream().filter(predicate).collect(Collectors.toList()); 

Voglio anche ordinare l'elenco in ordine decrescente. Ho usato il seguente codice per questo scopo.

Comparator<Entity> comp = (d1,d2) -> d2.getId().compareTo(d1.getId()); 
list.sort(comp); 

In entrambi i casi ottengo uno NullPointerException.

Come gestirlo?

Answer 1

Provare pre-filtraggio per soli non nulli parentId valori:

result = list.stream().filter(e -> e.getParentId() != null).filter(predicate).collect(Collectors.toList()); 

[modifica] appena visto, che l'attributo (e.parentId) sembra quello di essere null. In tal caso, la seconda cosa, l'ordinamento, si interrompe. Stai ordinando l'elenco originale, non quello filtrato. Prova result.sort(comp), quindi dovresti evitare l'NPE.

Answer 2

si può fare:

Predicate<Entity> predicate = e -> e.getParentId() < 100; 
Predicate<Entity> nonNull = e -> e != null; 
result = list.stream().filter(nonNull) 
         .filter(predicate) 
         .collect(Collectors.toList()); 

Naturalmente, si potrebbe combinare i predicati in una sola, ma ho introdotto un secondo per una migliore leggibilità. Inoltre, sei libero di modificare il predicato nonNull per controllare l'intera entità o solo l'attributo id (o anche entrambi). Gioca un po 'con quello. :)

Answer 3

si può fare tutto in una Stream Pipeline:

List<Entity> result = 
    list.stream() 
     .filter(e -> e.getParentId()!=null) // it's not clear if the null 
              // is the Entity object itself 
              // (in which case it should be e!=null) 
              // or just the ParentId member 
     .filter(predicate) 
     .sorted(comp) 
     .collect(Collectors.toList()); 

BTW, secondo il testo della tua domanda, il predicato originale dovrebbe essere:

Predicate<Entity> predicate = e -> e.getParentId() > 100; // not < 100 

Answer 4

sfruttare la potenza del un metodo di riferimento per rendere il codice ancora più compatta:

List<Entity> result = 
      list.stream() 
        .filter(Objects::nonNull) 
        .filter(predicate) 
        .sorted(comp) 
        .collect(Collectors.toList()); 

Answer 5

Tutte le risposte qui ruotano attorno a "buttare via gli elementi cattivi, quelli che hanno un valore nullo getParentId()". Questa potrebbe essere la risposta, se sono davvero cattive. Ma c'è un'altra alternativa: Comparators.nullsFirst (o l'ultima). Ciò consente di confrontare le cose che trattano un valore nullo come minore (o maggiore di) di tutti i valori non nulli, quindi non devi gettare gli elementi con un genitore nullo lontano.

Comparator<Entity> cmp = nullsLast(comparing(Entity::getParentId)); 
List<Entity> list = list.stream().sorted(cmp).collect(toList()); 

Si può fare una cosa simile per il filtraggio; definire il predicato come:

Predicate<Entity> predicate = e -> e.getParentId() != null 
             && e.getParentId() < 100; 

Answer 6

Sembra che siete alla ricerca di qualcosa di simile a:

list.sort(Comparator.comparing(Entity::getParent, 
           Comparator.nullsLast(Integer::compareTo))); 

Tutti gli elementi con nulla genitore saranno messi alla fine e il resto saranno ordinati da un genitore.