Comment obtenir plusieurs valeurs d'un objet à l'aide d'une seule opération de flux?

Vous pouvez utiliser 2 flux en utilisant Stream :: reduction pour obtenir un point avec un minimum et un point avec un maximum. Je ne recommande pas de concaténer les résultats en un seul flux car il peut être difficile de distinguer la différence entre le minimum, le maximum et les coordonnées.

Point min = points
    .stream()
    .reduce((l, r) -> new Point(Math.min(l.y, r.y), Math.min(l.y, r.y))
    .orElse(new Point(-1, -1));

Point max = points
    .stream()
    .reduce((l, r) -> new Point(Math.max(l.y, r.y), Math.max(l.y, r.y))
    .orElse(new Point(-1, -1));

En tant que BinaryOperator utilisez les deux Points suivants et un opérateur ternaire pour connaître le minimum / maximum qui est passé à un nouvel objet Point et renvoyé en utilisant Facultatif :: orElse avec les coordonnées par défaut -1, -1 .

Vous pouvez diviser par deux les itérations avec summaryStatistics () tout en gardant un code simple:

for (Point p : points) {
    minX = Math.min(p.x, minX);
    minY = Math.min(p.y, minY);
    maxY = Math.max(p.x, maxX);
    maxY = Math.max(p.y, maxY);
}

Et faire la même chose avec point.y .
Vous pouvez prendre en compte de cette manière:

Function<ToIntFunction<Point>, IntSummaryStatistics> statFunction =
        intExtractor -> points.stream()
                              .mapToInt(p -> intExtractor.applyAsInt(pp))
                              .summaryStatistics();

IntSummaryStatistics statX = statFunction.apply(p -> p.x);
IntSummaryStatistics statY = statFunction.apply(p -> p.y);

Un collecteur personnalisé est une possibilité, mais notez que vous devez implémenter la partie combineur qui rendra votre code plus difficile à lire.
Donc, mais si vous avez besoin d'utiliser un flux parallèle, vous devez rester à la manière impérative.
Bien que vous puissiez améliorer votre code actuel en vous appuyant sur les fonctions Math.min et Math.max :

IntSummaryStatistics stat = points.stream().mapToInt(point -> point.x).summaryStatistics();
int minX = stat.getMin();
int maxX = stat.getMax();

Par analogie avec IntSummaryStatistics , créez une classe PointStatistics qui collecte les informations dont vous avez besoin. Il définit deux méthodes: une pour enregistrer les valeurs d'un Point , une pour combiner deux Statistics.

Benchmark                        Mode  Cnt    Score     Error  Units

customCollector                  avgt   10  714.016 ± 151.558  ms/op
forEach                          avgt   10   54.334 ±   9.820  ms/op
fourStreams                      avgt   10  699.599 ± 138.332  ms/op
statistics                       avgt   10  148.649 ±  26.248  ms/op
twoStreams                       avgt   10  429.050 ±  72.879  ms/op

Ensuite, vous pouvez collecter un Diffusez dans un PointStatistics.

Benchmark                        Mode  Cnt   Score   Error  Units

customCollector                  avgt   10  68.117 ± 4.822  ms/op
forEach                          avgt   10   3.939 ± 0.559  ms/op
fourStreams                      avgt   10  57.800 ± 4.817  ms/op
statistics                       avgt   10   9.904 ± 1.048  ms/op
twoStreams                       avgt   10  32.303 ± 2.498  ms/op

UPDATE

J'ai été complètement déconcerté par la conclusion tirée par OP, alors j'ai décidé d'écrire JMH benchmarks.

Paramètres de référence:

Benchmark                        Mode  Cnt  Score   Error  Units

customCollector                  avgt   10  6.760 ± 0.789  ms/op
forEach                          avgt   10  0.255 ± 0.033  ms/op
fourStreams                      avgt   10  5.115 ± 1.149  ms/op
statistics                       avgt   10  0.887 ± 0.114  ms/op
twoStreams                       avgt   10  2.869 ± 0.567  ms/op

JDK 12 aura Collectors.teeing ( webrev et CSR ), qui recueille à deux collectionneurs différents et puis fusionne les deux résultats partiels en un résultat final.

Vous pouvez l'utiliser ici pour collecter deux IntSummaryStatistics pour la coordonnée x et le y code> coordonnée:

public static <T, A1, A2, R1, R2, R> Collector<T, ?, R> teeing(
        Collector<? super T, A1, R1> downstream1,
        Collector<? super T, A2, R2> downstream2,
        BiFunction<? super R1, ? super R2, R> merger) {

    class Acc {
        A1 acc1 = downstream1.supplier().get();
        A2 acc2 = downstream2.supplier().get();

        void accumulate(T t) {
            downstream1.accumulator().accept(acc1, t);
            downstream2.accumulator().accept(acc2, t);
        }

        Acc combine(Acc other) {
            acc1 = downstream1.combiner().apply(acc1, other.acc1);
            acc2 = downstream2.combiner().apply(acc2, other.acc2);
            return this;
        }

        R applyMerger() {
            R1 r1 = downstream1.finisher().apply(acc1);
            R2 r2 = downstream2.finisher().apply(acc2);
            return merger.apply(r1, r2);
        }
    }

    return Collector.of(Acc::new, Acc::accumulate, Acc::combine, Acc::applyMerger);
}

Ici, le premier collecteur rassemble les statistiques pour x et la seconde pour y . Ensuite, les statistiques pour x et y sont fusionnées dans une List au moyen du JDK 9 List.of méthode d'usine qui accepte deux éléments.

Une alternative à List :: of pour la fusion serait:

(xStats, yStats) -> Arrays.asList(xStats, yStats)

Si vous ne pas avoir JDK 12 installé sur votre machine, voici une version générique simplifiée de la méthode teeing que vous pouvez utiliser en toute sécurité comme méthode utilitaire:

List<IntSummaryStatistics> stats = points.stream()
    .collect(Collectors.teeing(
             Collectors.mapping(p -> p.x, Collectors.summarizingInt()),
             Collectors.mapping(p -> p.y, Collectors.summarizingInt()),
             List::of));

int minX = stats.get(0).getMin();
int maxX = stats.get(0).getMax();
int minY = stats.get(1).getMin();
int maxY = stats.get(1).getMax();

Veuillez noter que je ne considère pas les caractéristiques des collecteurs en aval lors de la création du collecteur retourné.

Merci à tous pour toutes les suggestions et réponses. C'est très utile et j'ai beaucoup appris!

J'ai décidé d'essayer la plupart de vos solutions (à l'exception de la solution JDK12). Pour certains d'entre eux, vous me fournissez déjà le code. De plus, j'ai créé mon propre Collector .

class extremesCollector implements Collector<Point, Map<String, Integer>, Map<String , Integer>> {

    @Override
    public Supplier<Map<String, Integer>> supplier() {
        Map<String, Integer> map = new HashMap<>();
        map.put("xMin", Integer.MAX_VALUE);
        map.put("yMin", Integer.MAX_VALUE);
        map.put("xMax", Integer.MIN_VALUE);
        map.put("yMax", Integer.MIN_VALUE);
        return () -> map;
    }

    @Override
    public BiConsumer<Map<String, Integer>, Point> accumulator() {
        return (a, b) -> {
            a.put("xMin", Math.min(a.get("xMin"), b.x));
            a.put("yMin", Math.min(a.get("yMin"), b.y));
            a.put("xMax", Math.max(a.get("xMax"), b.x));
            a.put("yMax", Math.max(a.get("yMax"), b.y));
        };
    }

    @Override
    public Function<Map<String, Integer>, Map<String, Integer>> finisher() {
        return Function.identity();
    }

    @Override
    public BinaryOperator<Map<String, Integer>> combiner() {
        return (a, b) -> {
            a.put("xMin", Math.min(a.get("xMin"), b.get("xMin")));
            a.put("yMin", Math.min(a.get("yMin"), b.get("yMin")));
            a.put("xMax", Math.max(a.get("xMax"), b.get("xMax")));
            a.put("yMax", Math.max(a.get("yMax"), b.get("yMax")));
            return a;
        };
    }

    @Override
    public Set<Characteristics> characteristics() {
        Set<Characteristics> characteristics = new HashSet<>();
        characteristics.add(Characteristics.UNORDERED);
        characteristics.add(Characteristics.CONCURRENT);
        characteristics.add(Characteristics.IDENTITY_FINISH);
        return characteristics;
    }
}

Concernant la vitesse, voici le classement:

1. boucles for
2. quatre flux individuels
3. stream avec un collecteur personnalisé
4. flux parallèle avec un collecteur personnalisé
5. approche statistique fournie par Andrew Tobilko

Les numéros 2 et 3 sont en fait très proches en termes de vitesse. La version parallèle est probablement plus lente car mon ensemble de données est trop petit.