Java 8 flusso valore di filtraggio di lista in una lista

Question

Ho un un oggetto che assomiglia al seguente

class MyObject { 

    String type; 
    List<String> subTypes; 

} 

E 'possibile, data una lista di MyObject di usare Java 8 flussi di filtrare sia dal tipo e poi il sottotipo?

Finora ho

myObjects.stream() 
    .filter(t -> t.getType().equals(someotherType) 
    .collect(Collections.toList()); 

ma all'interno di questo voglio anche un altro filtro su ciascuna dei sottotipi filtraggio quelli su un particolare sottotipo troppo. Non riesco a capire come farlo.

Un esempio sarebbe

myObject { type: A, subTypes [ { X, Y, Z } ] } 
myObject { type: B, subTypes [ { W, X, Y } ] } 
myObject { type: B, subTypes [ { W, X, Z } ] } 
myObject { type: C, subTypes [ { W, X, Z } ] } 

avrei passare matchtype B e subType Z, in modo che ci si aspetterebbe uno risultato -> tipo myObject B, sottotipi: W, X, Z

seguente attualmente restituisce 2 elementi in una lista.

myObjects.stream() 
    .filter(t -> t.getType().equals("B") 
    .collect(Collections.toList()); 

ma vorrei aggiungere un ulteriore filtro sulla ciascuno dei sottotipi e solo corrispondenza in cui è presente 'Z'.

Answer 1

si può fare:

myObjects.stream() 
     .filter(t -> t.getType().equals(someotherType) && 
         t.getSubTypes().stream().anyMatch(<predicate>)) 
     .collect(Collectors.toList()); 

Verrà recuperato tutti gli oggetti che MyObject

• incontrare un criterio per quanto riguarda il membro type.
• contengono oggetti nel nidificato List<String> che soddisfano alcuni altri criteri, rappresentate con <predicate>

Answer 2

ho visto la risposta accettata dalla @kocko che è sia una buona risposta e totalmente corretta. Tuttavia esiste un approccio leggermente alternativo in cui si concatenano semplicemente i filtri.

final List<MyObject> withBZ = myObjects.stream() 
     .filter(myObj -> myObj.getType().equals("B")) 
     .filter(myObj -> myObj.getSubTypes().stream().anyMatch("Z"::equals)) 
     .collect(Collectors.toList()); 

questo è fondamentalmente facendo la stessa cosa, ma la && operando viene rimosso in favore di un altro filtro. Il concatenamento funziona molto bene per l'API Java 8 Stream: s e IMO è più facile da leggere e seguire il codice.