É um exagero agrupar uma coleção em uma classe simples apenas por uma questão de melhor legibilidade?

Eu tenho o seguinte mapa:

Map<Double, List<SoundEvent>> soundEventCells = new HashMap<Double, List<SoundEvent>>();

Isso HashMapmapeia doublevalores (que são pontos no tempo) para a SoundEvent'célula' correspondente : cada 'célula' pode conter um número de SoundEvents. É por isso que é implementado como um List<SoundEvent>, porque é exatamente o que é.

Por uma questão de melhor legibilidade do código, pensei em implementar uma classe interna estática muito simples assim:

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
}

E que a declaração do mapa (e muitos outros códigos) ficaria melhor, por exemplo:

Map<Double, SoundEventCell> soundEventCells = new HashMap<Double, SoundEventCell>();

Isso é um exagero? Você faria isso em seus projetos?

Não é um exagero. Comece com as operações necessárias, em vez de começar com "Eu posso usar um HashMap". Às vezes, um HashMap é exatamente o que você precisa.
No seu caso, suspeito que não. O que você provavelmente quer fazer é algo como isto:

public class EventsByTime {
    public EventsByTime addEvent(double time, SoundEvent e);
    public List<SoundEvent> getEvents(double time);
    // ... more methods specific to your use ...
}

Você definitivamente não quer ter um monte de código dizendo isso:

List<SoundEvent> events = eventMap.get(time);
if (events == null) {
   events = new ArrayList<SoundEvent>();
   eventMap.put(time, events);
}

Ou talvez você possa apenas usar uma das implementações do Guava Multimap .

Embora possa ajudar na legibilidade em algumas áreas, também pode complicar as coisas. Pessoalmente, evito envolver ou estender coleções por motivos de fluência, pois o novo invólucro, na leitura inicial, implica para mim que pode haver um comportamento do qual preciso estar ciente. Considere um tom de princípio da menor surpresa.

Aderir à implementação da interface significa que só preciso me preocupar com a interface. A implementação concreta pode, é claro, abrigar um comportamento adicional, mas não preciso me preocupar com isso. Então, quando estou tentando encontrar o caminho através do código de alguém, prefiro as interfaces simples para facilitar a leitura.

Se, por outro lado, você estiver encontrando um caso de uso que se beneficia de um comportamento adicionado, terá um argumento para melhorar o código criando uma classe de pleno direito.

O agrupamento limita sua funcionalidade apenas aos métodos que você decide escrever, basicamente aumentando seu código sem nenhum benefício. No mínimo, tentaria o seguinte:

private static class SoundEventCell : List<SoundEvent>
{
}

Você ainda pode escrever o código do seu exemplo.

Map<Double, SoundEventCell> soundEventCells = new HashMap<Double, SoundEventCell>();

Dito isto, só fiz isso quando há alguma funcionalidade que a própria lista precisa. Mas acho que seu método seria um exagero para isso. A menos que você tenha um motivo para querer limitar o acesso à maioria dos métodos da Lista.

Outra solução pode ser definir sua classe de wrapper com um único método que expõe a lista:

private static class SoundEventCell
{
    private List<SoundEvent> events;

    public SoundEventCell(List<SoundEvent> events)
    {
        this.events = events;
    }

    public List<SoundEvent> getEvents()
    {
        return events;
    }
}

Isso fornece a sua classe bem nomeada com código mínimo, mas ainda fornece encapsulamento, permitindo, por exemplo, tornar a classe imutável (fazendo uma cópia defensiva no construtor e usando Collections.unmodifiableListno acessador).

(No entanto, se essas listas realmente estiverem sendo usadas apenas nesta classe, acho que seria melhor substituí-lo Map<Double, List<SoundEvent>>por um Multimap<Double, SoundEvent>( docs ), pois isso geralmente salva muita lógica e erros de verificação nula.)