I have the following map:Map<Double, List<SoundEvent>> soundEventCells = new HashMap<Double, List<SoundEvent>>();This HashMap maps double values (which are points in time) to the corresponding SoundEvent 'cell': each 'cell' can contain a number of SoundEvents. That's why it's implemented as a List<SoundEvent>, because that's exactly what it is.For the sake of better readability of the code, I thought about implementing a very simple static inner class like so:private static class SoundEventCell {    private List<SoundEvent> soundEvents = new ArrayList<SoundEvent>();    public void addEvent(SoundEvent event){        soundEvents.add(event);    }    public int getSize(){        return soundEvents.size();    }    public SoundEvent getEvent(int index){        return soundEvents.get(index);    }    // .. remove() method unneeded}And than the map declaration (and a lot of other code) would look better, for example:Map<Double, SoundEventCell> soundEventCells = new HashMap<Double, SoundEventCell>();Is this overkill? Would you do this in your projects?
Is it overkill to wrap a collection in a simple class only for the sake of better readability?
java;design;object oriented
It's not overkill at all.  Start with the operations you need, rather than starting with I can use a HashMap.  Sometimes a HashMap is just what you need.In your case I suspect it isn't.  What you probably want to do is something like this:public class EventsByTime {    public EventsByTime addEvent(double time, SoundEvent e);    public List<SoundEvent> getEvents(double time);    // ... more methods specific to your use ...}You definitely don't want to have a bunch of code saying this:List<SoundEvent> events = eventMap.get(time);if (events == null) {   events = new ArrayList<SoundEvent>();   eventMap.put(time, events);}Or maybe you could just use one of the Guava Multimap implementations.