SummingForFun.java

package sandbox;

import java.util.Arrays;
import java.util.Collections;
import java.util.EnumSet;
import java.util.Iterator;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class SummingForFun {

    public static void main(String args[]) {
        List<Double> numbersList = Arrays.asList(1d, 3d, 5.5d);
        System.out.println(forSum(numbersList));
        System.out.println(foreachSum(numbersList));
        System.out.println(iteratorSum(numbersList));
        System.out.println(streamSum(numbersList));
        System.out.println(streamSumming(numbersList));
        System.out.println(streamReducing(numbersList));
        System.out.println(streamCollecting(numbersList));
        double[] numbersArray = new double[] { 1d, 3d, 5.5d };
        System.out.println(forSum(numbersArray));
        System.out.println(foreachSum(numbersArray));
        System.out.println(streamSum(numbersArray));
    }

    private static double forSum(List<Double> numbers) {
        double accum = 0;
        for (int i = 0; i < numbers.size(); i++) {
            accum += numbers.get(i);
        }
        return accum;
    }

    private static double foreachSum(List<Double> numbers) {
        double accum = 0;
        for (double number : numbers) {
            accum += number;
        }
        return accum;
    }

    private static double iteratorSum(List<Double> numbers) {
        double accum = 0;
        for (Iterator<Double> it = numbers.iterator(); it.hasNext(); ) {
            accum += it.next();
        }
        return accum;
    }

    private static double streamSum(List<Double> numbers) {
        return numbers.stream().mapToDouble(Double::doubleValue).sum();
    }

    private static double streamSumming(List<Double> numbers) {
        return numbers.stream().collect(Collectors.summingDouble(Double::doubleValue));
    }

    private static double streamReducing(List<Double> numbers) {
        return numbers.stream().collect(Collectors.reducing(0d, (l, r) -> l + r));
    }

    private static Double streamCollecting(List<Double> numbers) {
        return numbers.stream().collect(new Collector<Double, double[], Double>() {
            @Override
            public Supplier<double[]> supplier() {
                return () -> new double[] { 0d };
            }

            @Override
            public BiConsumer<double[], Double> accumulator() {
                return (accum, value) -> accum[0] += value;
            }

            @Override
            public BinaryOperator<double[]> combiner() {
                return (left, right) -> {
                    left[0] += right[0];
                    return left;
                };
            }

            @Override
            public Function<double[], Double> finisher() {
                return accum -> accum[0];
            }

            @Override
            public Set<Characteristics> characteristics() {
                return Collections.unmodifiableSet(EnumSet.of(
                        Characteristics.CONCURRENT,
                        Characteristics.UNORDERED
                ));
            }
        });
    }

    private static double forSum(double[] numbers) {
        double accum = 0;
        for (int i = 0; i < numbers.length; i++) {
            accum += numbers[i];
        }
        return accum;
    }

    private static double foreachSum(double[] numbers) {
        double accum = 0;
        for (double number : numbers) {
            accum += number;
        }
        return accum;
    }

    private static double streamSum(double[] numbers) {
        return Arrays.stream(numbers).sum();
    }
}