Java 8 Flux FlatMap exemple de méthode de

Composée exemple

Imaginez que vous voulez créer la séquence suivante: 1, 2, 2, 3, 3, 3, 4, 4, 4, 4 etc. (en d'autres mots: 1x1, 2x2, 3x3, etc.)

Avec flatMap il pourrait ressembler à:

IntStream sequence = IntStream.rangeClosed(1, 4)
                          .flatMap(i -> IntStream.iterate(i, identity()).limit(i));
sequence.forEach(System.out::println);

où:

• IntStream.rangeClosed(1, 4) crée un flux de int de 1 à 4 inclusivement
• IntStream.iterate(i, identity()).limit(i) crée un flux de longueur i de int i - ainsi appliquée à i = 4 il crée un flux: 4, 4, 4, 4
• flatMap "aplatit" le flux et le "concatène" à l'origine de flux

Avec Java < 8, vous aurait besoin de deux boucles imbriquées:

List<Integer> list = new ArrayList<>();
for (int i = 1; i <= 4; i++) {
    for (int j = 0; j < i; j++) {
        list.add(i);
    }
}

L'exemple du monde réel

Disons que j'ai un List<TimeSeries> où chaque TimeSeries est essentiellement un Map<LocalDate, Double>. Je veux obtenir une liste de toutes les dates pour lesquelles au moins l'une de la série de temps a une valeur. flatMap à la rescousse:

list.stream().parallel()
    .flatMap(ts -> ts.dates().stream()) //for each TS, stream dates and flatmap
    .distinct()                         //remove duplicates
    .sorted()                           //sort ascending
    .collect(toList());

Il est non seulement lisible, mais si vous avez soudainement besoin de processus de 100k éléments, simplement en ajoutant parallel() permettra d'améliorer les performances sans vous écrire aucun code simultané.

Suis-je le seul qui trouve déroulement des listes ennuyeux? 😉

Essayons avec les objets. L'exemple du monde réel par la voie.

Donné: Objet représentant des tâches répétitives. Concernant d'importants champs de tâche: rappels commencent à sonner à start et répéter tous les repeatPeriod repeatUnit(par exemple, 5 HEURES) et il y aura repeatCount rappels au total(y compris le démarrage d'un).

Objectif: parvenir à une liste de tâche exemplaires, un pour chaque tâche de rappel invocation.

List<Task> tasks =
            Arrays.asList(
                    new Task(
                            false,//completed sign
                            "My important task",//task name (text)
                            LocalDateTime.now().plus(2, ChronoUnit.DAYS),//first reminder(start)
                            true,//is task repetitive?
                            1,//reminder interval
                            ChronoUnit.DAYS,//interval unit
                            5//total number of reminders
                    )
            );

tasks.stream().flatMap(
        x -> LongStream.iterate(
                x.getStart().toEpochSecond(ZoneOffset.UTC),
                p -> (p + x.getRepeatPeriod()*x.getRepeatUnit().getDuration().getSeconds())
        ).limit(x.getRepeatCount()).boxed()
        .map( y -> new Task(x,LocalDateTime.ofEpochSecond(y,0,ZoneOffset.UTC)))
).forEach(System.out::println);

De sortie:

Task{completed=false, text='My important task', start=2014-10-01T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null}
Task{completed=false, text='My important task', start=2014-10-02T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null}
Task{completed=false, text='My important task', start=2014-10-03T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null}
Task{completed=false, text='My important task', start=2014-10-04T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null}
Task{completed=false, text='My important task', start=2014-10-05T21:35:24, repeat=false, repeatCount=0, repeatPeriod=0, repeatUnit=null}

P. S.: je vous serais reconnaissant si quelqu'un a suggéré une solution plus simple, je ne suis pas un pro, après tout.

