View source for MapReduce Reducer Assignment

credit for this assignment: Finn Voichick and Dennis Cosgrove
=Motivation=
{{AccumulatorCombinerReducerLink}} is fundamental to the MapReduce assignments, providing four of the five methods which allow clients to well use {{MapReduceFrameworkLink}}.

First, we will implement {{ClassicReducerLink}} which will provide the basic MapReduce functionality used by the [https://en.wikipedia.org/wiki/PageRank PageRank] algorithm which made [https://www.google.com/ Google]'s original search engine so effective.  

Then, we will implement two AccumulatorCombinerReducers which can serve to sum mutable containers of Integers.  Thus, they will pair well with the previous [[#MapReduce_Mapper_Assignment|Mappers exercise]].
* {{SummingIntClassicReducerLink}} will extend ClassicReducer.  
* {{SummingIntEfficientAccumulatorCombinerReducerLink}} will use a far more efficient mutable container to get the job done.

=Background=
The [http://www.oracle.com/technetwork/articles/java/ma14-java-se-8-streams-2177646.html Java streams framework] uses {{CollectorLink}} to allow clients to customize the four methods to create, accumulate, combine, and reduce.  {{CollectorLink}} chose to add an extra level of indirection to allow a hyper-lambdafication style.  While there is nothing fundamentally wrong with this approach, it was eventually deemed more trouble than it was worth for CSE 231s.  To learn more about Collector and its connection to AccumulatorCombinerReducer, check out this [[#Collector_Rosetta_Stone|Rosetta Stone]].

={{AccumulatorCombinerReducerLink}}=
{{CollapsibleCode|AccumulatorCombinerReducer<V, A, R>|
<syntaxhighlight lang="java">
public interface AccumulatorCombinerReducer<V, A, R> {
	A createMutableContainer();

	void accumulate(A container, V item);

	void combine(A containerA, A containerB);

	R reduce(A container);
}
</syntaxhighlight>}}
==createMutableContainer()==
We use createMutableContainer() to create a new mutable container.  For classic map reduce this would be a [https://docs.oracle.com/javase/8/docs/api/java/util/List.html List<V>].

==accumulate(container,item)==
We use accumulate(container,item) to accumulate a value.  For classic map reduce this would add an item to a list.

==combine(containerA,containerB)==
We use combine(containerA,containerB) to combine two accumulated mutable containers.  You must combine containerB into containerA. 

==reduce(container)==
We use reduce(container) to produce the distilled value of the container.

=Code To Use=
{{ListDoc}}
: {{ArrayListDoc}}
: {{LinkedListDoc}}

[https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/mutable/MutableInt.html class MutableInt]

=Code To Implement=
==ClassicReducer==
The classic MapReduce approach always uses a List of <code>V</code>s as its mutable container.  This abstract class will prove useful in this exercise and in future ones.

{{CodeToImplement|ClassicReducer|createMutableContainer<br>accumulate<br>combine|mapreduce.apps.reducer.classic.exercise}}

===createMutableContainer===
{{Sequential|List<V> createMutableContainer()}}

Construct a new instance of a List.  [https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html ArrayList] and [https://docs.oracle.com/javase/8/docs/api/java/util/LinkedList.html LinkedList] are two classes each of which implement the interface [https://docs.oracle.com/javase/8/docs/api/java/util/List.html List].

===accumulate===
{{Sequential|void accumulate(List<V> container, V item)}}

Mutate the specified <code>container</code> by [https://docs.oracle.com/javase/8/docs/api/java/util/List.html#add-E- adding] the specified <code>item</code>.

===combine===
{{Sequential|void combine(List<V> containerA, List<V> containerB)}}

Mutate the specified <code>containerA</code> by [https://docs.oracle.com/javase/8/docs/api/java/util/List.html#addAll-java.util.Collection- adding all] of the contents of the specified <code>containerB</code>.  Do NOT mutated containerB.

==Classic Summing Int==
{{CodeToImplement|SummingIntClassicReducer|reduce|mapreduce.apps.reducer.summingint.classic.exercise}}

{{Sequential|public Integer reduce(List<Integer> container)}}

The reduce method is passed a list of integers which it should simply sum up and return.

==Efficient Summing Int==
MapReduce Apps like Word Count offer glaring opportunities to optimize the classic MapReduce append all of the 1s in a List and add them up later.  SummingIntEfficientAccumulatorCombinerReducer will use [https://commons.apache.org/proper/commons-lang/apidocs/org/apache/commons/lang3/mutable/MutableInt.html MutableInt] to simply add the values as they come in.

{{CodeToImplement|SummingIntEfficientAccumulatorCombinerReducer|createMutableContainer<br>accumulate<br>combine<br>reduce|mapreduce.apps.reducer.summingint.efficient.exercise}}

{{Sequential|MutableInt createMutableContainer()}}

{{Sequential|void accumulate(MutableInt container, Integer item)}}

{{Sequential|void combine(MutableInt containerA, MutableInt containerB)}}

{{Sequential|reduce(MutableInt container)}}

=Testing Your Solution=
'''Note:''' in order to effectively assess this assignment, the testing leverages the WordCountMapper.  Be sure to correctly complete that assignment first.

{{TestSuite|_AccumulatorCombinerReducerTestSuite|mapreduce.apps}}