Java 8 потоков-сбор против уменьшения

причина просто в том, что:

• collect()может работать только С mutable объекты результата.
• reduce() - это предназначен для работы С неизменяемые объекты результата.

"reduce() С неизменным" пример

public class Employee {
  private Integer salary;
  public Employee(String aSalary){
    this.salary = new Integer(aSalary);
  }
  public Integer getSalary(){
    return this.salary;
  }
}

@Test
public void testReduceWithImmutable(){
  List<Employee> list = new LinkedList<>();
  list.add(new Employee("1"));
  list.add(new Employee("2"));
  list.add(new Employee("3"));

  Integer sum = list
  .stream()
  .map(Employee::getSalary)
  .reduce(0, (Integer a, Integer b) -> Integer.sum(a, b));

  assertEquals(new Integer(6), sum);
}

"collect() С примером изменяемых"

например, если вы хотите вручную вычислить сумму с помощью collect() он не может работать с BigDecimal только с MutableInt С org.apache.commons.lang.mutable например. Смотрите:

public class Employee {
  private MutableInt salary;
  public Employee(String aSalary){
    this.salary = new MutableInt(aSalary);
  }
  public MutableInt getSalary(){
    return this.salary;
  }
}

@Test
public void testCollectWithMutable(){
  List<Employee> list = new LinkedList<>();
  list.add(new Employee("1"));
  list.add(new Employee("2"));

  MutableInt sum = list.stream().collect(
    MutableInt::new, 
    (MutableInt container, Employee employee) -> 
      container.add(employee.getSalary().intValue())
    , 
    MutableInt::add);
  assertEquals(new MutableInt(3), sum);
}

это работает, потому что аккумуляторcontainer.add(employee.getSalary().intValue()); не должен возвращать новый объект с результатом, но, чтобы изменить состояние изменчивое container типа MutableInt.

если вы хотите использовать BigDecimal вместо container вы не могли бы использовать collect() метод container.add(employee.getSalary()); не менять container, потому что BigDecimal она неизменна. (Помимо этого BigDecimal::new не будет работать как BigDecimal не имеет пустого конструктора)

нормальное сокращение предназначено для объединения двух неизменяемые значения, такие как int, double и т. д. и произвести новый; это неизменяемые

пусть поток будет a

в сокращении,

У вас будет ((A # b) # c) # d

где # это интересная операция, которую вы хотели бы сделать.

в сборе,

У вашего коллекционера будет какая-то коллекционная структура K.

K потребляет a. Затем K потребляет b. Затем K потребляет c. Затем K потребляет d.

в конце вы спрашиваете K, каков конечный результат.

K, тогда дает его тебе.

они очень отличается потенциальным объемом памяти во время выполнения. В то время как collect() собирает и выкладывает все данные в коллекцию, reduce() явно просит вас указать, как уменьшить данные, которые сделали это через поток.

например, если вы хотите прочитать некоторые данные из файла, обработать их и поместить в какую-либо базу данных, вы можете получить код потока java, подобный этому:

streamDataFromFile(file)
            .map(data -> processData(data))
            .map(result -> database.save(result))
            .collect(Collectors.toList());

в этом дело, мы используем collect() чтобы заставить java передавать данные через и заставить его сохранить результат в базе данных. Без collect() данные никогда не читал и никогда не хранятся.

этот код счастливо генерирует java.lang.OutOfMemoryError: Java heap space ошибка выполнения, если размер файла достаточно велик или размер кучи достаточно низок. Очевидная причина заключается в том, что он пытается сложить все данные, которые прошли через поток (и, по сути, уже были сохранены в базе данных) в результирующую коллекцию, и это взрывается куча.

однако, если вы замените collect() С reduce() -- это больше не будет проблемой, так как последний уменьшит и отбросит все данные, которые сделали это.

в представленном примере просто замените collect() С чем-то с reduce:

.reduce(0L, (aLong, result) -> aLong, (aLong1, aLong2) -> aLong1);

вам не нужно даже заботиться, чтобы сделать расчет зависит от result поскольку Java не является чистым языком FP (функционального программирования) и не может оптимизировать данные, которые не являются используется на дне ручья из-за возможных побочных эффектов.

вот пример кода

List<Integer> list = Arrays.asList(1,2,3,4,5,6,7);
int sum = list.stream().reduce((x,y) -> {
        System.out.println(String.format("x=%d,y=%d",x,y));
        return (x + y);
    }).get();

система.из.println (sum);

вот результат выполнения:

x=1,y=2
x=3,y=3
x=6,y=4
x=10,y=5
x=15,y=6
x=21,y=7
28

уменьшить функцию обрабатывать два параметра, первый параметр-это предыдущее возвращаемое значение int поток, второй параметр-текущий вычислите значение в потоке, оно суммирует первое значение и текущее значение как первое значение в следующей caculation.

По данным документы

сборники reducing () наиболее полезны при использовании в многоуровневом сокращении, после groupingBy или partitioningBy. Чтобы выполнить простое сокращение потока, используйте Stream.вместо этого уменьшите (BinaryOperator).

Так что в основном вы бы использовали reducing() только при принудительном сборе. Вот еще один пример:

 For example, given a stream of Person, to calculate the longest last name 
 of residents in each city:

    Comparator<String> byLength = Comparator.comparing(String::length);
    Map<String, String> longestLastNameByCity
        = personList.stream().collect(groupingBy(Person::getCity,
            reducing("", Person::getLastName, BinaryOperator.maxBy(byLength))));

По данным в этом уроке сокращение иногда менее эффективно

операция уменьшения всегда возвращает новое значение. Однако функция аккумулятора также возвращает новое значение каждый раз, когда она обрабатывает элемент потока. Предположим, что вы хотите свести элементы потока к более сложному объекту, такому как коллекция. Это может привести к снижению производительности приложения. Если ваша операция сокращения включает добавление элементов в коллекцию, то каждый раз, когда ваша функция аккумулятора обрабатывает элемент, он создает новую коллекцию, которая включает в себя элемент, который является неэффективным. Вместо этого было бы более эффективно обновить существующую коллекцию. Вы можете сделать это с потоком.соберите метод, который описывается в следующем разделе...

таким образом, идентичность "повторно используется" в сценарии сокращения, поэтому немного эффективнее идти с .reduce если это возможно.