Hey everyone, I have the following list in my code

public class order {
    private float amount;

    public float getAmount() {
        return this.amount;
    }
}

and in main function I have the following list

List<List<Order>> ordersList

I want to iterate the list through Streams in java 8 in order to calculate the total amount of all the orders. How do I do that? Please help

i solved it with the following code

ordersList.stream().map(x->x.getOrdersList())
                .collect(Collectors.toList())
                .stream()
                .flatMap(l->l.stream()).mapToDouble(z->z.getAmount()).sum();

Welcome to Java 8!

That code seems to have acumulated some extra code, presumably from trial-and-error.

I took your code, added a litte constructor to Order, and set up some test data like this

        List<List<Order>> list = new ArrayList<>();

        List<Order> list1 = new ArrayList<>();
        List<Order> list2 = new ArrayList<>();

        list1.add(new Order(1));
        list2.add(new Order(2));
        list2.add(new Order(3));

        list.add(list1);
        list.add(list2);

now all it needs to sum all the amounts is to flatten the nested lists, convert the Orders to amounts, and sum them...

list.stream().
     flatMap(x -> x.stream()).
     mapToDouble(x -> x.getAmount()).
     sum();

That's quite likely. You are replacing low-level procedural code (loops etc) with higher-level declarative code. However, I think you would have to be processing a lot of data for any difference to be significant.
It gets a lot more interesting if you add one word..

list.parallelStream().
     flatMap(x -> x.stream()).
     mapToDouble(x -> x.getAmount()).
     sum();

now Java will use multiple threads to process parts of the data in parallel. Assuming you have multi-cpu hardware this can give you very significant gains, and the code is orders of magnitude easier than splitting it up and running loops in multiple threads yourself.

This question has already been answered. Start a new discussion instead.