มันมากเกินไปที่จะห่อคอลเลกชันในชั้นเรียนที่เรียบง่ายเท่านั้นเพื่อประโยชน์ในการอ่านที่ดีขึ้น?

ฉันมีแผนที่ดังต่อไปนี้:

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

นี้HashMapแมdoubleค่า (ซึ่งเป็นคะแนนในเวลา) เพื่อที่สอดคล้องกันSoundEvent'มือถือ': แต่ละเซลล์สามารถมีจำนวนSoundEvents นั่นเป็นสาเหตุที่มันถูกนำมาใช้เป็นList<SoundEvent>เพราะนั่นคือสิ่งที่มันเป็น

เพื่อประโยชน์ในการอ่านรหัสได้ดีขึ้นฉันจึงคิดถึงการใช้คลาสภายในแบบคงที่ที่ง่ายมากเช่น:

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
}

และกว่าการประกาศแผนที่ (และรหัสอื่น ๆ อีกมากมาย) จะดูดีขึ้นเช่น:

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

นี่มันมากไปไหม? คุณจะทำสิ่งนี้ในโครงการของคุณหรือไม่

มันไม่ได้เกินความจริงเลย เริ่มต้นด้วยการดำเนินการที่คุณต้องการแทนที่จะเริ่มต้นด้วย "ฉันสามารถใช้ HashMap" ได้ บางครั้ง HashMap ก็เป็นสิ่งที่คุณต้องการ
ในกรณีของคุณฉันสงสัยว่ามันไม่ใช่ สิ่งที่คุณอาจต้องการทำคือสิ่งนี้:

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

แน่นอนคุณไม่ต้องการมีโค้ดจำนวนมากที่พูดสิ่งนี้:

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

หรือบางทีคุณอาจใช้Guava Multimap implementations อย่างใดอย่างหนึ่ง

ในขณะที่มันอาจช่วยในการอ่านในบางพื้นที่ก็ยังสามารถทำให้สิ่งต่าง ๆ ที่ซับซ้อน ฉันเอนตัวออกห่างจากการห่อหรือขยายคอลเลกชันเพื่อความคล่องแคล่วในฐานะที่เป็นเสื้อคลุมตัวใหม่ในการอ่านครั้งแรกหมายถึงฉันว่าอาจมีพฤติกรรมที่ฉันต้องระวัง ถือว่าเป็นเงาของหลักการแห่งความประหลาดใจน้อยที่สุด

การผสานกับการใช้อินเทอร์เฟซหมายความว่าฉันเพียงแค่ต้องกังวลเกี่ยวกับอินเทอร์เฟซ แน่นอนว่าการติดตั้งที่เป็นรูปธรรมอาจทำให้เกิดพฤติกรรมเพิ่มเติม แต่ฉันไม่ควรกังวลเกี่ยวกับมัน ดังนั้นเมื่อฉันพยายามหาทางผ่านรหัสของใครบางคนฉันชอบอินเตอร์เฟซธรรมดาสำหรับการอ่าน

หากในมืออื่น ๆ ที่คุณกำลังหากรณีการใช้งานที่ไม่ได้รับประโยชน์จากพฤติกรรมเพิ่มแล้วคุณมีข้อโต้แย้งสำหรับการปรับปรุงรหัสโดยการสร้างชั้นเต็มเปี่ยม

การตัดมัน จำกัด ฟังก์ชั่นของคุณเฉพาะวิธีที่คุณตัดสินใจที่จะเขียนโดยทั่วไปการเพิ่มโค้ดของคุณโดยไม่มีประโยชน์ อย่างน้อยที่สุดฉันจะลองทำสิ่งต่อไปนี้:

private static class SoundEventCell : List<SoundEvent>
{
}

คุณยังสามารถเขียนรหัสจากตัวอย่างของคุณได้

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

ที่กล่าวว่าฉันเคยทำเมื่อมีฟังก์ชั่นบางอย่างที่รายการต้องการ แต่ฉันคิดว่าวิธีการของคุณจะ overkill นี้ ถ้าคุณไม่มีเหตุผลที่ต้องการ จำกัด การเข้าถึงวิธีการส่วนใหญ่ของรายการ

โซลูชันอื่นอาจกำหนดคลาส wrapper ของคุณด้วยเมธอดเดียวซึ่งแสดงรายการ:

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

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

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

สิ่งนี้จะช่วยให้คุณมีคลาสที่มีชื่อรหัสน้อยที่สุด แต่ยังช่วยให้คุณมีแค็ปซูลช่วยให้คุณสามารถทำให้คลาสนั้นไม่เปลี่ยนรูป (โดยการทำสำเนาการป้องกันในตัวสร้างและการใช้งานCollections.unmodifiableListใน accessor)

( แต่ถ้ารายการเหล่านี้เป็นจริงเพียง แต่ถูกนำมาใช้ในชั้นนี้ผมคิดว่าคุณควรจะทำดีกว่าที่จะมาแทนที่ของคุณMap<Double, List<SoundEvent>>ด้วยMultimap<Double, SoundEvent>( เอกสาร ) เช่นที่มักจะบันทึกจำนวนมากของตรรกะ null การตรวจสอบและข้อผิดพลาด.)