Pfthb

I am trying partition a list into multiple sublists based on a condition that sum of a particular field should be less than 'x'. Below is sameple code:

public class TestGrouping {
 public static class Transaction
 String txnId;
 String comment;
 Amount amount;

 public Transaction(String txnId, String comment, Amount amount) 
 this.txnId = txnId;
 this.comment = comment;
 this.amount = amount;
 


public static class Amount
 String amountValue;

 public Amount(String amountValue) 
 this.amountValue = amountValue;

 

public static void main(String args) 
 List<Transaction> transactionList = new ArrayList<>();
 Transaction txn1 = new Transaction("T1","comment1",new Amount("81"));
 Transaction txn2 = new Transaction("T2","comment2",new Amount("5"));
 Transaction txn3 = new Transaction("T3","comment3",new Amount("12"));
 Transaction txn4 = new Transaction("T4","comment4",new Amount("28"));
 transactionList.add(txn1);
 transactionList.add(txn2);
 transactionList.add(txn3);
 transactionList.add(txn4);

//below is what i thought might work
// transactionList.stream().collect(groupingBy (r->Collectors.summingInt(Integer.valueOf(r.amount.amountValue)),Collectors.mapping(t -> t, toList())));

The goal is to split the transactionList into 2 (or more) sublists - where the sum of 'amount' is less than 100. So i could have a sublist have only txn1 - having amount as 81; and the other sublist have txn2, txn3, txn4 (as sum of these is less 100). Other possibility is - have sublist1 having txn1, txn2, txn3; and another sublist with just txn4. Not trying to create the most 'optimal' lists basically, just that sum of amounts should be less than 100.

Any clues?

The Idea is to use a custom collector to generate a list of pair(amountSum, transactions), the list should initialy be sorted. The accumulator method (here Accumulator.accept) do the grouping logic, I didn't implement combine because there is no need for a combiner in non parallel stream.
Bellow the code snippet, hope it helps.

 public class TestStream 

 public class Transaction 
 String txnId;
 String comment;
 Amount amount;

 public Transaction(String txnId, String comment, Amount amount) 
 this.txnId = txnId;
 this.comment = comment;
 this.amount = amount;
 
 

 public class Amount 
 String amountValue;

 public Amount(String amountValue) 
 this.amountValue = amountValue;

 
 

 @Test
 public void test() 
 List<Transaction> transactionList = new ArrayList<>();
 Transaction txn1 = new Transaction("T1", "comment1", new Amount("81"));
 Transaction txn2 = new Transaction("T2", "comment2", new Amount("5"));
 Transaction txn3 = new Transaction("T3", "comment3", new Amount("12"));
 Transaction txn4 = new Transaction("T4", "comment4", new Amount("28"));
 transactionList.add(txn1);
 transactionList.add(txn2);
 transactionList.add(txn3);
 transactionList.add(txn4);

 transactionList.stream()
 .sorted(Comparator.comparing(tr -> Integer.valueOf(tr.amount.amountValue)))
 .collect(ArrayList<Pair<Integer, List<Transaction>>>::new, Accumulator::accept, (x, y) -> 
 )
 .forEach(t -> 
 System.out.println(t.left);
 );
 

 static class Accumulator 
 public static void accept(List<Pair<Integer, List<Transaction>>> lPair, Transaction tr) lastPair.left + amount > 100) 
 lPair.add(
 new TestStream().new Pair<Integer, List<Transaction>>(amount,
 Arrays.asList(tr)));
 else 
 List<Transaction> newList = new ArrayList<>();
 newList.addAll(lastPair.getRight());
 newList.add(tr);
 lastPair.setLeft(lastPair.getLeft() + amount);
 lastPair.setRight(newList);
 
 
 

 class Pair<T, V> 
 private T left;
 private V right;

 /**
 * 
 */
 public Pair(T left, V right) 
 this.left = left;
 this.right = right;
 

 public V getRight() 
 return right;
 

 public T getLeft() 
 return left;
 

 public void setLeft(T left) 
 this.left = left;
 

 public void setRight(V right) 
 this.right = right;