14

Is there a library that does this:

public class Iterables{
    private Iterables() {}

    public static <T> int sum(Iterable<T> iterable, Func<T, Integer> func) {
        int result = 0;
        for (T item : iterable)
            result += func.run(item);
        return result;
    }
}

public interface Func<TInput, TOutput> {
    TOutput run(TInput input);
}
ripper234
  • 222,824
  • 274
  • 634
  • 905

5 Answers5

10

Since Java 8 is now out getting a sum on collections is simple:

collection.stream().reduce(0, Integer::sum)

Unfortunately stream is not available on iterables but one can always convert. Arrays are easier:

LongStream.of(1, 2, 3).sum()
Andrejs
  • 26,885
  • 12
  • 107
  • 96
  • In Java 8, you could use StreamSupport.stream(values.spliterator(), false) to get a stream if "values" is of type Iterable – Milind Jul 19 '18 at 06:40
10

There are basically two useful libraries that can help with this; Google Guava and Apache Commons Collections.

What you are trying to do is basically two operations, first mapping, then reduction. I've never used Commons Collections to any extent myself so I can't tell you more about that, but I know there is no support for reduction (or folding) in Google Guava at least (see Issue 218). This is not too hard to add yourself though (not tested):

interface Function2<A, B> {
  B apply(B b, A a);
}

public class Iterables2 {
    public static <A, B> B reduce(Iterable<A> iterable,
      B initial, Function2<A, B> fun) {
        B b = initial;
        for (A item : iterable)
             b = fun.apply(b, item);
        return b;
    }
}

That way you can combine it with Guavas Iterables.transform() like so:

class Summer implements Function2<Integer, Integer> {
    Integer apply(Integer b, Integer a) {
        return b + a;
    }
}

class MyMapper<T> implements Function<T, Integer> {
    Integer apply(T t) {
      // Do stuff
    }
}

And then (provided you've import static'ed the relevant classes):

reduce(transform(iterable, new MyMapper()), 0, new Summer());

Also see this question.

Community
  • 1
  • 1
Henrik Gustafsson
  • 51,180
  • 9
  • 47
  • 60
9

Java is not a functional langugae and often it simpler and faster to just using a plain loop.

You could write something like

List<String> list = /* ... */
int totalLength = Iterables.sum(list, new Func<String, Integer>() {
    public Integer run(String input) {
        return input.length();
    }
});

however IMHO its shorter and simpler to just write.

List<String> list = /* ... */
int totalLength = 0;
for(String s: list) totalLength += s.length();

When closures become standard in Java, this will change but for now a loop is often the best way.

einpoklum
  • 118,144
  • 57
  • 340
  • 684
Peter Lawrey
  • 525,659
  • 79
  • 751
  • 1,130
  • 1
    Just remember though: `shorter != easier to read` , a cognitive bias most programmers aren't aware of. – Sridhar Sarnobat Apr 19 '16 at 17:41
  • @Sridhar-Sarnobat agreed which is something to watch out for when using lambda, esp nested lambdas. e.g `a -> b -> a > b` is short but not very clear. – Peter Lawrey Apr 19 '16 at 17:45
3

Functional Java has a sum method:

http://functionaljava.googlecode.com/svn/artifacts/3.0/javadoc/fj/function/Integers.html#sum%28fj.data.List%29

Here's an example: 

List<Integer> ints = new ArrayList<Integer>();
ints.add(1);
ints.add(2);
ints.add(3);
int sum = Integers.sum(fj.data.List.iterableList(ints));
eirirlar
  • 814
  • 6
  • 24
3

You could simply use Lamdaj - a library to manipulate collections in a pseudo-functional and statically typed way:

sum = Lambda.sum(iterable);

It can also do other types of aggregation or you can addd you own Aggregators:

sum = Lambda.aggregate(seq, new InitializedPairAggregator<Integer>(0) {
    protected Integer aggregate(Integer first, Integer second) {
        return first + second;
    }
});

See Features for other examples.

Andrejs
  • 26,885
  • 12
  • 107
  • 96