Ich beginne mit der Stream-API in Java 8.

Hier ist mein Personenobjekt, das ich verwende:

public class Person {

    private String firstName;
    private String lastName;
    private int age;
    private double height;
    private double weight;

    public Person(String firstName, String lastName, int age, double height, double weight) {
      this.firstName = firstName;
      this.lastName = lastName;
      this.age = age;
      this.height = height;
      this.weight = weight;
    }

    public String getFirstName() {
      return firstName;
    }
    public String getLastName() {
      return lastName;
    }
    public int getAge() {
      return age;
    }
    public double getHeight() {
      return height;
    }
    public double getWeight() {
      return weight;
    }

  }

Hier ist mein Code, der eine Liste von Objekten Person initialisiert und der die Anzahl von Objekten ermittelt, die nach einem bestimmten Vornamen, dem maximalen Alter und der minimalen Größe, dem Gewichtsdurchschnitt gefiltert wurden, und schließlich ein Array von Objekten erstellt, das diese Werte enthält:

List<Person> personsList = new ArrayList<Person>();

personsList.add(new Person("John", "Doe", 25, 1.80, 80));
personsList.add(new Person("Jane", "Doe", 30, 1.69, 60));
personsList.add(new Person("John", "Smith", 35, 174, 70));

long count = personsList.stream().filter(p -> p.getFirstName().equals("John")).count();
int maxAge = personsList.stream().mapToInt(Person::getAge).max().getAsInt();
double minHeight = personsList.stream().mapToDouble(Person::getHeight).min().getAsDouble();
double avgWeight = personsList.stream().mapToDouble(Person::getWeight).average().getAsDouble();

Object[] result = new Object[] { count, maxAge, minHeight, avgWeight };
System.out.println(Arrays.toString(result));

Ist es möglich, ein einziges Gespräch mit dem @ zu führestream() -Methode und um das Array von Objekten direkt zurückzugeben?

Object[] result = personsList.stream()...count()...max()...min()...average()

Ich habe zuvor eine sehr ähnliche Frage gestellt:Java 8 Streams: So rufen Sie einmal die Collection.stream () - Methode auf und rufen ein Array mit mehreren aggregierten Werten ab aber diesmal kann ich das @ nicht benutzsummaryStatistics() -Methode, da ich verschiedene Felder (Alter, Größe, Gewicht) verwende, um die aggregierten Werte abzurufen.

EDIT 07.01.2016

Ich habe die Lösungen von @ getestTriCore undTagir Valeev, und ich habe die Laufzeit für jede Lösung berechnet.

Es scheint, dass dasTriCore Lösung ist effizienter alsTagir Valeev.

Tagir Valeevie Lösung von @ scheint im Vergleich zu meiner Lösung (mit mehreren Streams) nicht viel Zeit zu sparen.

Hier ist meine Testklasse:

public class StreamTest {

  public static class Person {

    private String firstName;
    private String lastName;
    private int age;
    private double height;
    private double weight;

    public Person(String firstName, String lastName, int age, double height, double weight) {
      this.firstName = firstName;
      this.lastName = lastName;
      this.age = age;
      this.height = height;
      this.weight = weight;
    }

    public String getFirstName() {
      return firstName;
    }

    public String getLastName() {
      return lastName;
    }

    public int getAge() {
      return age;
    }

    public double getHeight() {
      return height;
    }

    public double getWeight() {
      return weight;
    }

  }

  public static abstract class Process {

    public void run() {
      StopWatch timer = new StopWatch();
      timer.start();
      doRun();
      timer.stop();
      System.out.println(timer.getTime());
    }

    protected abstract void doRun();

  }

  public static void main(String[] args) {
    List<Person> personsList = new ArrayList<Person>();

    for (int i = 0; i < 1000000; i++) {
      int age = random(15, 60);
      double height = random(1.50, 2.00);
      double weight = random(50.0, 100.0);
      personsList.add(new Person(randomString(10, Mode.ALPHA), randomString(10, Mode.ALPHA), age, height, weight));
    }

    personsList.add(new Person("John", "Doe", 25, 1.80, 80));
    personsList.add(new Person("Jane", "Doe", 30, 1.69, 60));
    personsList.add(new Person("John", "Smith", 35, 174, 70));
    personsList.add(new Person("John", "T", 45, 179, 99));

    // Query with mutiple Streams
    new Process() {
      protected void doRun() {
        queryJava8(personsList);
      }
    }.run();

    // Query with 'TriCore' method
    new Process() {
      protected void doRun() {
        queryJava8_1(personsList);
      }
    }.run();

    // Query with 'Tagir Valeev' method
    new Process() {
      protected void doRun() {
        queryJava8_2(personsList);
      }
    }.run();
  }

  // --------------------
  // JAVA 8
  // --------------------

  private static void queryJava8(List<Person> personsList) {
    long count = personsList.stream().filter(p -> p.getFirstName().equals("John")).count();
    int maxAge = personsList.stream().mapToInt(Person::getAge).max().getAsInt();
    double minHeight = personsList.stream().mapToDouble(Person::getHeight).min().getAsDouble();
    double avgWeight = personsList.stream().mapToDouble(Person::getWeight).average().getAsDouble();

    Object[] result = new Object[] { count, maxAge, minHeight, avgWeight };
    System.out.println("Java8: " + Arrays.toString(result));

  }

