È eccessivo avvolgere una raccolta in una classe semplice solo per motivi di migliore leggibilità?

Ho la seguente mappa:

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

Questo HashMapmappa i doublevalori (che sono punti nel tempo) alla corrispondente SoundEvent"cella": ogni "cella" può contenere un numero di SoundEvents. Ecco perché è implementato come List<SoundEvent>, perché è esattamente quello che è.

Per motivi di migliore leggibilità del codice, ho pensato di implementare una classe interna statica molto semplice come questa:

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 rispetto alla dichiarazione della mappa (e molti altri codici) apparirebbe meglio, ad esempio:

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

Questo è eccessivo? Lo faresti nei tuoi progetti?

Non è affatto eccessivo. Inizia con le operazioni che ti servono, piuttosto che iniziare con "Posso usare una HashMap". A volte una HashMap è proprio ciò di cui hai bisogno.
Nel tuo caso sospetto che non lo sia. Quello che probabilmente vuoi fare è qualcosa del genere:

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

Sicuramente non vuoi avere un sacco di codice che dice questo:

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

O forse potresti semplicemente usare una delle implementazioni di Guava Multimap .

Mentre può aiutare nella leggibilità in alcune aree, può anche complicare le cose. Personalmente mi allontano dal confezionare o estendere le raccolte per motivi di fluidità, poiché il nuovo wrapper, alla lettura iniziale, implica per me che potrebbe esserci un comportamento di cui devo essere consapevole. Consideralo una sfumatura del Principio della minima sorpresa.

Attenersi all'implementazione dell'interfaccia significa che devo solo preoccuparmi dell'interfaccia. L'implementazione concreta può ovviamente comportare un comportamento aggiuntivo, ma non dovrei preoccuparmene. Quindi, quando sto cercando di trovare la mia strada attraverso il codice di qualcuno, preferisco le semplici interfacce per la leggibilità.

Se, d'altra parte, si sta trovando un caso d'uso che fa beneficio dal comportamento aggiunto, allora hai un argomento per migliorare il codice creando una classe pieno titolo.

L'avvolgimento limita la tua funzionalità solo ai metodi che decidi di decidere di scrivere, aumentando sostanzialmente il tuo codice senza alcun vantaggio. Per lo meno, proverei quanto segue:

private static class SoundEventCell : List<SoundEvent>
{
}

Puoi ancora scrivere il codice dal tuo esempio.

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

Detto questo, l'ho mai fatto solo quando ci sono alcune funzionalità di cui l'elenco stesso ha bisogno. Ma penso che il tuo metodo sarebbe eccessivo per questo. A meno che tu non abbia avuto un motivo per voler limitare l'accesso alla maggior parte dei metodi di List.

Un'altra soluzione potrebbe essere quella di definire la classe wrapper con un singolo metodo che espone l'elenco:

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

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

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

Questo ti dà la tua classe ben nominata con un codice minimo, ma ti dà comunque l'incapsulamento, permettendoti ad esempio di rendere immutabile la classe (facendo una copia difensiva nel costruttore e usando Collections.unmodifiableListnell'accessorio).

(Tuttavia, se questi elenchi vengono effettivamente utilizzati solo in questa classe, penso che faresti meglio a sostituire il tuo Map<Double, List<SoundEvent>>con un Multimap<Double, SoundEvent>( docs ), poiché ciò spesso salva molta logica ed errori di controllo null.)