堆棧內存溢出
  簡體   English   中英

Java 8 Streams：如何調用Collection.stream（）方法並檢索具有不同字段的多個聚合值的數組

[英]Java 8 Streams: How to call once the Collection.stream() method and retrieve an array of several aggregate values with different fields

 原文  2016-01-05 21:49:33  5   3    java/ java-8/ java-stream

問題描述

我將從Java 8中的Stream API開始。

這是我使用的Person對象： 

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;
    }

  }

這是我的代碼，它初始化一個對象列表Person，它獲取由特定名字過濾的對象數，最大年齡和最小高度，平均權重，最后創建一個包含這些值的對象數組： 

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));

是否可以單獨調用stream()方法並直接返回對象數組？ 

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

我之前問過非常類似的問題： Java 8 Streams：如何調用一次Collection.stream（）方法並檢索幾個聚合值的數組，但這次我不能使用summaryStatistics()方法因為我使用了不同的字段（年齡，高度） ，weight）檢索聚合值。

編輯2016-01-07

我測試了TriCore和Tagir Valeev的解決方案，並計算了每個解決方案的運行時間。

似乎TriCore解決方案比Tagir Valeev更有效。

與我的解決方案（使用多個Streams）相比， Tagir Valeev的解決方案似乎沒有節省太多時間。

這是我的測試類： 

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);
  }

}

3 個解決方案

解決方案1
 9  2016-01-05 22:08:33

使用標准JDK 8 API解決這個問題有點棘手，它沒有提供很多組合Collector類型的方法。 如果您願意使用像jOOλ這樣的第三方庫，您可以寫： 

Tuple4<Long, Optional<Integer>, Optional<Double>, Optional<Double>> result =
Seq.seq(personsList)
   .collect(
       filter(p -> p.getFirstName().equals("John"), count()),
       max(Person::getAge),
       min(Person::getHeight),
       avg(Person::getWeight)
   );

System.out.println(result);

以上產量： 

(2, Optional[35], Optional[1.8], Optional[75.0])

注意，它使用新的Agg.filter()方法，類似於JDK 9 Collectors.filtering()方法，其工作方式如下： 

public static <T, A, R> Collector<T, A, R> filter(
    Predicate<? super T> predicate, Collector<T, A, R> downstream) {
    return Collector.of(
        downstream.supplier(),
        (c, t) -> {
            if (predicate.test(t))
                downstream.accumulator().accept(c, t);
        }, 
        downstream.combiner(),
        downstream.finisher()
    );
}

collect(collector1, collector2, ...)工作？

如果您不想使用上述第三方庫，則可以編寫自己的Collector組合實用程序。 將兩個收集器組合到Tuple2收集器中的Tuple2 ： 

static <T, A1, A2, D1, D2> Collector<T, Tuple2<A1, A2>, Tuple2<D1, D2>> collectors(
    Collector<T, A1, D1> collector1
  , Collector<T, A2, D2> collector2
) {
    return Collector.<T, Tuple2<A1, A2>, Tuple2<D1, D2>>of(
        () -> tuple(
            collector1.supplier().get()
          , collector2.supplier().get()
        ),
        (a, t) -> {
            collector1.accumulator().accept(a.v1, t);
            collector2.accumulator().accept(a.v2, t);
        },
        (a1, a2) -> tuple(
            collector1.combiner().apply(a1.v1, a2.v1)
          , collector2.combiner().apply(a1.v2, a2.v2)
        ),
        a -> tuple(
            collector1.finisher().apply(a.v1)
          , collector2.finisher().apply(a.v2)
        )
    );
}

免責聲明：我為jOOλ背后的公司工作。

解決方案2
 9 已采納  2016-01-05 22:50:05

這是收藏家 

public 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};
    }
}

您可以按如下方式使用此收集器 

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

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

        Object[] objects = personsList.stream().collect(Collector.of(
                () -> new PersonStatistics(p -> p.getFirstName().equals("John")),
                PersonStatistics::accept,
                PersonStatistics::combine,
                PersonStatistics::toStatArray));
        System.out.println(Arrays.toString(objects));
    }
}

解決方案3
 5  2016-01-06 11:25:24

如果沒有第三方庫，您可以創建一個通用收集器，它將任意數量的指定收集器的結果組合到單個Object[]數組中： 

/**
 * 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;
    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());
}

對於您的具體問題，您還需要一個filtering()收集器（將在JDK-9中添加，請參閱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()]));
}

現在您可以構建一個可以生成最終結果的收集器： 

Collector<Person, ?, Object[]> collector = 
    multiCollector(
        filtering(p -> p.getFirstName().equals("John"), counting()),
        collectingAndThen(mapping(Person::getAge, 
            maxBy(Comparator.naturalOrder())), Optional::get),
        collectingAndThen(mapping(Person::getHeight, 
            minBy(Comparator.naturalOrder())), Optional::get),
        averagingDouble(Person::getWeight));

Object[] result = personsList.stream().collect(collector);
System.out.println(Arrays.toString(result));

暫無
暫無

聲明:本站的技術帖子網頁，遵循CC BY-SA 4.0協議，如果您需要轉載，請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.

相關問題 Java flatMap - 有什么區別stream.of（）和collection.stream（） Collection.stream() 的實現 Java 8. collection.stream（）和Stream.of（集合）之間的區別 如何避免嵌套的Collection.stream（）調用？ collection.stream（）。skip（）。findFirst（）的效率 Collection.stream（）是否具有內部同步？ 使用Collection.stream按特定屬性動態分組 Collection.toArray() 與 Collection.stream().toArray() Collection.stream().forEach() 和 Collection.forEach() 有什么區別？ for 循環時間和空間復雜度中的嵌套 Collection.stream()
相關標簽
 
粵ICP備18138465號  © 2020-2024 STACKOOM.COM