  // --------------------
  // JAVA 8_1 - TriCore
  // --------------------

  private static void queryJava8_1(List<Person> personsList) {
    Object[] objects = personsList.stream().collect(Collector.of(() -> new PersonStatistics(p -> p.getFirstName().equals("John")),
        PersonStatistics::accept, PersonStatistics::combine, PersonStatistics::toStatArray));
    System.out.println("Java8_1: " + Arrays.toString(objects));
  }

  public static class PersonStatistics {
    private long firstNameCounter;
    private int maxAge = Integer.MIN_VALUE;
    private double minHeight = Double.MAX_VALUE;
    private double totalWeight;
    private long total;
    private final Predicate<Person> firstNameFilter;

    public PersonStatistics(Predicate<Person> firstNameFilter) {
      Objects.requireNonNull(firstNameFilter);
      this.firstNameFilter = firstNameFilter;
    }

    public void accept(Person p) {
      if (this.firstNameFilter.test(p)) {
        firstNameCounter++;
      }

      this.maxAge = Math.max(p.getAge(), maxAge);
      this.minHeight = Math.min(p.getHeight(), minHeight);
      this.totalWeight += p.getWeight();
      this.total++;
    }

    public PersonStatistics combine(PersonStatistics personStatistics) {
      this.firstNameCounter += personStatistics.firstNameCounter;
      this.maxAge = Math.max(personStatistics.maxAge, maxAge);
      this.minHeight = Math.min(personStatistics.minHeight, minHeight);
      this.totalWeight += personStatistics.totalWeight;
      this.total += personStatistics.total;

      return this;
    }

    public Object[] toStatArray() {
      return new Object[] { firstNameCounter, maxAge, minHeight, total == 0 ? 0 : totalWeight / total };
    }
  }

  // --------------------
  // JAVA 8_2 - Tagir Valeev
  // --------------------

  private static void queryJava8_2(List<Person> personsList) {
    // @formatter:off
    Collector<Person, ?, Object[]> collector = multiCollector(
            filtering(p -> p.getFirstName().equals("John"), Collectors.counting()),
            Collectors.collectingAndThen(Collectors.mapping(Person::getAge, Collectors.maxBy(Comparator.naturalOrder())), Optional::get),
            Collectors.collectingAndThen(Collectors.mapping(Person::getHeight, Collectors.minBy(Comparator.naturalOrder())), Optional::get),
            Collectors.averagingDouble(Person::getWeight)
    );
    // @formatter:on

    Object[] result = personsList.stream().collect(collector);
    System.out.println("Java8_2: " + Arrays.toString(result));
  }

  /**
   * Returns a collector which combines the results of supplied collectors
   * into the Object[] array.
   */
  @SafeVarargs
  public static <T> Collector<T, ?, Object[]> multiCollector(Collector<T, ?, ?>... collectors) {
    @SuppressWarnings("unchecked")
    Collector<T, Object, Object>[] cs = (Collector<T, Object, Object>[]) collectors;
    // @formatter:off
      return Collector.<T, Object[], Object[]> of(
          () -> Stream.of(cs).map(c -> c.supplier().get()).toArray(),
          (acc, t) -> IntStream.range(0, acc.length).forEach(
              idx -> cs[idx].accumulator().accept(acc[idx], t)),
          (acc1, acc2) -> IntStream.range(0, acc1.length)
              .mapToObj(idx -> cs[idx].combiner().apply(acc1[idx], acc2[idx])).toArray(),
          acc -> IntStream.range(0, acc.length)
              .mapToObj(idx -> cs[idx].finisher().apply(acc[idx])).toArray());
     // @formatter:on
  }

  /**
   * filtering() collector (which will be added in JDK-9, see JDK-8144675)
   */
  public static <T, A, R> Collector<T, A, R> filtering(Predicate<? super T> filter, Collector<T, A, R> downstream) {
    BiConsumer<A, T> accumulator = downstream.accumulator();
    Set<Characteristics> characteristics = downstream.characteristics();
    return Collector.of(downstream.supplier(), (acc, t) -> {
      if (filter.test(t))
        accumulator.accept(acc, t);
    } , downstream.combiner(), downstream.finisher(), characteristics.toArray(new Collector.Characteristics[characteristics.size()]));
  }

  // --------------------
  // HELPER METHODS
  // --------------------

  public static enum Mode {
    ALPHA,
    ALPHANUMERIC,
    NUMERIC
  }

  private static String randomString(int length, Mode mode) {
    StringBuffer buffer = new StringBuffer();
    String characters = "";

    switch (mode) {
      case ALPHA:
        characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
        break;

      case ALPHANUMERIC:
        characters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890";
        break;

      case NUMERIC:
        characters = "1234567890";
        break;
    }

    int charactersLength = characters.length();

    for (int i = 0; i < length; i++) {
      double index = Math.random() * charactersLength;
      buffer.append(characters.charAt((int) index));
    }
    return buffer.toString();
  }

  private static int random(int min, int max) {
    Random rand = new Random();
    return rand.nextInt((max - min) + 1) + min;
  }

  private static double random(double min, double max) {
    return min + Math.random() * (max - min);
  }

}