Re: ArrayList grouping?

news.t-com.hr wrote:

[...]


There are many solutions to your problem possible.

One, a kind of general solution, may be using the following simple utility:

import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;

/**
  * @param <E> the type of elements being grouped
  * @param <K> the type of grouping key
  * @param <V> the type of value associated with each group
  */
public abstract class Grouper<E, K, V>
{
   private static class ValueHolder<V>
   {
     V value;

     ValueHolder(V value)
     {
       this.value = value;
     }
   }

   private Map<K, ValueHolder<V>> map = new HashMap<K, ValueHolder<V>>();

   protected abstract K keyOf(E e);
   protected abstract V createValue(E e, K key);
   protected abstract V updateValue(E e, K key, V value);

   public void add(E e)
   {
     K key = keyOf(e);
     ValueHolder<V> valueHolder = map.get(key);
     if (valueHolder == null)
     {
       valueHolder = new ValueHolder<V>(createValue(e, key));
       map.put(key, valueHolder);
     }
     else
     {
       valueHolder.value = updateValue(e, key, valueHolder.value);
     }
   }

   public Map<K, V> toMap()
   {
     Map<K, V> res = new HashMap<K, V>();
     for (Entry<K, ValueHolder<V>> e : map.entrySet())
     {
       res.put(e.getKey(), e.getValue().value);
     }
     return res;
   }

}

The implementation provided may be redesigned and/or improved depending
on needs (especially implementing Iterable<Entry<K, V>> to allow direct
iteration of the inner map might be useful). But the idea presented
seems to be flexible enough in many typical grouping scenarios.

Below is an example based on your initial posting demonstrating intended
use of my simple utility:

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map.Entry;

public class GrouperDemo
{

   static class Example
   {
     Date date;
     Integer no;
     Integer salary;

     static final DateFormat dateFmt = new SimpleDateFormat("d.M.y");

     Example(String date, Integer no, Integer salary)
         throws ParseException
     {
       this(dateFmt.parse(date), no, salary);
     }

     Example(Date date, Integer no, Integer salary)
     {
       this.date = date;
       this.no = no;
       this.salary = salary;
     }

     @Override
     public String toString()
     {
       return String.format("[%tF, %s, %s]", date, no, salary);
     }
   }

   static class DateNo
   {
     Date date;
     Integer no;

     DateNo(Date date, Integer no)
     {
       this.date = date;
       this.no = no;
     }

     @Override
     public boolean equals(Object obj)
     {
       return obj instanceof DateNo && equals((DateNo) obj);
     }

     public boolean equals(DateNo other)
     {
       return date.equals(other.date) && no.equals(other.no);
     }

     @Override
     public int hashCode()
     {
       return date.hashCode() ^ no.hashCode();
     }

     @Override
     public String toString()
     {
       return String.format("[%tF, %s]", date, no);
     }
   }

   public static void main(String[] args) throws Exception
   {
     List<Example> list
       = Arrays.asList(
         new Example("01.01.2009", 1, 10000),
         new Example("02.01.2009", 1, 20000),
         new Example("01.01.2009", 2, 30000));

     System.out.println(list);

     Grouper<Example, Date, Integer> gruper1
       = new Grouper<Example, Date, Integer>()
     {

       @Override
       protected Date keyOf(Example e)
       {
         return e.date;
       }

       @Override
       protected Integer createValue(Example e, Date key)
       {
         return e.salary;
       }

       @Override
       protected Integer updateValue(Example e, Date key, Integer value)
       {
         return value + e.salary;
       }

     };

     Grouper<Example, DateNo, Integer> gruper2
       = new Grouper<Example, DateNo, Integer>()
     {

       @Override
       protected DateNo keyOf(Example e)
       {
         return new DateNo(e.date, e.no);
       }

       @Override
       protected Integer createValue(Example e, DateNo key)
       {
         return e.salary;
       }

       @Override
       protected Integer updateValue(Example e, DateNo key,
           Integer value)
       {
         return value + e.salary;
       }

     };

     for (Example e : list)
     {
       gruper1.add(e);
       gruper2.add(e);
     }

     List<DateNo> res1 = new ArrayList<DateNo>();
     for (Entry<Date, Integer> e : gruper1.toMap().entrySet())
     {
       res1.add(new DateNo(e.getKey(), e.getValue()));
     }

     List<Example> res2 = new ArrayList<Example>();
     for (Entry<DateNo, Integer> e : gruper2.toMap().entrySet())
     {
       res2.add(
           new Example(e.getKey().date, e.getKey().no, e.getValue()));
     }

     System.out.println(res1);
     System.out.println(res2);
   }
}

piotr