Bir koleksiyonu sadece daha iyi okunabilirlik amacıyla basit bir sınıfa sarmak aşırı mıdır?

Aşağıdaki haritaya sahibim:

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

Bu, değerleri (zaman içindeki noktalar) karşılık gelen 'hücre' ile HashMapeşleştirir : her 'hücre' bir dizi s içerebilir . Bu yüzden a olarak uygulanır , çünkü tam olarak budur.doubleSoundEventSoundEventList<SoundEvent>

Kodun daha iyi okunabilmesi için şöyle basit bir statik iç sınıf uygulamayı düşündüm:

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
}

Harita beyanından (ve diğer birçok koddan) daha iyi görünür, örneğin:

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

Bu aşırı mı? Bunu projelerinizde yapar mısınız?

Hiç abartılı değil. "Bir HashMap Kullanabilirim" ile başlamak yerine, ihtiyacınız olan işlemlerle başlayın. Bazen bir HashMap tam ihtiyacınız olan şeydir.
Sizin durumunuzda olduğundan şüpheleniyorum. Muhtemelen yapmak istediğiniz şey şudur:

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

Kesinlikle bunu söyleyen bir kod grubuna sahip olmak istemezsiniz:

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

Ya da sadece Guava Multimap uygulamalarından birini kullanabilirsiniz .

Bazı alanlarda okunabilirliğe yardımcı olsa da, işleri de zorlaştırabilir. Kişisel olarak, akıcılık için koleksiyonları sarmaktan veya uzatmaktan uzağa yaslanıyorum, çünkü yeni ambalaj, ilk okumada, bilmem gereken davranışlar olabileceğini ima ediyor. En Az Sürpriz İlkesinin bir gölgesi olarak düşünün.

Arayüz uygulamasına bağlı kalmak, sadece arayüz hakkında endişelenmem gerektiği anlamına gelir. Somut uygulama, elbette, ek davranışlara ev sahipliği yapabilir, ancak bunun için endişelenmem gerekmiyor. Yani, birinin kodunu kullanarak yolumu bulmaya çalışırken, okunabilirlik için düz arayüzleri tercih ederim.

Öte yandan, bir kullanım durumunda buluyoruz ise yaptığı katma davranışından fayda, o zaman tam teşekküllü bir sınıf oluşturarak kod geliştirmek için bir argüman var.

Kaydırmak, işlevselliğinizi yalnızca yazmaya karar verdiğiniz yöntemlerle sınırlar ve temel olarak hiçbir faydası olmadan kodunuzu artırır. En azından aşağıdakileri deneyeceğim:

private static class SoundEventCell : List<SoundEvent>
{
}

Kodu yine de örneğinizden yazabilirsiniz.

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

Bununla birlikte, bunu yalnızca listenin kendisinin ihtiyaç duyduğu bazı işlevler olduğunda yaptım. Ama bence yönteminiz buna fazla gelebilir. List'in yöntemlerinin çoğuna erişimi sınırlamak istemeniz için bir nedeniniz olmadıkça.

Başka bir çözüm, sarmalayıcı sınıfınızı listeyi gösteren tek bir yöntemle tanımlamak olabilir:

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

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

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

Bu size iyi kodlanmış sınıfınızı en az kodla verir, ancak yine de kapsüllemeyi verir, örneğin sınıfı değiştirilemez hale getirmenize izin verir (yapıcıda savunma amaçlı bir kopya yaparak Collections.unmodifiableListve erişimcide kullanarak ).

(Ancak, bu listeler gerçekten sadece bu sınıfta kullanılıyorsa, bence yerine Map<Double, List<SoundEvent>>bir Multimap<Double, SoundEvent>( dokümanlar ) koymak daha iyi olur , çünkü bu genellikle çok sayıda boş denetleme mantığı ve hatası kaydeder.)