Mise à JOUR:
@RBz a demandé de plus amples explications si elle est ici.
Fondamentalement, flatMap met tous les éléments de flux à l'intérieur d'un autre flux de données en flux de sortie. Beaucoup de ruisseaux ici :). Ainsi, pour chaque Tâche initiale de flux expression lambda x -> LongStream.iterate... crée un flux de valeurs longues qui représentent une tâche de démarrage des moments. Ce flux est limité à x.getRepeatCount() instances. C'est les valeurs de début de x.getStart().toEpochSecond(ZoneOffset.UTC) et de chaque côté de la valeur est calculée à l'aide de lambda p -> (p + x.getRepeatPeriod()*x.getRepeatUnit().getDuration().getSeconds(). boxed() retourne le flux avec chaque valeur de type long qu'un Long wrapper instance. Ensuite, chaque Long de ce cours d'eau est mappé à la nouvelle instance de la Tâche qui n'est pas répétitif plus et contient exacte de temps d'exécution. Cet échantillon ne contient qu'une seule Tâche dans la liste d'entrée. Mais imaginez que vous avez un millier de. Vous aurez alors un flot de 1000 flux d'objets de Tâche. Et ce flatMap fait ici est de mettre toutes les Tâches de tous les flux sur le même flux de sortie. C'est tout ce que je comprends. Merci pour votre question!

Donné ceci:

  public class SalesTerritory
{
private String territoryName;
private Set<String> geographicExtents;
public SalesTerritory( String territoryName, Set<String> zipCodes )
{
this.territoryName = territoryName;
this.geographicExtents = zipCodes;
}
public String getTerritoryName()
{
return territoryName;
}
public void setTerritoryName( String territoryName )
{
this.territoryName = territoryName;
}
public Set<String> getGeographicExtents()
{
return geographicExtents != null ? Collections.unmodifiableSet( geographicExtents ) : Collections.emptySet();
}
public void setGeographicExtents( Set<String> geographicExtents )
{
this.geographicExtents = new HashSet<>( geographicExtents );
}
@Override
public int hashCode()
{
int hash = 7;
hash = 53 * hash + Objects.hashCode( this.territoryName );
return hash;
}
@Override
public boolean equals( Object obj )
{
if ( this == obj ) {
return true;
}
if ( obj == null ) {
return false;
}
if ( getClass() != obj.getClass() ) {
return false;
}
final SalesTerritory other = (SalesTerritory) obj;
if ( !Objects.equals( this.territoryName, other.territoryName ) ) {
return false;
}
return true;
}
@Override
public String toString()
{
return "SalesTerritory{" + "territoryName=" + territoryName + ", geographicExtents=" + geographicExtents + '}';
}
}

et ce:

public class SalesTerritories
{
private static final Set<SalesTerritory> territories
= new HashSet<>(
Arrays.asList(
new SalesTerritory[]{
new SalesTerritory( "North-East, USA",
new HashSet<>( Arrays.asList( new String[]{ "Maine", "New Hampshire", "Vermont",
"Rhode Island", "Massachusetts", "Connecticut",
"New York", "New Jersey", "Delaware", "Maryland",
"Eastern Pennsylvania", "District of Columbia" } ) ) ),
new SalesTerritory( "Appalachia, USA",
new HashSet<>( Arrays.asList( new String[]{ "West-Virgina", "Kentucky",
"Western Pennsylvania" } ) ) ),
new SalesTerritory( "South-East, USA",
new HashSet<>( Arrays.asList( new String[]{ "Virginia", "North Carolina", "South Carolina",
"Georgia", "Florida", "Alabama", "Tennessee",
"Mississippi", "Arkansas", "Louisiana" } ) ) ),
new SalesTerritory( "Mid-West, USA",
new HashSet<>( Arrays.asList( new String[]{ "Ohio", "Michigan", "Wisconsin", "Minnesota",
"Iowa", "Missouri", "Illinois", "Indiana" } ) ) ),
new SalesTerritory( "Great Plains, USA",
new HashSet<>( Arrays.asList( new String[]{ "Oklahoma", "Kansas", "Nebraska",
"South Dakota", "North Dakota",
"Eastern Montana",
"Wyoming", "Colorada" } ) ) ),
new SalesTerritory( "Rocky Mountain, USA",
new HashSet<>( Arrays.asList( new String[]{ "Western Montana", "Idaho", "Utah", "Nevada" } ) ) ),
new SalesTerritory( "South-West, USA",
new HashSet<>( Arrays.asList( new String[]{ "Arizona", "New Mexico", "Texas" } ) ) ),
new SalesTerritory( "Pacific North-West, USA",
new HashSet<>( Arrays.asList( new String[]{ "Washington", "Oregon", "Alaska" } ) ) ),
new SalesTerritory( "Pacific South-West, USA",
new HashSet<>( Arrays.asList( new String[]{ "California", "Hawaii" } ) ) )
}
)
);
public static Set<SalesTerritory> getAllTerritories()
{
return Collections.unmodifiableSet( territories );
}
private SalesTerritories()
{
}
}

Nous pouvons alors faire ceci:

System.out.println();
System.out
.println( "We can use 'flatMap' in combination with the 'AbstractMap.SimpleEntry' class to flatten a hierarchical data-structure to a set of Key/Value pairs..." );
SalesTerritories.getAllTerritories()
.stream()
.flatMap( t -> t.getGeographicExtents()
.stream()
.map( ge -> new SimpleEntry<>( t.getTerritoryName(), ge ) )
)
.map( e -> String.format( "%-30s : %s",
e.getKey(),
e.getValue() ) )
.forEach( System.out::println );